阅读
barriers / 阅读 / 详情

java中常见的异常类

2023-07-17 22:17:49
TAG: ava ja java
共12条回复
英语范文
我来回答
max笔记

从异常类的继承架构图中可以看出：Exception 类扩展出数个子类，其中 IOException、RunntimeException 是较常用的两种。

习惯上将 Error 与 Exception 类统称为异常类，但这两者本质上还是有不同的。Error 类专门用来处理严重影响程序运行的错误，可是通常程序设计者不会设计程序代码去捕捉这种错误，其原因在于即使捕捉到它，也无法给予适当的处理，如 JAVA 虚拟机出错就属于一种 Error。

不同于 Error 类，Exception 类包含了一般性的异常，这些异常通常在捕捉到之后便可做妥善的处理，以确保程序继续运行，如 TestException7_2 里所捕捉到的 ArrayIndexOutOfBoundsException 就是属于这种异常。

RunntimeException 即使不编写异常处理的程序代码，依然可以编译成功，而这种异常必须是在程序运行时才有可能发生，例如：数组的索引值超出了范围。

与RunntimeException 不同的是，IOException 一定要编写异常处理的程序代码才行，它通常用来处理与输入/输出相关的操作，如文件的访问、网络的连接等。

当异常发生时，发生异常的语句代码会抛出一个异常类的实例化对象，之后此对象与 catch 语句中的类的类型进行匹配，然后在相应的 catch 中进行处理。

throwable

扩展资料：

Java异常的分类：

Java标准裤内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。


参考资料：百度百科-异常

苏州马小云

1. java.lang.nullpointerexception

这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话）

2. java.lang.classnotfoundexception

这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。

3. java.lang.arithmeticexception

这个异常的解释是"数学运算异常"，比如程序中出现了除以零这样的运算就会出这样的异常，对这种异常，大家就要好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。

4. java.lang.arrayindexoutofboundsexception

这个异常相信很多朋友也经常遇到过，异常的解释是"数组下标越界"，现在程序中大多都有对数组的操作，因此在调用数组的时候一定要认真检查，看自己调用的下标是不是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。

5. java.lang.illegalargumentexception

这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。

6. java.lang.illegalaccessexception

这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。

其他还有很多异常，我就不一一列举了，我要说明的是，一个合格的程序员，需要对程序中常见的问题有相当的了解和相应的解决办法，否则仅仅停留在写程序而不会改程序的话，会极大影响到自己的开发的。关于异常的全部说明，在api里都可以查阅。

算术异常类：ArithmeticExecption

空指针异常类：NullPointerException

类型强制转换异常：ClassCastException

数组负下标异常：NegativeArrayException

数组下标越界异常：ArrayIndexOutOfBoundsException

违背安全原则异常：SecturityException

文件已结束异常：EOFException

文件未找到异常：FileNotFoundException

字符串转换为数字异常：NumberFormatException

操作数据库异常：SQLException

输入输出异常：IOException

方法未找到异常：NoSuchMethodException

java.lang.AbstractMethodError

抽象方法错误。当应用试图调用抽象方法时抛出。

java.lang.AssertionError

断言错。用来指示一个断言失败的情况。

java.lang.ClassCircularityError

类循环依赖错误。在初始化一个类时，若检测到类之间循环依赖则抛出该异常。

java.lang.ClassFormatError

类格式错误。当Java虚拟机试图从一个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。

java.lang.Error

错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。

java.lang.ExceptionInInitializerError

初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。

java.lang.IllegalAccessError

违法访问错误。当一个应用试图访问、修改某个类的域（Field）或者调用其方法，但是又违反域或方法的可见性声明，则抛出该异常。

java.lang.IncompatibleClassChangeError

不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时，抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下，容易引发该错误。

java.lang.InstantiationError

实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.

java.lang.InternalError

内部错误。用于指示Java虚拟机发生了内部错误。

java.lang.LinkageError

链接错误。该错误及其所有子类指示某个类依赖于另外一些类，在该类编译之后，被依赖的类改变了其类定义而没有重新编译所有的类，进而引发错误的情况。

java.lang.NoClassDefFoundError

未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类，而找不到该类的定义时抛出该错误。

java.lang.NoSuchFieldError

域不存在错误。当应用试图访问或者修改某类的某个域，而该类的定义中没有该域的定义时抛出该错误。

java.lang.NoSuchMethodError

方法不存在错误。当应用试图调用某类的某个方法，而该类的定义中没有该方法的定义时抛出该错误。

java.lang.OutOfMemoryError

内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。

java.lang.StackOverflowError

堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。

java.lang.ThreadDeath

线程结束。当调用Thread类的stop方法时抛出该错误，用于指示线程结束。

java.lang.UnknownError

未知错误。用于指示Java虚拟机发生了未知严重错误的情况。

java.lang.UnsatisfiedLinkError

未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。

java.lang.UnsupportedClassVersionError

不支持的类版本错误。当Java虚拟机试图从读取某个类文件，但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候，抛出该错误。

java.lang.VerifyError

验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。

java.lang.VirtualMachineError

虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。

java.lang.ArithmeticException

算术条件异常。譬如：整数除零等。

java.lang.ArrayIndexOutOfBoundsException

数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。

java.lang.ArrayStoreException

数组存储异常。当向数组中存放非数组声明类型对象时抛出。

java.lang.ClassCastException

类造型异常。假设有类A和B（A不是B的父类或子类），O是A的实例，那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。

java.lang.ClassNotFoundException

找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。

java.lang.CloneNotSupportedException

不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。

java.lang.EnumConstantNotPresentException

枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象，但该枚举对象并不包含常量时，抛出该异常。

java.lang.Exception

根异常。用以描述应用程序希望捕获的情况。

java.lang.IllegalAccessException

违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法，而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。

java.lang.IllegalMonitorStateException

违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象（O）的监控器或者通知其他线程等待该对象（O）的监控器时，抛出该异常。

java.lang.IllegalStateException

违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态，而调用了该方法时，抛出该异常。

java.lang.IllegalThreadStateException

违法的线程状态异常。当县城尚未处于某个方法的合法调用状态，而调用了该方法时，抛出异常。

java.lang.IndexOutOfBoundsException

索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。

java.lang.InstantiationException

实例化异常。当试图通过newInstance()方法创建某个类的实例，而该类是一个抽象类或接口时，抛出该异常。

java.lang.InterruptedException

被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态，而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。

java.lang.NegativeArraySizeException

数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。

java.lang.NoSuchFieldException

属性不存在异常。当访问某个类的不存在的属性时抛出该异常。

java.lang.NoSuchMethodException

方法不存在异常。当访问某个类的不存在的方法时抛出该异常。

java.lang.NullPointerException

空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。

java.lang.NumberFormatException

数字格式异常。当试图将一个String转换为指定的数字类型，而该字符串确不满足数字类型要求的格式时，抛出该异常。

java.lang.RuntimeException

运行时异常。是所有Java虚拟机正常操作期间可以被抛出的异常的父类。

java.lang.SecurityException

安全异常。由安全管理器抛出，用于指示违反安全情况的异常。

java.lang.StringIndexOutOfBoundsException

字符串索引越界异常。当使用索引值访问某个字符串中的字符，而该索引值小于0或大于等于序列大小时，抛出该异常。

java.lang.TypeNotPresentException

类型不存在异常。当应用试图

S笔记

NullPointerException - 空指针引用异常

ClassCastException - 类型强制转换异常

IllegalArgumentException - 传递非法参数异常

ArithmeticException - 算术运算异常

