Throwable

Throwable

Throwable ()

用null作为详细消息构造一个新的throwable。 原因未初始化，并可能随后通过致电initCause(Throwable)进行初始化。

调用 fillInStackTrace()方法来初始化新创建的throwable中的堆栈跟踪数据。

Throwable

Throwable (String message)

用指定的详细信息构造一个新的throwable。 原因未初始化，并可能随后通过致电initCause(Throwable)进行初始化。

调用 fillInStackTrace()方法来初始化新创建的throwable中的堆栈跟踪数据。

Parameters
message	String: the detail message. The detail message is saved for later retrieval by the getMessage() method.

Throwable

Throwable (String message, 
                Throwable cause)

用指定的详细信息和原因构造一个新的throwable。

请注意，与 cause关联的详细消息 不会自动包含在此throwable的详细消息中。

调用 fillInStackTrace()方法来初始化新创建的throwable中的堆栈跟踪数据。

Parameters
message	String: the detail message (which is saved for later retrieval by the getMessage() method).
cause	Throwable: the cause (which is saved for later retrieval by the getCause() method). (A null value is permitted, and indicates that the cause is nonexistent or unknown.)

Throwable

Throwable (Throwable cause)

构造具有指定的原因和详细消息的新throwable (cause==null ? null : cause.toString()) （它通常包含的类和详细消息cause ）。 这个构造函数对于throwables来说非常有用，它比其他throwables的包装稍微多一点（例如， PrivilegedActionException ）。

调用 fillInStackTrace()方法来初始化新创建的throwable中的堆栈跟踪数据。

Parameters
cause	Throwable: the cause (which is saved for later retrieval by the getCause() method). (A null value is permitted, and indicates that the cause is nonexistent or unknown.)

Throwable

Throwable (String message, 
                Throwable cause, 
                boolean enableSuppression, 
                boolean writableStackTrace)

使用指定的详细消息构造新的throwable，原因，启用或禁用suppression ，以及启用或禁用可写堆栈跟踪。 如果禁用抑制， getSuppressed()此对象的getSuppressed()将返回一个零长度的数组，并调用addSuppressed(Throwable) ，否则将异常添加到禁止列表中将不起作用。 如果可写堆栈跟踪为false，则此构造函数将不会调用fillInStackTrace() ，将null写入stackTrace字段，并且对fillInStackTrace和setStackTrace(StackTraceElement[])后续调用将不会设置堆栈跟踪。 如果可写堆栈跟踪为false，则getStackTrace()将返回零长度数组。

请注意， Throwable的其他构造Throwable将抑制视为启用并且堆栈跟踪为可写。 Throwable子类应记录禁用抑制的任何条件以及堆栈跟踪不可写入的文档条件。 只有在存在特殊要求的特殊情况下（例如虚拟机在低内存情况下重新使用异常对象），才能禁用禁用。 在一个给定的异常对象被重复捕获和重新抛出的情况下，例如在两个子系统之间实现控制流的情况下，另一种情况是不可变的可抛出对象是合适的。

Parameters
message	String: the detail message.
cause	Throwable: the cause. (A null value is permitted, and indicates that the cause is nonexistent or unknown.)
enableSuppression	boolean: whether or not suppression is enabled or disabled
writableStackTrace	boolean: whether or not the stack trace should be writable

addSuppressed

void addSuppressed (Throwable exception)

将指定的异常附加到为了传递此异常而被禁止的异常。 此方法是线程安全的，通常由try -with-resources语句调用（自动和隐式地）。

抑制行为已启用， 除非禁用via a constructor 。 当禁用抑制时，此方法除了验证其参数外别无其他。

请注意，当一个异常causes另一个异常时，通常会捕获第一个异常，然后在响应中引发第二个异常。 换句话说，这两个例外之间有因果关系。 与此相反，存在两个独立的异常可以在同级代码块在被抛出，在特定情况下try一个的块try -with资源语句和编译器生成的finally块封闭该资源。 在这些情况下，只有一个抛出的异常可以被传播。 在try -with-resources语句，当有两个这样的例外，从始发异常try块被传播，并从异常finally块添加到从异常抑制例外列表try块。 由于异常展开堆栈，它可以累积多个抑制异常。

异常可能会抑制异常，同时也是由另一个异常引起的。 异常是否具有原因在创建时在语义上是已知的，与异常是否会抑制通常仅在抛出异常之后确定的其他异常不同。

请注意，程序员编写的代码也可以利用在存在多个同级异常并且只能传播一个异常的情况下调用此方法。

Parameters
exception	Throwable: the exception to be added to the list of suppressed exceptions

Throws
IllegalArgumentException	if exception is this throwable; a throwable cannot suppress itself.
NullPointerException	if exception is null

fillInStackTrace

Throwable fillInStackTrace ()

填写执行堆栈跟踪。 此方法这内记录Throwable有关当前线程的堆栈帧的当前状态对象的信息。

