XPathException

XPathException

XPathException (String message)

构造一个新 XPathException带指定详细 message 。

cause未初始化。

如果 message是 null ，则抛出 NullPointerException 。

Parameters
message	String: The detail message.

XPathException

XPathException (Throwable cause)

构造一个新 XPathException与指定 cause 。

如果 cause是 null ，则引发 NullPointerException 。

Parameters
cause	Throwable: The cause.

Throws
NullPointerException	if cause is null.

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.

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