/**@class java.lang.Throwable implements java.io.Serializable @extends java.lang.Object The superclass of all classes which can be thrown by the VM. The two direct subclasses are recoverable exceptions ({@code Exception}) and unrecoverable errors ({@code Error}). This class provides common methods for accessing a string message which provides extra information about the circumstances in which the {@code Throwable} was created (basically an error message in most cases), and for saving a stack trace (that is, a record of the call stack at a particular point in time) which can be printed later. <p>A {@code Throwable} can also include a cause, which is a nested {@code Throwable} that represents the original problem that led to this {@code Throwable}. It is often used for wrapping various types of errors into a common {@code Throwable} without losing the detailed original error information. When printing the stack trace, the trace of the cause is included. @see Error @see Exception @see RuntimeException */ var Throwable = { /**Records the stack trace from the point where this method has been called to this {@code Throwable}. This method is invoked by the {@code Throwable} constructors. <p>This method is public so that code (such as an RPC system) which catches a {@code Throwable} and then re-throws it can replace the construction-time stack trace with a stack trace from the location where the exception was re-thrown, by <i>calling</i> {@code fillInStackTrace}. <p>This method is non-final so that non-Java language implementations can disable VM stack traces for their language. Filling in the stack trace is relatively expensive. <i>Overriding</i> this method in the root of a language's exception hierarchy allows the language to avoid paying for something it doesn't need. @return {Object {java.lang.Throwable}} this {@code Throwable} instance. */ fillInStackTrace : function( ) {}, /**Returns the detail message which was provided when this {@code Throwable} was created. Returns {@code null} if no message was provided at creation time. */ getMessage : function( ) {}, /**Returns the detail message which was provided when this {@code Throwable} was created. Returns {@code null} if no message was provided at creation time. Subclasses may override this method to return localized text for the message. Android returns the regular detail message. */ getLocalizedMessage : function( ) {}, /**Returns a clone of the array of stack trace elements of this {@code Throwable}. Each {@code StackTraceElement} represents an entry in the call stack. The element at position 0 is the top of the stack, that is, the stack frame where this {@code Throwable} is thrown. @see #printStackTrace() */ getStackTrace : function( ) {}, /**Sets the array of stack trace elements. Each {@code StackTraceElement} represents an entry in the call stack. A copy of the specified array is stored in this {@code Throwable}. will be returned by {@code getStackTrace()} and printed by {@code printStackTrace()}. @param {Object {java.lang.StackTraceElement[]}} trace the new array of {@code StackTraceElement}s. A copy of the array is stored in this {@code Throwable}, so subsequent changes to {@code trace} will not change the call stack stored in this {@code Throwable}. @throws NullPointerException if any element in {@code trace} is {@code null}. @see #printStackTrace() */ setStackTrace : function( ) {}, /**Writes a printable representation of this {@code Throwable}'s stack trace to the {@code System.err} stream. */ printStackTrace : function( ) {}, /**Writes a printable representation of this {@code Throwable}'s stack trace to the given print stream. If the {@code Throwable} contains a {@link #getCause() cause}, the method will be invoked recursively for the nested {@code Throwable}. */ printStackTrace : function( ) {}, /**Writes a printable representation of this {@code Throwable}'s stack trace to the specified print writer. If the {@code Throwable} contains a {@link #getCause() cause}, the method will be invoked recursively for the nested {@code Throwable}. @param {Object {PrintWriter}} err the writer to write the stack trace on. */ printStackTrace : function( ) {}, /** */ toString : function( ) {}, /**Initializes the cause of this {@code Throwable}. The cause can only be initialized once. @param {Object {Throwable}} throwable the cause of this {@code Throwable}. @return {Object {java.lang.Throwable}} this {@code Throwable} instance. @throws IllegalArgumentException if {@code Throwable} is this object. @throws IllegalStateException if the cause has already been initialized. */ initCause : function( ) {}, /**Returns the cause of this {@code Throwable}, or {@code null} if there is no cause. */ getCause : function( ) {}, /**Adds {@code throwable} to the list of throwables suppressed by this. The throwable will included when this exception's stack trace is printed. @throws IllegalArgumentException if {@code throwable == this}. @throws NullPointerException if {@code throwable == null}. @since 1.7 */ addSuppressed : function( ) {}, /**Returns the throwables suppressed by this. @since 1.7 */ getSuppressed : function( ) {}, };