如果此 Throwable is not writable的堆栈跟踪调用此方法不起作用。

Returns
Throwable	a reference to this Throwable instance.

getCause

Throwable getCause ()

如果原因不存在或未知，则返回此throwable的原因或null 。 （原因是导致此throwable被抛出的throwable。）

该实现返回通过需要Throwable的构造函数之一提供的Throwable ，或者在使用initCause(Throwable)方法创建之后设置的initCause(Throwable) 。 虽然通常不需要重写此方法，但子类可以覆盖它以返回由其他方法设置的原因。 这适用于在Throwable之前添加链式异常之前的“遗留链式可Throwable 。 请注意， 没有必要重写任何PrintStackTrace方法，所有这些方法都会调用getCause方法来确定throwable的原因。

Returns
Throwable	the cause of this throwable or null if the cause is nonexistent or unknown.

getLocalizedMessage

String getLocalizedMessage ()

创建这个throwable的本地化描述。 子类可以重写此方法以生成特定于语言环境的消息。 对于不重写此方法的子类，默认实现返回与getMessage()相同的结果。

Returns
String	The localized description of this throwable.

getMessage

String getMessage ()

返回此throwable的详细消息字符串。

Returns
String	the detail message string of this Throwable instance (which may be null).

getStackTrace

StackTraceElement[] getStackTrace ()

提供编程访问由printStackTrace()打印的堆栈跟踪信息。 返回堆栈跟踪元素的数组，每个元素表示一个堆栈帧。 数组的第零个元素（假定数组的长度不为零）表示堆栈的顶部，这是序列中最后一个方法调用。 通常，这是创建和抛出此throwable的关键点。 数组的最后一个元素（假设数组的长度不为零）代表堆栈的底部，这是序列中第一个方法调用。

某些虚拟机在某些情况下可能会忽略堆栈跟踪中的一个或多个堆栈帧。 在极端情况下，不允许有关此throwable的堆栈跟踪信息的虚拟机从此方法返回一个长度为零的数组。 一般来说，通过此方法返回的数组将为每个由printStackTrace打印的帧包含一个元素。 写入返回的数组不会影响将来对此方法的调用。

Returns
StackTraceElement[]	an array of stack trace elements representing the stack trace pertaining to this throwable.

getSuppressed

Throwable[] getSuppressed ()

返回一个数组，其中包含通常由try -with-resources语句抑制的所有异常，以便提供此异常。 如果没有异常被抑制或者suppression is disabled ，则返回一个空数组。 这种方法是线程安全的。 写入返回的数组不会影响将来对此方法的调用。

Returns
Throwable[]	an array containing all of the exceptions that were suppressed to deliver this exception.

initCause

Throwable initCause (Throwable cause)

将此throwable的原因初始化为指定值。 （原因是导致此throwable被抛出的throwable。）

该方法最多可以调用一次。 它通常在构造函数中调用，或者在创建throwable之后立即调用。 如果这个throwable是用Throwable(Throwable)或Throwable(String, Throwable)创建的，这个方法甚至不能被调用一次。

在传统的可丢弃类型上使用此方法的示例没有其他支持来设置原因：

 try {
     lowLevelOp();
 } catch (LowLevelException le) {
     throw (HighLevelException)
           new HighLevelException().initCause(le); // Legacy constructor
 }
 

Parameters
cause	Throwable: the cause (which is saved for later retrieval by the getCause() method). (A null value is permitted, and indicates that the cause is nonexistent or unknown.)

Returns
Throwable	a reference to this Throwable instance.

Throws
IllegalArgumentException	if cause is this throwable. (A throwable cannot be its own cause.)
IllegalStateException	if this throwable was created with Throwable(Throwable) or Throwable(String, Throwable), or this method has already been called on this throwable.

printStackTrace

void printStackTrace ()

将此throwable及其回溯打印到标准错误流。 此方法在错误输出流上打印此Throwable对象的堆栈跟踪，该值是字段System.err的值。 第一行输出包含此对象的toString()方法的结果。 剩余线代表先前由方法fillInStackTrace()记录的数据。 这个信息的格式取决于实现，但下面的例子可能被认为是典型的：

 java.lang.NullPointerException
         at MyClass.mash(MyClass.java:9)
         at MyClass.crunch(MyClass.java:6)
         at MyClass.main(MyClass.java:3)
 

This example was produced by running the program:

 class MyClass {
     public static void main(String[] args) {
         crunch(null);
     }
     static void crunch(int[] a) {
         mash(a);
     }
     static void mash(int[] b) {
         System.out.println(b[0]);
     }
 }
 