ArrayStoreException - 向数组中存放与声明类型不兼容对象异常

IndexOutOfBoundsException - 下标越界异常

NegativeArraySizeException - 创建一个大小为负数的数组错误异常

NumberFormatException - 数字格式异常

SecurityException - 安全异常

UnsupportedOperationException - 不支持的操作异常

这些是常见的RunTimeException（运行时异常），也就是说，这些异常不需要强制声明会抛出

nicehost

打开jdk文档

所有Exception的父类都是java.lang.Throwable。

异常分成两种。

Error和Exception

而一般Error不是人为能处理的。像out of memory就是虚拟机空间不够时会报这个

而Exception分为运行时异常(RuntimeException)和非运行时异常.

运行时异常就是RuntimeException其子类的异常。像常用的空指针NullPointerException，数组溢出IndexOutOfBoundsExceptiont等。

非运行时是RuntimeException以外的异常。

如：IOException、SQLException等。

如要看异常类到相应的jdk下面找下面的子类即可。

北有云溪

AclNotFoundException, ActivationException, AlreadyBoundException, ApplicationException, AWTException, BackingStoreException, BadAttributeValueExpException, BadBinaryOpValueExpException, BadLocationException, BadStringOperationException, BrokenBarrierException, CertificateException, ClassNotFoundException, CloneNotSupportedException, DataFormatException, DatatypeConfigurationException, DestroyFailedException, ExecutionException, ExpandVetoException, FontFormatException, GeneralSecurityException, GSSException, IllegalAccessException, IllegalClassFormatException, InstantiationException, InterruptedException, IntrospectionException, InvalidApplicationException, InvalidMidiDataException, InvalidPreferencesFormatException, InvalidTargetObjectTypeException, InvocationTargetException, IOException, JAXBException, JMException, KeySelectorException, LastOwnerException, LineUnavailableException, MarshalException, MidiUnavailableException, MimeTypeParseException, MimeTypeParseException, NamingException, NoninvertibleTransformException, NoSuchFieldException, NoSuchMethodException, NotBoundException, NotOwnerException, ParseException, ParserConfigurationException, PrinterException, PrintException, PrivilegedActionException, PropertyVetoException, RefreshFailedException, RemarshalException, RuntimeException, SAXException, ScriptException, ServerNotActiveException, SOAPException, SQLException, TimeoutException, TooManyListenersException, TransformerException, TransformException, UnmodifiableClassException, UnsupportedAudioFileException, UnsupportedCallbackException, UnsupportedFlavorException, UnsupportedLookAndFeelException, URIReferenceException, URISyntaxException, UserException, XAException, XMLParseException, XMLSignatureException, XMLStreamException, XPathException

上面是所有的异常类，其实你可以去看api，Exception类的子类都是异常类你在api里可以看到详细的说明。

cloud123

NullPointerException,遇到无数次了！

牛云

从异常类的继承架构图中可以看出：Exception 类扩展出数个子类，其中 IOException、RunntimeException 是较常用的两种。

习惯上将 Error 与 Exception 类统称为异常类，但这两者本质上还是有不同的。Error 类专门用来处理严重影响程序运行的错误，可是通常程序设计者不会设计程序代码去捕捉这种错误，其原因在于即使捕捉到它，也无法给予适当的处理，如 JAVA 虚拟机出错就属于一种 Error。

不同于 Error 类，Exception 类包含了一般性的异常，这些异常通常在捕捉到之后便可做妥善的处理，以确保程序继续运行，如 TestException7_2 里所捕捉到的 ArrayIndexOutOfBoundsException 就是属于这种异常。

RunntimeException 即使不编写异常处理的程序代码，依然可以编译成功，而这种异常必须是在程序运行时才有可能发生，例如：数组的索引值超出了范围。

与RunntimeException 不同的是，IOException 一定要编写异常处理的程序代码才行，它通常用来处理与输入/输出相关的操作，如文件的访问、网络的连接等。

当异常发生时，发生异常的语句代码会抛出一个异常类的实例化对象，之后此对象与 catch 语句中的类的类型进行匹配，然后在相应的 catch 中进行处理。

throwable

扩展资料：

Java异常的分类：

Java标准裤内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

马老四

从异常类的继承架构图中可以看出：Exception 类扩展出数个子类，其中 IOException、RunntimeException 是较常用的两种。

习惯上将 Error 与 Exception 类统称为异常类，但这两者本质上还是有不同的。Error 类专门用来处理严重影响程序运行的错误，可是通常程序设计者不会设计程序代码去捕捉这种错误，其原因在于即使捕捉到它，也无法给予适当的处理，如 JAVA 虚拟机出错就属于一种 Error。

不同于 Error 类，Exception 类包含了一般性的异常，这些异常通常在捕捉到之后便可做妥善的处理，以确保程序继续运行，如 TestException7_2 里所捕捉到的 ArrayIndexOutOfBoundsException 就是属于这种异常。

RunntimeException 即使不编写异常处理的程序代码，依然可以编译成功，而这种异常必须是在程序运行时才有可能发生，例如：数组的索引值超出了范围。

与RunntimeException 不同的是，IOException 一定要编写异常处理的程序代码才行，它通常用来处理与输入/输出相关的操作，如文件的访问、网络的连接等。

当异常发生时，发生异常的语句代码会抛出一个异常类的实例化对象，之后此对象与 catch 语句中的类的类型进行匹配，然后在相应的 catch 中进行处理。

throwable

皮皮

从异常类的继承架构图中可以看出：Exception 类扩展出数个子类，其中 IOException、RunntimeException 是较常用的两种。

习惯上将 Error 与 Exception 类统称为异常类，但这两者本质上还是有不同的。Error 类专门用来处理严重影响程序运行的错误，可是通常程序设计者不会设计程序代码去捕捉这种错误，其原因在于即使捕捉到它，也无法给予适当的处理，如 JAVA 虚拟机出错就属于一种 Error。

不同于 Error 类，Exception 类包含了一般性的异常，这些异常通常在捕捉到之后便可做妥善的处理，以确保程序继续运行，如 TestException7_2 里所捕捉到的 ArrayIndexOutOfBoundsException 就是属于这种异常。

RunntimeException 即使不编写异常处理的程序代码，依然可以编译成功，而这种异常必须是在程序运行时才有可能发生，例如：数组的索引值超出了范围。

与RunntimeException 不同的是，IOException 一定要编写异常处理的程序代码才行，它通常用来处理与输入/输出相关的操作，如文件的访问、网络的连接等。

当异常发生时，发生异常的语句代码会抛出一个异常类的实例化对象，之后此对象与 catch 语句中的类的类型进行匹配，然后在相应的 catch 中进行处理。

throwable

扩展资料：

Java异常的分类：

Java标准裤内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

Java的发展现在已经成为了一个巨大趋势，源码时代看中其市场价值，为就业提供了很多机会。

大鱼炖火锅

Java异常的分类：

Java标准裤内建了一些通用的异常，这些类以Throwable为顶层父类。

Throwable又派生出Error类和Exception类。

错误：Error类以及他的子类的实例，代表了JVM本身的错误。错误不能被程序员通过代码处理，Error很少出现。因此，程序员应该关注Exception为父类的分支下的各种异常类。

异常：Exception以及他的子类，代表程序运行时发送的各种不期望发生的事件。可以被Java异常处理机制使用，是异常处理的核心。

wio

一、异常

异常:程序生病了

1.异常的分类

异常的超类Throwable，派生两个子类Error和Exception，

Error错误：一般是虚拟机生成脱出，程序员无法控制。

