catch (AbortException ae) {
IMessage m = ae.getMessage();
if (!ae.isPorter()) ae.printStackTrace(System.err);
Throwable thrown = ae.getThrown();
if (null != thrown) thrown.printStackTrace(System.err);
}
| Modifier and Type | Field and Description |
|---|---|
| protected boolean | isPorter
true if this is a porter exception - only used to hold message |
| private boolean | |
| protected IMessage | message
structured message abort |
| public static final String | NO_MESSAGE_TEXT
used when message text is null |
| private static final ArrayList | |
| private static final long |
| Access | Constructor and Description |
|---|---|
| public | |
| public | |
| public |
| Modifier and Type | Method and Description |
|---|---|
| public static AbortException | |
| private static String | |
| public IMessage | |
| public String | getMessage()
Overrides java. |
| public Throwable | |
| public boolean | Returns: true if this exception is only to carry exceptionThe stack trace of a porter is invalid; it is only used to carry a message (which may itself have a wrapped exception). |
| public boolean | |
| public void | printStackTrace()
Overrides java. |
| public void | printStackTrace(PrintStream
PrintStream to use for outputOverrides java. |
| public void | printStackTrace(PrintWriter
PrintWriter to use for outputOverrides java. |
| public static void | |
| private void | |
| public void |
| isPorter | back to summary |
|---|---|
| protected boolean isPorter true if this is a porter exception - only used to hold message | |
| isSilent | back to summary |
|---|---|
| private boolean isSilent | |
| message | back to summary |
|---|---|
| protected IMessage message structured message abort | |
| NO_MESSAGE_TEXT | back to summary |
|---|---|
| public static final String NO_MESSAGE_TEXT used when message text is null | |
| porters | back to summary |
|---|---|
| private static final ArrayList<AbortException> porters | |
| serialVersionUID | back to summary |
|---|---|
| private static final long serialVersionUID | |
| AbortException | back to summary |
|---|---|
| public AbortException() abort with default String message | |
| AbortException | back to summary |
|---|---|
| public AbortException(String s) abort with message | |
| AbortException | back to summary |
|---|---|
| public AbortException(IMessage message) abort with structured message | |
| borrowPorter | back to summary |
|---|---|
| public static AbortException borrowPorter(IMessage message) Get a porter exception from the pool. Porter exceptions do not have valid stack traces. They are used only to avoid generating stack traces when using throw/catch to abruptly complete but continue. | |
| extractMessage | back to summary |
|---|---|
private static String extractMessage(IMessage message)
| |
| getIMessage | back to summary |
|---|---|
public IMessage getIMessage()
| |
| getMessage | back to summary |
|---|---|
| public String getMessage() Overrides java. Get message for this AbortException, either associated explicitly as message or implicitly as IMessage message or its thrown message.
| |
| getThrown | back to summary |
|---|---|
public Throwable getThrown()
| |
| isPorter | back to summary |
|---|---|
| public boolean isPorter() The stack trace of a porter is invalid; it is only used to carry a message (which may itself have a wrapped exception).
| |
| isSilent | back to summary |
|---|---|
| public boolean isSilent() | |
| printStackTrace | back to summary |
|---|---|
| public void printStackTrace() Overrides java. Doc from java. Prints this throwable and its backtrace to the
standard error stream. This method prints a stack trace for this
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 the 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 as it is used on causes. Unlike causes, suppressed exceptions are
indented beyond their "containing exceptions."
An exception can have both a cause and one or more suppressed 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.<init>(Resource2.java:45)
... 2 more
| |
| printStackTrace | back to summary |
|---|---|
| public void printStackTrace(PrintStream s) Overrides java. Print the stack trace of any enclosed thrown or this otherwise.
| |
| printStackTrace | back to summary |
|---|---|
| public void printStackTrace(PrintWriter s) Overrides java. Print the stack trace of any enclosed thrown or this otherwise.
| |
| returnPorter | back to summary |
|---|---|
| public static void returnPorter(AbortException porter) Return (or add) a porter exception to the pool. | |
| setIMessage | back to summary |
|---|---|
| private void setIMessage(IMessage message) | |
| setIsSilent | back to summary |
|---|---|
| public void setIsSilent(boolean isSilent) | |