Class Throwable

public Throwable()

Instantiate this Throwable with an empty message. The cause remains uninitialized. fillInStackTrace() will be called to set up the stack trace.

public Throwable(String message)

Instantiate this Throwable with the given message. The cause remains uninitialized. fillInStackTrace() will be called to set up the stack trace.

Parameters:

message - the message to associate with the Throwable

public Throwable(String message,
                 Throwable cause)

Instantiate this Throwable with the given message and cause. Note that the message is unrelated to the message of the cause. fillInStackTrace() will be called to set up the stack trace.

Parameters:

message - the message to associate with the Throwable

cause - the cause, may be null

Since:

1.4

public Throwable(Throwable cause)

Instantiate this Throwable with the given cause. The message is then built as cause == null ? null : cause.toString(). fillInStackTrace() will be called to set up the stack trace.

Parameters:

cause - the cause, may be null

Since:

1.4

public Throwable fillInStackTrace()

Fill in the stack trace with the current execution stack.

Returns:

this same throwable

See Also:

printStackTrace()

public Throwable getCause()

Returns the cause of this exception, or null if the cause is not known or non-existant. This cause is initialized by the new constructors, or by calling initCause.

Returns:

the cause of this Throwable

Since:

1.4

public String getLocalizedMessage()

Get a localized version of this Throwable's error message. This method must be overridden in a subclass of Throwable to actually produce locale-specific methods. The Throwable implementation just returns getMessage().

Returns:

a localized version of this error message

Since:

1.1

See Also:

getMessage()

public String getMessage()

Get the message associated with this Throwable.

Returns:

the error message associated with this Throwable, may be null

public StackTraceElement[] getStackTrace()

Provides access to the information printed in printStackTrace(). The array is non-null, with no null entries, although the virtual machine is allowed to skip stack frames. If the array is not 0-length, then slot 0 holds the information on the stack frame where the Throwable was created (or at least where fillInStackTrace() was called).

Returns:

an array of stack trace information, as available from the VM

Since:

1.4

public Throwable initCause(Throwable cause)

Initialize the cause of this Throwable. This may only be called once during the object lifetime, including implicitly by chaining constructors.

Parameters:

cause - the cause of this Throwable, may be null

Returns:

this

Throws:

IllegalArgumentException - if cause is this (a Throwable can't be its own cause!)

IllegalStateException - if the cause has already been set

Since:

1.4

public void printStackTrace()

Print a stack trace to the standard error stream. This stream is the current contents of System.err. The first line of output is the result of toString(), and the remaining lines represent the data created by fillInStackTrace(). While the format is unspecified, this implementation uses the suggested format, demonstrated by this example:

 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
 {
 }
 

  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
 

public void printStackTrace(PrintStream s)

Print a stack trace to the specified PrintStream. See printStackTrace() for the sample format.

Parameters:

s - the PrintStream to write the trace to

public void printStackTrace(PrintWriter pw)

Prints the exception, the detailed message and the stack trace associated with this Throwable to the given PrintWriter. The actual output written is implemention specific. Use the result of getStackTrace() when more precise information is needed.

This implementation first prints a line with the result of this object's toString() method.
Then for all elements given by getStackTrace it prints a line containing three spaces, the string "at " and the result of calling the toString() method on the StackTraceElement object. If getStackTrace() returns an empty array it prints a line containing three spaces and the string "<<No stacktrace available>>".
Then if getCause() doesn't return null it adds a line starting with "Caused by: " and the result of calling toString() on the cause.
Then for every cause (of a cause, etc) the stacktrace is printed the same as for the top level Throwable except that as soon as all the remaining stack frames of the cause are the same as the the last stack frames of the throwable that the cause is wrapped in then a line starting with three spaces and the string "... X more" is printed, where X is the number of remaining stackframes.

Parameters:

pw - the PrintWriter to write the trace to

Since:

1.1

public void setStackTrace(StackTraceElement[] stackTrace)

Change the stack trace manually. This method is designed for remote procedure calls, which intend to alter the stack trace before or after serialization according to the context of the remote call.

The contents of the given stacktrace is copied so changes to the original array do not change the stack trace elements of this throwable.

Parameters:

stackTrace - the new trace to use

Throws:

NullPointerException - if stackTrace is null or has null elements

Since:

1.4

public String toString()

Get a human-readable representation of this Throwable. The detail message is retrieved by getLocalizedMessage(). Then, with a null detail message, this string is simply the object's class name; otherwise the string is getClass().getName() + ": " + message.

Overrides:

toString in interface Object

Returns:

a human-readable String represting this Throwable