Exception异常：派生出RuntimeException运行异常

Exception:异常分类：

CheckedException检查时异常|编译时异常:是在编译时出现的,如果不处理,程序无法执行

RuntimeException运行时异常:是在程序运行的时候出现,简单的可以通过增强程序的健壮性来处理(if判断)

常见的运行时异常:

1.空指针 NullPointerException

2.数组索引越界 ArrayIndexOutOfBoundsException

3.类型转换异常 ClassCastException (引用数据类型父类|父接口引用强转为实现类|子类类型)

4.数学异常 ArithmeticException

5.负数异常 NegativeArraySizeException

6.数字格式异常 NumberFormatException

throw : 制造异常

2.异常的处理 （重点掌握）

遇到异常,不同的异常见名知意,非常直观,方便调试

如果遇到异常不处理,程序无法继续向下执行

throw : 制造异常

异常处理方式:

throws : 抛出异常

try..catch 捕获异常

try{

可能会出现异常的代码;

}catch(StringIndexOutOfBoundsException e){

e....

如果出现这个类型的异常,就执行的代码

}catch(NullPointerException e){

...

}catch(FileNotFoundException e){

..

}catch(Exception e){

....

}finally{

无论是否出现异常,肯定会执行的代码

}

1）异常都可以使用异常处理的2中方式进行处理

编译时异常必须使用这两种方式处理,运行时异常可以使用这两种方式也可以使用增强程序的健壮性

2）抛出异常,当前不处理,异常抛出到上一层,方法的内部把异常抛出到方法上面,谁调用这个方法,谁处理

3）异常捕获,在遇到异常的时候当前位置就处理,捕获某个异常对象,使用异常的功能

4）如果try中遇到异常了,try中下面的代码不会执行,直接去执行对应catch中的内容,如果没有遇到异常,正常执行所有的try中代码

5）一个try后可以跟一到多个catch,捕获小范围的异常catch写在上面,否则下面的catch执行不到

6）finally中的内容无论当前trycatch结构是否遇到异常都会执行其中的代码,与前面的try..catch是一个结构

3.异常的定义（自定义异常）

自定义异常:除了java提供的这些异常类以外,自定义异常类

要求的异常类要继承Exception|RuntimeException |等子类

例子：年龄不合法异常:处理年龄的时候使用

二、String类

String : 不可变长的字符序列

多字符串没有大小修改或拼接,灵活使用当前字符串对象String

StringBuilder : 可变长的字符序列,线程不安全,效率较高

单线程环境下,如果大量的对字符串做修改,推荐使用StringBuilder

StringBuffer : 可变长的字符序列,线程安全,效率较低

多线程环境下,需要保证线程安全的是哦户,如果大量的对字符串做修改,推荐使用StringBuffer

执行效率: StringBuilder > StringBuffer > String

1.String

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。

字符串常量:字符串常量池中出现,使用时会先检查常量池中是否存在这个字符串常量对象,如果直接使用,不存在创建新的字符串常量对象

通过构造器创建对象:new-->对象在堆中,每执行new都是新的对象

常用构造方法:

String(String original) 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。

字符串A.equals(z字符串B)：比较字符串内容是否相等

String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。

String(char[] value, int offset, int count) 分配一个新的 String，它包含取自字符数组参数一个子数组的字符。

String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

String(byte[] bytes, String charsetName) 通过自定字符编码格式byte 数组，构造一个新的 String。

String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。

String(byte[] bytes, int offset, int length, String charsetName) 通过使用指定的字符集解码指定的 byte 子数组，构造一个新的 String。

String(StringBuffer buffer) 分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。

String(StringBuilder builder) 分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列。

常用方法：

char charAt(int index) 返回指定索引处的 char 值。

int codePointAt(int index) 返回指定索引处的字符（Unicode 代码点）

int compareTo(String anotherString) 按字典顺序比较两个字符串

int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写。

String concat(String str) 将指定字符串连接到此字符串的结尾。

boolean contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true。

static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。

static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String。

boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。

boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束

byte[] getBytes() 字符串转字节数组

byte[] getBytes(String charsetName)

int indexOf(int ch) 根据字符找索引,第一次出现

int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。

int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。

int length() 返回此字符串的长度。

String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。

String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。

String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。 结束索引endIndex不包含

char[] toCharArray() 将此字符串转换为一个新的字符数组。

String toUpperCase() 字符串转大写

String toLowerCase() 字符串转小写

String trim() 去前后空格

static String valueOf(int i) 返回 int 参数的字符串表示形式。

2.StringBuilder和StringBuffer

StringBuilder() 构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。

StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。

StringBuilder(int capacity) 构造一个其中不带字符的字符串生成器，初始容量由 capacity 参数指定。

int capacity() 初始容量

int length() 真实存储的字符个数

追加字符 append()

删除数据 StringBuilder delete(int start, int end) 结束索引不包含

插入数据StringBuilder insert(int offset, int i)

字符串反转StringBuilder reverse()

三、基本数据类型的包装类

byte --- Byte

short --- Short

int --- Integer

long --- Long

float --- Float

double--- Double

char --- Character

boolean --- Boolean

自动拆装箱:

自动装箱: 基本-->引用

自动拆箱: 引用-->基本

基本数据类型有各类型的常量池

如果缓冲区对象所能表示的范围之间[-128,127],返回缓冲区对象,否则返回new Integer

Integer类型无论是否是new的,和基本数据类型比较,会自动拆箱,只要值相同肯定相同

四、Date日期类

Date 日期类

构造器:

Date() 当前本机时间

Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

在java.util.Date日期类

long getTime()：获取对象从1970年开始到现在的毫秒数long类型

boolean after(Date when) 测试此日期是否在指定日期之后。

boolean before(Date when) 测试此日期是否在指定日期之前。

int compareTo(Date anotherDate) 比较两个日期的顺序。

boolean equals(Object obj) 比较两个日期的相等性。

五、SimpleDateFormat类 日期格式转换器

可以使用转换器的默认格式,指定转换格式

例子：SimpleDateFormat simple2=new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");

SimpleDateFormat simple3=new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");

日期对象-->字符串

字符串-->日期对象

y: 年

M: 月

d: 日

H: 24小时制

h: 12小时制

m: 分

s: 秒

S: 毫秒

format : 日期对象转为字符串

parse : 字符串转为日期对象

最后希望大家都能在理想的领域里实现择优就业~

CarieVinne

参见科技与人文网（网页链接），里面有Java相关问题以及解决方案，异常相关就有80多种，执行异常、异常跟类等等。

相关推荐

wiz note

throwable和Exception的区别(详细一点)

看下API:throwable:所有已实现的接口： Serializable直接已知子类： Error, ExceptionThrowable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息（比如堆栈跟踪数据）。 Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件
2023-07-17 16:44:432

catch,Throwable或Exception,有什么区别?？