The backtrace for a throwable with an initialized, non-null cause should generally include the backtrace for the cause. The format of this information depends on the implementation, but the following example may be regarded as typical:

 HighLevelException: MidLevelException: LowLevelException
         at Junk.a(Junk.java:13)
         at Junk.main(Junk.java:4)
 Caused by: MidLevelException: LowLevelException
         at Junk.c(Junk.java:23)
         at Junk.b(Junk.java:17)
         at Junk.a(Junk.java:11)
         ... 1 more
 Caused by: LowLevelException
         at Junk.e(Junk.java:30)
         at Junk.d(Junk.java:27)
         at Junk.c(Junk.java:21)
         ... 3 more
 

Note the presence of lines containing the characters "...". These lines indicate that the remainder of the stack trace for this exception matches the indicated number of frames from the bottom of the stack trace of the exception that was caused by this exception (the "enclosing" exception). This shorthand can greatly reduce the length of the output in the common case where a wrapped exception is thrown from same method as the "causative exception" is caught. The above example was produced by running the program:

 public class Junk {
     public static void main(String args[]) {
         try {
             a();
         } catch(HighLevelException e) {
             e.printStackTrace();
         }
     }
     static void a() throws HighLevelException {
         try {
             b();
         } catch(MidLevelException e) {
             throw new HighLevelException(e);
         }
     }
     static void b() throws MidLevelException {
         c();
     }
     static void c() throws MidLevelException {
         try {
             d();
         } catch(LowLevelException e) {
             throw new MidLevelException(e);
         }
     }
     static void d() throws LowLevelException {
        e();
     }
     static void e() throws LowLevelException {
         throw new LowLevelException();
     }
 }

 class HighLevelException extends Exception {
     HighLevelException(Throwable cause) { super(cause); }
 }

 class MidLevelException extends Exception {
     MidLevelException(Throwable cause)  { super(cause); }
 }

 class LowLevelException extends Exception {
 }
 

As of release 7, the platform supports the notion of suppressed exceptions (in conjunction with the try-with-resources statement). Any exceptions that were suppressed in order to deliver an exception are printed out beneath the stack trace. The format of this information depends on the implementation, but the following example may be regarded as typical:

 Exception in thread "main" java.lang.Exception: Something happened
  at Foo.bar(Foo.java:10)
  at Foo.main(Foo.java:5)
  Suppressed: Resource$CloseFailException: Resource ID = 0
          at Resource.close(Resource.java:26)
          at Foo.bar(Foo.java:9)
          ... 1 more
 

Note that the "... n more" notation is used on suppressed exceptions just at it is used on causes. Unlike causes, suppressed exceptions are indented beyond their "containing exceptions."

异常既可以包含原因，也可以包含一个或多个抑制异常：

 Exception in thread "main" java.lang.Exception: Main block
  at Foo3.main(Foo3.java:7)
  Suppressed: Resource$CloseFailException: Resource ID = 2
          at Resource.close(Resource.java:26)
          at Foo3.main(Foo3.java:5)
  Suppressed: Resource$CloseFailException: Resource ID = 1
          at Resource.close(Resource.java:26)
          at Foo3.main(Foo3.java:5)
 Caused by: java.lang.Exception: I did it
  at Foo3.main(Foo3.java:8)
 

Likewise, a suppressed exception can have a cause:

 Exception in thread "main" java.lang.Exception: Main block
  at Foo4.main(Foo4.java:6)
  Suppressed: Resource2$CloseFailException: Resource ID = 1
          at Resource2.close(Resource2.java:20)
          at Foo4.main(Foo4.java:5)
  Caused by: java.lang.Exception: Rats, you caught me
          at Resource2$CloseFailException.
      
      
      
       
       
       (Resource2.java:45)
          ... 2 more
 
      
      
      

printStackTrace

void printStackTrace (PrintWriter s)

将这个throwable和它的backtrace打印到指定的打印作者。

Parameters
s	PrintWriter: PrintWriter to use for output

printStackTrace

void printStackTrace (PrintStream s)

将此throwable及其回溯打印到指定的打印流。

Parameters
s	PrintStream: PrintStream to use for output

setStackTrace

void setStackTrace (StackTraceElement[] stackTrace)

设置将由getStackTrace()返回并由printStackTrace()和相关方法打印的堆栈跟踪元素。 此方法专为RPC框架和其他高级系统使用而设计，允许客户端覆盖默认的堆栈跟踪，当构建throwable时由fillInStackTrace()生成或从序列化流读取throwable时反序列化。

如果此 Throwable is not writable的堆栈跟踪调用此方法除验证其参数外没有其他影响。

Parameters
stackTrace	StackTraceElement: the stack trace elements to be associated with this Throwable. The specified array is copied by this call; changes in the specified array after the method invocation returns will have no affect on this Throwable's stack trace.

Throws
NullPointerException	if stackTrace is null or if any of the elements of stackTrace are null

toString

String toString ()

返回此throwable的简短描述。 结果是以下各项的连接：

• the name of the class of this object
• ": " (a colon and a space)
• the result of invoking this object's getLocalizedMessage() method

If getLocalizedMessage returns null, then just the class name is returned.

Returns
String	a string representation of this throwable.