Overview  Package   Class  Use  Deprecated  Index
Home >> All >> java >> [ lang overview ]	PREV CLASS  NEXT CLASS
SUMMARY:  JAVADOC |  SOURCE |  DOWNLOAD | NESTED | FIELD | CONSTR | METHOD	DETAIL: FIELD | CONSTR | METHOD

---

java.lang
Class Throwable  

java.lang.Object
  java.lang.Throwable

All Implemented Interfaces:

java.io.Serializable

Direct Known Subclasses:

Error, Exception

---

public class Throwable

extends Object

implements java.io.Serializable

Throwable is the superclass of all exceptions that can be raised.

There are two special cases: Error and RuntimeException: these two classes (and their subclasses) are considered unchecked exceptions, and are either frequent enough or catastrophic enough that you do not need to declare them in throws clauses. Everything else is a checked exception, and is ususally a subclass of Exception; these exceptions have to be handled or declared.

Instances of this class are usually created with knowledge of the execution context, so that you can get a stack trace of the problem spot in the code. Also, since JDK 1.4, Throwables participate in "exception chaining." This means that one exception can be caused by another, and preserve the information of the original.

One reason this is useful is to wrap exceptions to conform to an interface. For example, it would be bad design to require all levels of a program interface to be aware of the low-level exceptions thrown at one level of abstraction. Another example is wrapping a checked exception in an unchecked one, to communicate that failure occured while still obeying the method throws clause of a superclass.

A cause is assigned in one of two ways; but can only be assigned once in the lifetime of the Throwable. There are new constructors added to several classes in the exception hierarchy that directly initialize the cause, or you can use the initCause method. This second method is especially useful if the superclass has not been retrofitted with new constructors:

 try
   {
     lowLevelOp();
   }
 catch (LowLevelException lle)
   {
     throw (HighLevelException) new HighLevelException().initCause(lle);
   }
 

Notice the cast in the above example; without it, your method would need a throws clase that declared Throwable, defeating the purpose of chainig your exceptions.

By convention, exception classes have two constructors: one with no arguments, and one that takes a String for a detail message. Further, classes which are likely to be used in an exception chain also provide a constructor that takes a Throwable, with or without a detail message string.

Another 1.4 feature is the StackTrace, a means of reflection that allows the program to inspect the context of the exception, and which is serialized, so that remote procedure calls can correctly pass exceptions.

Since:

1.0

---

Nested Class Summary
private static class	Throwable.StaticData

 

Field Summary
private  Throwable	cause           The cause of the throwable, including null for an unknown or non-chained cause.
private  String	detailMessage           The detail message.
private static long	serialVersionUID           Compatible with JDK 1.0+.
private  StackTraceElement[]	stackTrace           The stack trace, in a serialized form.
private  VMThrowable	vmState           VM state when fillInStackTrace was called.

 

Constructor Summary

Throwable()           Instantiate this Throwable with an empty message.

Throwable(String message)           Instantiate this Throwable with the given message.

Throwable(String message, Throwable cause)           Instantiate this Throwable with the given message and cause.

Throwable(Throwable cause)           Instantiate this Throwable with the given cause.

 

Method Summary
Throwable	fillInStackTrace()           Fill in the stack trace with the current execution stack.
Throwable	getCause()           Returns the cause of this exception, or null if the cause is not known or non-existant.
String	getLocalizedMessage()           Get a localized version of this Throwable's error message.
String	getMessage()           Get the message associated with this Throwable.
StackTraceElement[]	getStackTrace()           Provides access to the information printed in printStackTrace() 55 .
Throwable	initCause(Throwable cause)           Initialize the cause of this Throwable.
void	printStackTrace()           Print a stack trace to the standard error stream.
void	printStackTrace(java.io.PrintStream s)           Print a stack trace to the specified PrintStream.
void	printStackTrace(java.io.PrintWriter pw)           Prints the exception, the detailed message and the stack trace associated with this Throwable to the given PrintWriter.
void	setStackTrace(StackTraceElement[] stackTrace)           Change the stack trace manually.
private  String	stackTraceString()
private static void	stackTraceStringBuffer(StringBuffer sb, String name, StackTraceElement[] stack, int equal)
String	toString()           Get a human-readable representation of this Throwable.

 

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

 

Field Detail

serialVersionUID

private static final long serialVersionUID

Compatible with JDK 1.0+.

See Also:

Constant Field Values

---

detailMessage

private final String detailMessage

The detail message.

---

cause

private Throwable cause

The cause of the throwable, including null for an unknown or non-chained cause. This may only be set once; so the field is set to this until initialized.

Since:

1.4

---

stackTrace

private StackTraceElement[] stackTrace

The stack trace, in a serialized form.

Since:

1.4

---

vmState

private transient VMThrowable vmState

VM state when fillInStackTrace was called. Used by getStackTrace() to get an array of StackTraceElements. Cleared when no longer needed.

Constructor Detail

Throwable

public Throwable()

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

---

Throwable

public Throwable(String message)

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

---

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() 55 will be called to set up the stack trace.

Since:

1.4

---

Throwable

public Throwable(Throwable cause)

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

Since:

1.4

Method Detail

getMessage

public String getMessage()

Get the message associated with this Throwable.

---

getLocalizedMessage

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().

Since:

1.1

---

getCause

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.

Since:

1.4

---

initCause

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.

Since:

1.4

---

toString

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 class Object

---

printStackTrace

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() 55 , and the remaining lines represent the data created by fillInStackTrace() 55 . 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
 

---

printStackTrace

public void printStackTrace(java.io.PrintStream s)

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

---

printStackTrace

public void printStackTrace(java.io.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.

Since:

1.1

---

stackTraceString

private String stackTraceString()

---

stackTraceStringBuffer

private static void stackTraceStringBuffer(StringBuffer sb,
                                           String name,
                                           StackTraceElement[] stack,
                                           int equal)

---

fillInStackTrace

public Throwable fillInStackTrace()

Fill in the stack trace with the current execution stack.

---

getStackTrace

public StackTraceElement[] getStackTrace()

Provides access to the information printed in printStackTrace() 55 . 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).

Since:

1.4

---

setStackTrace

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.

Since:

1.4

---

Overview  Package   Class  Use  Deprecated  Index
Home >> All >> java >> [ lang overview ]	PREV CLASS  NEXT CLASS
SUMMARY:  JAVADOC |  SOURCE |  DOWNLOAD | NESTED | FIELD | CONSTR | METHOD	DETAIL: FIELD | CONSTR | METHOD

---