catch n.捕捉,陷阱,捕获物 v.抓住；赶上,了解,感染 Throwable 可投掷的 exception n.例外 Please read: Java语言要求java程序中（无论是谁写的代码）所有抛出（throw）的异常都必须是从Throwable派生而来.当然,实际的Java编程中,由于JDK平台已经为我们设计好了非常丰富和完整的异常对象分类模型.因此,java程序员一般是不需要再重新定义自己的异常对象.而且即便是需要扩展自定义的异常对象,也往往会从Exception派生而来.所以,对于java程序员而言,它一般只需要在它的顶级函数中catch(Exception ex)就可以捕获出所有的异常对象.所有异常对象的根基类是 Throwable ,Throwable从Object直接继承而来（这是java系统所强制要求的）,并且它实现了 Serializable接口（这为所有的异常对象都能够轻松跨越Java组件系统做好了最充分的物质准备）.从Throwable直接派生出的异常类有Exception和Error .Exception是java程序员所最熟悉的,它一般代表了真正实际意义上的异常对象的根基类.也即是说,Exception 和从它派生而来的所有异常都是应用程序能够catch到的,并且可以进行异常错误恢复处理的异常类型.而Error则表示Java系统中出现了一个非常严重的异常错误,并且这个错误可能是应用程序所不能恢复的,例如LinkageError ,或 ThreadDeath 等.,1,catch,Throwable或Exception,有什么区别? I think I was asking about the java-Programming language instead of English,okay?
2023-07-17 16:45:021

Throwable的使用

使用Throwable一个很大的好处在于，他能保存他被实例化的方法的堆栈信息，通过方法： 可以将他和他的cause Throwable和他的cause的cause...( 递归 ) 的堆栈信息都打印出来。 而例如我们要将一个Throwable对象的堆栈信息不仅仅是输出到控制台，还要保存到本地日志或者发送到服务器呢？那么就要将Throwable的堆栈信息提取出来。 令人开心的是， android.util.Log 类提供了这么一个工具方法： 通过该方法，可以直接把 Throwable 对象的堆栈信息都拿出来了。 他有4个构造方法。每个构造方法都会调用 fillInStackTrace() 来记录当前的堆栈信息。 只有两个参数可选：String类型的message，和他的cause Throwable。 那么现在来看一下这两个变量对Throwable有什么用，以及对我们来说有什么意义。 先说结论： detailMessage 和 cause 变量在调用 printStackTrace() 的时候都会被打印出来。 看下 printStackTrace() 看下 toString 是如何包含 message 进来的： 看下打印cause: 可以发现， printEnclosedStackTrace() 方法中又调用了 getCause() 和 printEnclosedStackTrace() ，那么其实就是一个递归，直到递归到最根源的那个cause。 那么当我们要构造一个 Throwable 对象的时候，如果上下文中有一个关联的 Throwable ，那么把他作为cause参数来构造新的 Throwable 对象，这样能更好地记录问题真正的原因。
2023-07-17 16:45:091

Throwable的子类都有什么?

在elcipse里面，Throwable上按ctrl+T所有可抛出的异常类，都继承了这个类。。
2023-07-17 16:45:173

catch，Throwable或Exception，有什么区别？

catchnbsp;n.nbsp;捕捉,陷阱,捕获物nbsp;v.nbsp;抓住；赶上,了解,感染nbsp;Throwablenbsp;可投掷的nbsp;exceptionnbsp;n.nbsp;例外Pleasenbsp;read:http://www.gdglc.com/bbs/dispbbs.asp?boardid=11amp;ID=20790amp;replyID=20790Java语言要求java程序中（无论是谁写的代码）所有抛出（throw）的异常都必须是从Throwable派生而来。当然，实际的Java编程中，由于JDK平台已经为我们设计好了非常丰富和完整的异常对象分类模型。因此，java程序员一般是不需要再重新定义自己的异常对象。而且即便是需要扩展自定义的异常对象，也往往会从Exception派生而来。所以，对于java程序员而言，它一般只需要在它的顶级函数中catch(Exceptionnbsp;ex)就可以捕获出所有的异常对象。nbsp;所有异常对象的根基类是nbsp;Throwablenbsp;，Throwable从Object直接继承而来（这是java系统所强制要求的），并且它实现了nbsp;Serializable接口（这为所有的异常对象都能够轻松跨越Java组件系统做好了最充分的物质准备）。从Throwable直接派生出的异常类有Exception和Errornbsp;。Exception是java程序员所最熟悉的，它一般代表了真正实际意义上的异常对象的根基类。也即是说，nbsp;Exceptionnbsp;和从它派生而来的所有异常都是应用程序能够catch到的，并且可以进行异常错误恢复处理的异常类型。而Error则表示Java系统中出现了一个非常严重的异常错误，并且这个错误可能是应用程序所不能恢复的，例如LinkageErrornbsp;，或nbsp;ThreadDeathnbsp;等。 查看原帖>>
2023-07-17 16:45:312

throwable是类还是接口，请详细解释一下，谢谢！

是 接口，它继承了 Collection 接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作
2023-07-17 16:45:403

PHP 7异常与错误 —— Throwable

Throwable 是 PHP 7 中可以用作任何对象抛出声明的基本接口，包括 Expection （异常）和 Error （错误）。
2023-07-17 16:45:471

如何理解java.lang.Throwable

Throwable 是异常的根类所有异常类的根类, 下面又包含两大异常, Exception 还有 Error
2023-07-17 16:45:562

Java中,所有的异常的父类是那个?

Throwable是所有异常Exception和错误Error的祖先
2023-07-17 16:46:056

JAVA 中 Throwable是所有异常类的祖先 对吗？？？

记得好像所有的类都是object的子类...再看看别人怎么说的。
2023-07-17 16:46:266

java所有的异常类皆继承哪一个类

2023-07-17 16:46:543

java里的throw new throwable

抛出异常
2023-07-17 16:47:103

Throwable怎么读啊 java里的所有的子类啊

你们真NB，呵呵
2023-07-17 16:47:184

请问在java语言异常处理中的getCause（）方法的用法？

getCausepublicThrowablegetCause()返回此throwable的cause；如果cause不存在或未知，则返回null。（该Cause是导致抛出此throwable的throwable。）此实现返回由一个需要Throwable的构造方法提供的cause，或者在创建之后通过initCause(Throwable)方法进行设置的cause。虽然通常不需要重写此方法，但子类可以重写它，以返回一个通过某些其他方式设置的cause。这适用于在异常链（异常嵌套）机制被加入到Throwable之前存在“遗留Throwable链机制”的情况。注意，不必重写任何PrintStackTrace方法，所有方法都调用getCause方法来确定throwable的cause。返回：此throwable的cause，如果cause不存在或是未知的，则返回null。
2023-07-17 16:47:271

java中为何泛型类不能继承Throwable？

虚拟机的规格标准强制的规定的：JVM虚拟机目前没有实现捕捉“泛型的抛出对象”，捕捉机制只对非泛型类有效。泛型模板在编译时也会类型具体化。
2023-07-17 16:47:343

如何理解java.lang.Throwable

lang 是 language（语言） 的简写 是java中常用方法最多的包 包含常用类 软件包 java.lang 的描述提供利用 Java 编程语言进行程序设计的基础类。最重要的类是 Object（它是类层次结构的根）和 Class（它的实例表示正在运行的应用程序中的类）。
2023-07-17 16:47:411

应用技巧:Java中的异常处理

异常处理是初学者经常忽视执行的编程技巧。然而，当他们完成了一项大型项目后，就会发现仅仅停留在表面的工作是不够的。在本文中，我们将对异常处理进行讨论，并为大家解释其重要性，尤其是要告诉大家怎样处理这些情况。 　　首先，让我们解释一下什么是异常情况，通常也称例外。正如在其他的编程语言中那样，它也适用于Java：异常情况是那些在运行时出现错误的情况。这些错误并非真正的错误，因为他们是一些例外。我们可以将这些情况理解为必须解决的异常事件，否则程序将无法继续执行。所以我们就有必要了解怎样处理异常事件。 　　在异常事件的例子中最显著的应该是在程序执行时，运行时的分配变成了零。这样程序就无法执行，于是Java就会抛出一个异常事件，确切点说是ArithmeticException。从Java程序员的角度来看，异常事件是对象。抛出异常事件类似于抛出对象。但是，并非所有的对象都可以被抛出。 　　为了充分理解可抛出的异常事件，整个类层次结构的一些部分要被提交。主要的类称为Throwable。这个类拥有两个子类：Exception 和Error。一个异常事件对象应从Throwable的类中传出。意味着它应该是Exception子类或Error子类的一个对象实例。这些都可以在 java.lang数据包中找到。 　　异常处理就是捕捉可能在运行时被抛出的异常事件的一项技术。Java通过try-catch-finally的异常处理语句为我们提供了强大的异常处理解决方案。而在另一方面，你也可以使用已经声明的异常事件，如ArithmeticException, NullPointerException等。其他类扩展了Exception 类，如IOException子类。 　　此外，我们应该注意到异常事件包含了两种情况：检查过的和没检查的。技术上，我们认为没检查过的异常事件RuntimeExceptions。这些不需要在抛出的语句中作出声明，而且对它们的捕捉也是选择性的。不过，它们一般不会有什么影响，如果程序员根本不能发现它们的存在。在大多数情况下，这些都是逻辑性的编程错误，如NullPointerException或者ArrayIndexOutOfBounds。 　　同时，对异常事件进行技术性检查也迫使程序员对其进行处理和管理，意味着要对其进行单独捕捉并覆盖。这些都来自Exceptions类和它的子类，包括我们之前讨论过的RuntimeExceptions。检查过的异常事件要求异常事件处理因为它们有可能导致程序终止。 　　现在，我们对异常事件有了个基本的了解，下面就让我们启动集成开发环境开始编码吧! 　　异常处理 　　前面我们提到了异常处理就是指处理代码中的异常事件，或者在运行时向运行引擎抛出异常事件，在引擎末端它会搜索异常事件处理例程。它使用包含了一系列方法调用的调用堆栈进行搜索。 　　一般而言，异常事件可能因为包含一个异常活动或其他异步异常导致的。我们讨论的异常事件包括了一些基本的处理议题：怎样捕捉和处理这些异常事件。 　　Java允许我们创建自己的Exception对象和类，但是会有一个关键的请求。这些对象和类必须是扩展的Exception类。编码标准要求异常事件应该充分命名，意味着它们的名字就代表了其本身。 　　throw new Exception(“ This is an exception!”) 　　下面，我们看看要怎样捕捉和处理这些异常事件。检查以下代码： 　　try{ 　　// this is the block of code where the exception happens 　　// sometimes called as source/root of exception 　　// or even called as tricky block or tricky method 　　｝ 　　catch{Exception_Typel e) { 　　// dealing with this kind of exception 　　｝ 　　Catch (Exception_Type2 e) { 　　// dealing witn this kind of exception 　　｝ 　　//... unlimited number of catches are possible 　　finally { 　　// this block of code is always executed 　　｝ 　　try-catch-finally语句的第一个部分是尝试阻止。这是异常事件有可能发生的部分。通常，我们建议代码行用最小的数量来编写，因为它们只会在异常事件发生的时候执行。这种情况发生时，执行会跳转去捕捉那些异常事件被比较的块中。如果它们匹配，那么就可以处理异常事件。 　　不论尝试阻止的时候，异常事件会不会发生，或不管能不能得到处理，阻止总会执行。由于它总是被执行，所以我们推荐你在这里做一些清理。因此，正如所预料的那样，执行起来就是具有选择性的。 　　Try-catch模块的结构类似于switch-case的结构。在检查过的需要处理的异常事件中，是有可能在相同方法中将其处理或者抛出的。后者可以通过关键词抛出。在这种情况下，异常事件的种类必须在方法签名中被指定。看这个例子： 　　Void myMethod () throws SomeKindOfException{ 　　// method goes here 　　} 　　接下来，我们将为大家展示更多的异常处理实例。 　　初学者常常与非匹配数据类型纠缠不清。通常，它们会引发一些问题，例如，在做加法时出现非数字型代码。下面给大家展示的代码中，出现了异常处理的工作环境。检查该网页以完成嵌入式Exception种类的清单。现在，我们要处理NumberFormatException 的发生。 　　public static void main (String args[] ) { 　　double sum= 0; 　　for (int i=0; i﹤args. length; ++1) 　　try { 　　sum+= Double.parseDboule (args[i]); 　　} 　　Catch (NumberFormatException e) { 　　Ststem.out.printIn(args[i] + “non-numeric data on”); 　　} 　　System.out.printIn(“Total sum: “+ sum); 　　} 　　正如你所见到的，它和命令行参数一起运行，而且一旦轮到非数字型参数，它就会写入system.out，意指出现的问题。但是项目会继续进行，因为try模块是循环的。否则，没有合适的异常处理，项目就会终止。用这种方式总和还是可以计算处理并在最后显示处理。 　我们来看看另一个例子。在这个例子中，我们会要建立自己的异常实例类，该类扩展了其母Exception类。应用程序会模拟用于异常处理和抛出的堆栈机制，如堆栈是满的或者是空的。检查一下。 　　Public class StackException extends Exception { 　　Public StackException (String text) { 　　Super (text) 　　} 　　} 　　现在让我们创建一个Stack类。注意push和pop方法。它们正抛出StackException，而这一动作由方法签名导入。此外，还有一个if条件，且条件满足时，异常事件会被抛出。否则，一切都会顺利运行。 　　public class Stack { 　　private final int SIZE = 100; 　　private Object st[]; 　　private int size; 　　private int sp; 　　public Stack (int size) { 　　if (size < MAXSIZE) 　　this.size = size; 　　else 　　this.size = MAXSIZE; 　　this.st = new Object [size]; 　　this.sp = -1; 　　} 　　public void push (Object o) throws StackException { 　　if (sp == this.size - 1) 　　throw new StackException ("Stack is full"); 　　this.st [++this.sp] = o; 　　} 　　public Object pop () throws StackException { 　　if (sp == -1) 　　throw new StackException ("Stack is empty"); 　　Object o = this.st [this.sp]; 　　this.sp--; 　　return o; 　　} 　　public boolean isEmpty() { 　　return this.sp == -1; 　　} 　　} 　　好的，现在是时候写一写Main class连同主要方法了。在这一部分，请对try-catch语句给予更多关注。有两类异常情况可以被捕捉到。你也可以很容易地找出它们。 　　public class Main { 　　public static void main (String args[]) { 　　Stack s = new Stack (10); 　　for (int i = 0; i <= 10; ++i) 　　try { 　　s.push (new Integer(i)); 　　} 　　catch (StackException e) { 　　System.out.println (e); 　　} 　　while (! s.isEmpty() ) { 　　try { 　　System.out.println( (Integer)(s.pop()) ); 　　} 　　catch (StackException e) { 　　System.out.println(e); 　　} 　　} 　　} 　　} 　　当然，这里也会有附带输出。如你所见，第一行显示出的就是异常事件，因为我们要用11个要素填补堆栈，因此，在循环到isEmpty是错误的时，异常事件不会抛出。 　　Stack is full 　　练习几次以上的几段代码。如果异常事件被抛出但是却能够正确被处理那就不要感到惊讶。这就是异常处理的神奇之处。 　　总结 　　在这篇文章里我们就异常处理的实用性和重要性进行了分析。我们都知道，不管是检查过的或是未经检查的，程序员都要处理好异常事件，否则可能出现程序的异常终止。我们强调要将理论与实践相结合。坦率地说，本文虽只是冰山一角，但一些基本的知识已经介绍给了大家。希望能在异常处理方面对大家有所帮助。
2023-07-17 16:47:481

严重: StandardWrapper.Throwable

log4j-1.2.15.jar把这个包放在你装的tomcat下commonlib目录下就好了！
2023-07-17 16:47:573

Java的异常处理语法

catch(Exception e){处理语句}
2023-07-17 16:48:183

slf4j怎么打印java错误堆栈信息throwable对象

SLF4J 1.6.0　以前的版本，如果打印异常堆栈信息，必须用log.error(Stringmsg,Throwablet)log.info等对应方法．如果msg含有变量，一般用String.format方法格式化msg.如果用error(Stringformat,Object...arguments) 等其它方法，异常堆栈信息会丢失．幸好，SLF4J 1.6.0以后的版本对这个不友好的异常信息log　改进了．error(Stringformat,Object…arguments)　这个方法也会打印异常堆栈信息，只不过规定throwable对象必须为最后一个参数．如果不遵守这个规定，异常堆栈信息不会log出来．
2023-07-17 16:48:261

请问bug,error和Exception的区别

bug是指系统的漏洞，一般不会影响使用者使用error是指错误，如果发生error，则表示系统出现问题exception一般出现在编程语音中，指发生的异常
2023-07-17 16:48:363

java抛出异常： unknown

出现这个异常，表明向方法传递了不合法或不正确的参数。检查一下，是否在调用某个方法时，传递了与方法定义时不相符的参数类型。在SSM动态javaweb服务器框架中，经常看到这个异常，很多人说这是参数异常，检查自己在ioc容器中配置的参数是否正确，其实这是项目使用的Java编译器（即Javacompiler）使用的jdk版本和Java的运行环境（即jreJavaruntimeenvironment）版本不匹配造成的。扩展资料：类 Math 提供了常用的数学函数，比如正弦、余弦和平方根。类似地，类 String 和 StringBuffer 提供了常用的字符串操作。类 ClassLoader、Process、Runtime、SecurityManager 和 System 提供了管理类的动态加载、外部进程创建、主机环境查询（比如时间）和安全策略实施等“系统操作”。类 Throwable 包含了可能由 throw 语句抛出的对象(§14.16)。Throwable 的子类表示错误和异常。参考资料来源：百度百科-java.lang
2023-07-17 16:48:431

不兼容的类型: Exception无法转换为Throwable

Exception继承于Throwable 所以Exception能转化为Throwable ，Throwable 不能转化Exception
2023-07-17 16:49:011

求解：java.lang.IllegalArgumentException: No enum const class com.xxx.xxx.UserType.1 at java.

java.lang 类 IllegalArgumentExceptionjava.lang.Object java.lang.Throwable java.lang.Exception java.lang.RuntimeException java.lang.IllegalArgumentException所有已实现的接口： Serializable 直接已知子类： IllegalCharsetNameException, IllegalFormatException, IllegalSelectorException, IllegalThreadStateException, InvalidKeyException, InvalidOpenTypeException, InvalidParameterException, KeyAlreadyExistsException, NumberFormatException, PatternSyntaxException, UnresolvedAddressException, UnsupportedAddressTypeException, UnsupportedCharsetException --------------------------------------------------------------------------------public class IllegalArgumentExceptionextends RuntimeException抛出的异 常表明向方法传递了一个不合法或不正确的参数。 从以下版本开始： JDK1.0 另请参见：Thread.setPriority(int), 序列化表格--------------------------------------------------------------------------------构造方法摘要 IllegalArgumentException() 构造不带详细消息的 IllegalArgumentException。 IllegalArgumentException(String s) 构造带指定详细消息的 IllegalArgumentException。 IllegalArgumentException(String message, Throwable cause) 根据指定的详细消息和原因构造一个新异常。 IllegalArgumentException(Throwable cause) 根据指定的原因和 (cause==null ? null :cause.toString()) 的详细消息构造一个新异常（它通常包含 cause 的类和详细消息）。 方法摘要 从类 java.lang.Throwable 继承的方法 fillInStackTrace, getCause, getLocalizedMessage, getMessage, getStackTrace, initCause, printStackTrace, printStackTrace, printStackTrace, setStackTrace, toString 从类 java.lang.Object 继承的方法 clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait 构造方法详细信息 IllegalArgumentExceptionpublic IllegalArgumentException()构造不带详细消息的 IllegalArgumentException。 --------------------------------------------------------------------------------IllegalArgumentExceptionpublic IllegalArgumentException(String s)构造带指定详细消息的 IllegalArgumentException。 参数：s - 详细消息。--------------------------------------------------------------------------------IllegalArgumentExceptionpublic IllegalArgumentException(String message, Throwable cause)根据指定的详细消息和原因构造一个新异常。 注意，与 cause 相关的详细消息不是 自动合并到这个异常的详细消息中的。 参数：message - 详细消息（保存此消息，以便以后通过 Throwable.getMessage() 方法获取它）。cause - 原因（保存此原因，以便以后通过 Throwable.getCause() 方法获取它）。（允许使用 null 值，指出原因是不存在的或是未知的。）从以下版本开始： 1.5 --------------------------------------------------------------------------------IllegalArgumentExceptionpublic IllegalArgumentException(Throwable cause)根据指定的原因和 (cause==null ? null :cause.toString()) 的详细消息构造一个新异常（它通常包含 cause 的类和详细消息）。 此构造方法对于那些与其他 throwable（例如，PrivilegedActionException）的包装器相同的异常来说是有用的。 参数：cause - 原因（保存此原因，以便以后通过 Throwable.getCause() 方法获取它）。（允许使用 null 值，指出原因是不存在的或是未知的。）从以下版本开始： 1.5
2023-07-17 16:49:111

教您在Java开发过程中如何应对异常处理

早期的编程语言（比如C语言）没有异常处理，通常是遇到错误返回一个特殊的值或设定一个标志，并以此判断是不是有错误产生。随着系统规模的不断扩大，这种错误处理已经成为创建大型可维护程序的障碍了。于是在一些语言中出现了异常处理机制，比如在Basic中的异常处理语句“on error goto”，而Java则在C++基础上建立了新的异常处理机制。Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。这种机制为复杂程序提供了强有力的控制方式。同时这些异常代码与“常规”代码分离，增强了程序的可读性，编写程序时也显得更灵活。Java中的异常类在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Throwable类有两个标准子类：java.lang.Error和java.lang.Exception，即错误和异常。错误：Error类，一般是指虚拟机相关的问题，如系统崩溃、虚拟机出错误、动态链接失败等，这一类错误无法恢复或不可能捕获，将导致应用程序中断。异常：Exception类，则是指一些可以被捕获且可能恢复的异常情况，如数组下标越界Array，Index，OutOf，Bounds，Excepton。数字被零除产生异常：ArithmeticException 、输入/输出异常：IOException等。提示：Java编译器要求Java程序必须捕获或声明所有非运行时的异常，如：FileNotFoundException、IOException等。因为，对于这类异常来说，如果程序不进行处理，可能会带来意想不到的结果。但运行时出现异常可以不做处理，因为这类异常很普遍，全部处理可能对程序的可读性和运行效率产生影响。Java异常处理形式，Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。下面是Java异常处理程序的基本形式： try //执行时程序块 catch ExceptionType1e //对ExceptionType1的处理 catch ExceptionType2e //对ExceptionType2的处理 throw e //再抛出这个“异常” finally try程序块和catch语句：遇到一个try语句，“异常”的框架就放到堆栈上面，直到所有的try块内的语句都完成。如果下一级的try语句没有对某种“异常”进行处理，堆栈就会展开，直到遇到有处理这种“异常”的try语句。 在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型。提示：捕获异常的第一步就是用try … 选定你要捕获异常的范围，在执行时，括号内的代码会产生异常对象并被抛出。然后你就可以用catch块来处理异常了。 throw语句和throws语句：throw语句用来明确地抛出一个“异常”。首先，你必须得到一个Throwable类或其它子类产生的实例句柄，通过参数传到catch子句，或者用new语句来创建一个实例。 下面是throw语句的通常形式： throw ThrowableInstance，提示：执行throw语句后，运行流程将立即停止，throw的下一条语句也将暂停执行。这里new运算符用于创建一个Throwable类的实例，在后文的面向对象编程一文中将详细讲解。 throws语句用来标明一个成员函数可能抛出的各种“异常”。对大多数Exception子类来说，Java编译器会强迫你声明在一个成员函数中抛出的“异常”的类型。如果“异常”的类型是Error或RuntimeException，或它们的子类，这个规则不起作用。如果你想明确地抛出一个RuntimeException，你必须用throws语句来声明它的类型。 提示：当然，你可能对上面的说明不是很明白，不过不要紧，编译运行下面的Java程序（已经为你做了详细的注释）你会理解很多! 现在我们用下面的例程来说明问题： class ThrowsDemo //类名，相应的java源文件应该保存成： ThrowsDemo.javastatic void procedure throws IllegalAccessException //throws语句 //抛出IllegalAccessException类型的异常System.out.println ″inside procedure″ //输出文本信息，以说明是在执行procedure方法时抛出了异常throw new IllegalAccessException ″demo″ //新生成一个Throwable类实例，然后抛出异常 public static void main String args //main 方法开始，程序从此处执行 try //try语句块开始procedure //调用procedure方法，该方法将Throw（抛出）异常信息 catch IllegalAccessException e //处理IllegalAccessException类型的异常， catch语句块System.out.println ″caught ″ + e 编程并执行程序，其过程如下： E javacodeexception>java ThrowsDemoinside procedurecaught java.lang.IllegalAccessException demo提示：如上面的代码所示，我们用了一个完整的程序来说明在Java程序中如何使用try…catch…throw等语句。Try … 里产生的异常被捕获了下来，然后在catch块里进行处理（这里只是输出异常信息）。 throws IllegalAccessException标明程序将抛出一个IllegalAccessException类型的异常。IllegalAccessExceptione生成一个异常对象，然后用System.out.println输出异常信息。 finally语句，有时为了确保一段代码不管发生什么异常都要被执行，可以使用关键词finally来标出这样一段代码。一个成员函数返回到调用它的成员函数，或者通过一个没捕捉到的异常，或者通过一个明确的return语句，finally子句总是恰好在成员函数返回前执行。 下面我们以一个比较完整的异常处理程序来说明上面所述的各种异常处理语句的使用问题： class ExceptionDemo //异常使用示例，保存为ExceptionDemo.javastatic void procA try System.out.println ″inside procA″ throw new RuntimeException ″demo″ //抛出异常finally System.out.println ″procA"s finally″ //注意：不管发生什么等会执行!!static void procB try System.out.println ″inside procB″ return //返回，实际上是在finally语句执行完后才返回finally System.out.println ″procB"s finally″ public static void main String args try procA catch Exception e System.out.println ″catch ″+e procB提示：在上面的完整程序中，finally后的大括号内的代码是任何情况下都会执行的。另外，在procB中，return 语句并没有立即返回，这一点应该特别注意。你可以亲自动手，执行上面的程序试试（编译和执行类似于上例）。 到目前为止，关于Java的流程控制已经完全讲完了。要真正理解并掌握它们只有经过大量的练习。而好的方法就是修改上面的每一个程序，让它们实现你想要的功能，并在此基本上理解Java的流程控制。 而要写好Java程序，熟悉使用Java的流程控制和异常处理是非常关键的。
2023-07-17 16:49:191

我设置过环境变量，当时在运行程序的时候还是出现了：设置延迟的 未捕捉到 java.lang.Throwable

不知道你用没用IDE，Eclipse中的话，可能是类没有调用的问题不过还是检查下环境变量吧。。。
2023-07-17 16:50:084

error和exception有什么区别

二者的不同之处：Exception：1．可以是可被控制(checked) 或不可控制的(unchecked)2．表示一个由程序员导致的错误3．应该在应用程序级被处理Error：1．总是不可控制的(unchecked)2．经常用来用于表示系统错误或低层资源的错误3．如何可能的话，应该在系统级被捕捉
2023-07-17 16:50:174

slf4j怎么打印java错误堆栈信息throwable对象

打印堆栈直接用e.printtracestack()就可以了了
2023-07-17 16:50:383

在java中_____是所有异常类的父类，java中进行异常处理的语句是______

Throwable是所有异常的父类，处理语句：try{//代码块}catch(Exception e ){//代码块}finally{//代码块}
2023-07-17 16:50:482

有关Java的问题 Throwable中getMessage()干什么用的 问题：getMessage（）中为什么显示5

getMessage方法是用来取内置的消息的具体来说，就是你在new Exception的时候给的那个String参数
2023-07-17 16:50:562

java 中Throw能抛出的是什么？ A：ERROR B：Event C: Object D: Throwable E: Exception F: RunTimeExcepti

应该是E吧
2023-07-17 16:52:026

public void finalize() throws Throwable 不是在垃圾回收的时候强制调用的么,为什么运行不出来？

你的代码正确,这是我运行后的结果,你运行不出来第一种可能是:java的配置问题!第二种可能是:你当时运行的程序过多,当条用System.gc();//垃圾收集器时,并没有申请到系统的执行权,另外提醒你一下:为了提高垃圾回收器的执行权你可以在主线程中使用Thread.sleep(1000);让主线程休息1秒,可以大大提高此程序的执行权,你可以尝试一下!~~~如有疑问,共同探讨!望采纳~谢谢!!!
2023-07-17 16:52:241

Throwable的子类都有哪些?

有两个子类 :一、Error二、Exceptionthrowable和Exception的区别：一、Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。二、两个子类的实例，Error 和 Exception，通常用于指示发生了异常情况。通常，这些实例是在异常情况的上下文中新近创建的，因此包含了相关的信息（比如堆栈跟踪数据）。三、Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。
2023-07-17 16:52:491

java里的throw new throwable

分类: 电脑/网络 >> 程序设计 >> 其他编程语言 问题描述: try { int i=11/b; throw new Throwable("Here is my Exception")} ………… 请问throw new throwable是什么意思？ 解析: 抛出一个自定义的异常,这个异常被处理之后会得到, "Here is my Exception"这个值.
2023-07-17 16:52:581

tomcat 6 启动报错 SEVERE: createMBeans: Throwable

Caused by: java.lang.IllegalArgumentException: Invalid name->Catalina:type=NamingResources,resourcetype=Context,path=/,host=*这个配置有问题
2023-07-17 16:53:051

java所有的异常类皆继承哪一个类

个人认为你的答案是错误的，因为.java.lang.throwable是java.lang.exception的父类，所以所有的类应该都继承了throwable个类吧。你说的异常的类,是只能抽象类了.某子类c,父类p.如果p是普通的类,则c不必重写p内部的方法.重写是可选的.如果p抽象类
2023-07-17 16:53:152

请问在java语言异常处理中的getCause（）方法的用法？

getCause（)返回此异常的原因（尝试加载类时发生错误引发的异常；否则返回 null）。
2023-07-17 16:53:242

在JAVA中为什么字符转换为数值是会抛出异常？抛出什么异常？

抛出 NumberFormatException
2023-07-17 16:53:354

下列方法中，不属于Throwable类的方法是（　　）。

【答案】：CtoString是Object类的方法，所有类都从Object类继承。
2023-07-17 16:53:421

java.lang.IllegalArgumentException

应该是你传入参数据到你的pojo的类型或值有问题
2023-07-17 16:53:515

java的异常分类有哪些？

异常的分类：Throwable包含了错误(Error)和异常(Excetion两类)。Exception又包含了运行时异常(RuntimeException, 又叫非检查异常)和非运行时异常(又叫检查异常)。Error是程序无法处理了, 如果OutOfMemoryError、OutOfMemoryError等等, 这些异常发生时, java虚拟机一般会终止线程。运行时异常都是RuntimeException类及其子类,如 NullPointerException、IndexOutOfBoundsException等, 这些异常是不检查的异常, 是在程序运行的时候可能会发生的, 所以程序可以捕捉, 也可以不捕捉. 这些错误一般是由程序的逻辑错误引起的, 程序应该从逻辑角度去尽量避免。检查异常是运行时异常以外的异常, 也是Exception及其子类, 这些异常从程序的角度来说是必须经过捕捉检查处理的, 否则不能通过编译. 如IOException、SQLException等。
2023-07-17 16:54:061

严重: StandardWrapper.Throwable

能看懂一定给你说
2023-07-17 16:54:431

e.printStackTrace() ; 是什么意思？

捕获异常的语句：e.printStackTrace();1、e是Throwable的实例异常对象，用在catch语句中，相当于一个形参，一旦try捕获到了异常，那么就将这个异常信息交给e，由e处理，printStackTrace()是异常类的一个方法。与它重载的方法还有printStackTrace(PrintStream s) 和printStackTrace(PrintWriter s)。2、在Throwable类中printStackTrace()内部是这样执行的：public void printStackTrace() {printStackTrace(System.err);}3、它调用了printStackTrace(PrintStream s)方法。err是System类当中的一个静态PrintStream类型字段。所以它能传递进去。扩展资料public void printStackTrace()将此 throwable 及其追踪输出至标准错误流。此方法将此 Throwable 对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。输出的第一行包含此对象的 toString() 方法的结果。剩余行表示以前由方法 fillInStackTrace() 记录的数据。此信息的格式取决于实现，但以下示例是最常见的：java.lang.NullPointerExceptionat MyClass.mash(MyClass.java:9)at MyClass.crunch(MyClass.java:6)at MyClass.main(MyClass.java:3)参考资料百度百科-Java
2023-07-17 16:54:512

java的异常处理两种方式， super(msg);什么意思啊？

一、第一种定义方式，继承Exception类public class MyFirstException extends Exception {public MyFirstException() {super();}public MyFirstException(String msg) { super(msg);}public MyFirstException(String msg, Throwable cause) {super(msg, cause);}public MyFirstException(Throwable cause) {super(cause);}//自定义异常类的主要作用是区分异常发生的位置，当用户遇到异常时，//根据异常名就可以知道哪里有异常，根据异常提示信息进行修改。}二、 第二种定义方式：继承Throwable 类public class MySecondException extends Throwable {public MySecondException() {super();}public MySecondException(String msg) {super(msg);}public MySecondException(String msg, Throwable cause) {super(msg, cause);}public MySecondException(Throwable cause) {super(cause);}}
2023-07-17 16:55:171

java中exception的处理

有catch 就说明处理了 就算catch里面什么也不写 那也叫空处理 错误不会影响程序继续运行你说那个 叫 throw 是往外抛异常 如果外层没有处理 即外层没有 try catch 继续向外跑直到被处理 如果一直没处理 就会报错
2023-07-17 16:55:272

华为手机一直出现(错误原因null)怎么清除，有什么影响对手机

应该是自身软件运行出错，你关机了，等一个小时在开机。还可能是你安装的软件与系统软件冲突，你把你安装的软件卸载。
2023-07-17 16:55:351

java.lang.reflect.UndeclaredThrowableException怎么回事

JDK的java doc是这么解释UndeclaredThrowableException的：如果代理实例的调用处理程序的 invoke 方法抛出一个经过检查的异常（不可分配给 RuntimeException 或 Error 的 Throwable），且该异常不可分配给该方法的throws子局声明的任何异常类，则由代理实例上的方法调用抛出此异常。明白了什么是UndeclaredThrowableException后，就可以查找具体的代码。比方说测试环境不稳定，等待超时，抛出了一个TimeOutException，而这个TimeOutException不是业务方法所声明的异常，因此就被包装成UndeclaredThrowableException抛出了。
2023-07-17 16:55:501

public void Main() throws Throwable如何理解这里的异常抛出呢

有错误就往外抛异常，也没什么
2023-07-17 16:56:012

tomcat 启动抛出java.lang.IllegalArgumentException异常问题

C:Program FilesApache Software FoundationTomcat 6.0webappsswork这个目录不存在造成的问题。在你的程序里边搜索这个目录“swork”,或者查找配置文件中的该路径，初步怀疑是你的配置文件出的错误。多打了一个.s 默认应该是work。重装tomcat不会有任何帮助。
2023-07-17 16:56:106

e.printStackTrace() ; 是什么意思？

捕获异常的语句：e.printStackTrace();1、e是Throwable的实例异常对象，用在catch语句中，相当于一个形参，一旦try捕获到了异常，那么就将这个异常信息交给e，由e处理，printStackTrace()是异常类的一个方法。与它重载的方法还有printStackTrace(PrintStream s) 和printStackTrace(PrintWriter s)。2、在Throwable类中printStackTrace()内部是这样执行的：public void printStackTrace() {printStackTrace(System.err);}3、它调用了printStackTrace(PrintStream s)方法。err是System类当中的一个静态PrintStream类型字段。所以它能传递进去。扩展资料public void printStackTrace()将此 throwable 及其追踪输出至标准错误流。此方法将此 Throwable 对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。输出的第一行包含此对象的 toString() 方法的结果。剩余行表示以前由方法 fillInStackTrace() 记录的数据。此信息的格式取决于实现，但以下示例是最常见的：java.lang.NullPointerExceptionat MyClass.mash(MyClass.java:9)at MyClass.crunch(MyClass.java:6)at MyClass.main(MyClass.java:3)参考资料百度百科-Java
2023-07-17 16:56:241

猜你想看

perfect 干组词 红双喜香烟价格表大全 生产车间安全管理培训 香烟价格表 what edm是什么意思 楚小云 百燕之家 scoops bucking 设备管理培训 企业管理培训 企业管理培训课程 6S管理培训 精益生产 企业管理培训 现场管理培训 阅读 仓库安全管理培训内容 精细化管理 企业财务管理培训 香烟价格查询 领导力 沙盘模拟企业经营 采购谈判培训 企业绩效薪酬管理培训 熬姜呷醋 indirecttax 阅读 adopts 七匹狼香烟价格 黄山香烟价格 海员 自找 初中 升学率 中学 初中 升学率 中学 good 反义词 大学

大家在看

hamada posh koji avcc good yammy proposes lingos lingoes mojave vimicro pentile wannacry veggie veggieg serto turnup netants turnto 7的倍数
Copyright © 2019-2023 . All Rights Reserved. www.votoro.com 版权所有