本文主要是介绍AssertionError、Error和Throwable，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
随时随地技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666)
AssertionError继承Error，提供了多个构造方法，代码如下：
/** Licensed to the Apache Software Foundation (ASF) under one or more* contributor license agreements. See the NOTICE file distributed with* this work for additional information regarding copyright ownership.* The ASF licenses this file to You under the Apache License, Version 2.0* (the "License"); you may not use this file except in compliance with* the License. You may obtain a copy of the License at** http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package java.lang;/*** Thrown when an assertion has failed.** @since 1.4*/
public class AssertionError extends Error {private static final long serialVersionUID = -5013299493970297370L;/*** Constructs a new {@code AssertionError} with no message.*/public AssertionError() {}/*** Constructs a new {@code AssertionError} with the given detail message and cause.* @since 1.7* @hide 1.7*/public AssertionError(String detailMessage, Throwable cause) {super(detailMessage, cause);}/*** Constructs a new {@code AssertionError} with a message based on calling* {@link String#valueOf(Object)} with the specified object. If the object* is an instance of {@link Throwable}, then it also becomes the cause of* this error.** @param detailMessage* the object to be converted into the detail message and* optionally the cause.*/public AssertionError(Object detailMessage) {super(String.valueOf(detailMessage));if (detailMessage instanceof Throwable) {initCause((Throwable) detailMessage);}}/*** Constructs a new {@code AssertionError} with a message based on calling* {@link String#valueOf(boolean)} with the specified boolean value.** @param detailMessage* the value to be converted into the message.*/public AssertionError(boolean detailMessage) {this(String.valueOf(detailMessage));}/*** Constructs a new {@code AssertionError} with a message based on calling* {@link String#valueOf(char)} with the specified character value.** @param detailMessage* the value to be converted into the message.*/public AssertionError(char detailMessage) {this(String.valueOf(detailMessage));}/*** Constructs a new {@code AssertionError} with a message based on calling* {@link String#valueOf(int)} with the specified integer value.** @param detailMessage* the value to be converted into the message.*/public AssertionError(int detailMessage) {this(Integer.toString(detailMessage));}/*** Constructs a new {@code AssertionError} with a message based on calling* {@link String#valueOf(long)} with the specified long value.** @param detailMessage* the value to be converted into the message.*/public AssertionError(long detailMessage) {this(Long.toString(detailMessage));}/*** Constructs a new {@code AssertionError} with a message based on calling* {@link String#valueOf(float)} with the specified float value.** @param detailMessage* the value to be converted into the message.*/public AssertionError(float detailMessage) {this(Float.toString(detailMessage));}/*** Constructs a new {@code AssertionError} with a message based on calling* {@link String#valueOf(double)} with the specified double value.** @param detailMessage* the value to be converted into the message.*/public AssertionError(double detailMessage) {this(Double.toString(detailMessage));}
}
其父类Error继承自Throwable，有四个构造方法，如下：
/** Licensed to the Apache Software Foundation (ASF) under one or more* contributor license agreements. See the NOTICE file distributed with* this work for additional information regarding copyright ownership.* The ASF licenses this file to You under the Apache License, Version 2.0* (the "License"); you may not use this file except in compliance with* the License. You may obtain a copy of the License at** http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package java.lang;/*** {@code Error} is the superclass of all classes that represent unrecoverable* errors. When errors are thrown, they should not be caught by application* code.** @see Throwable* @see Exception* @see RuntimeException*/
public class Error extends Throwable {private static final long serialVersionUID = 4980196508277280342L;/*** Constructs a new {@code Error} that includes the current stack trace.*/public Error() {}/*** Constructs a new {@code Error} with the current stack trace and the* specified detail message.** @param detailMessage* the detail message for this error.*/public Error(String detailMessage) {super(detailMessage);}/*** Constructs a new {@code Error} with the current stack trace, the* specified detail message and the specified cause.** @param detailMessage* the detail message for this error.* @param throwable* the cause of this error.*/public Error(String detailMessage, Throwable throwable) {super(detailMessage, throwable);}/*** Constructs a new {@code Error} with the current stack trace and the* specified cause.** @param throwable* the cause of this error.*/public Error(Throwable throwable) {super(throwable);}
}
而Throwable是所有异常和错误的超类，里面有两个native方法，代码如下：
/** Licensed to the Apache Software Foundation (ASF) under one or more* contributor license agreements. See the NOTICE file distributed with* this work for additional information regarding copyright ownership.* The ASF licenses this file to You under the Apache License, Version 2.0* (the "License"); you may not use this file except in compliance with* the License. You may obtain a copy of the License at** http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package java.lang;import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import libcore.util.EmptyArray;/*** 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*/
public class Throwable implements java.io.Serializable {private static final long serialVersionUID = -3042686055658047285L;/*** The message provided when the exception was created.*/private String detailMessage;/*** The cause of this Throwable. Null when there is no cause.*/private Throwable cause = this;/*** Throwables suppressed by this throwable. Null when suppressed exceptions* are disabled.*/private List<Throwable> suppressedExceptions = Collections.emptyList();/*** An intermediate representation of the stack trace. This field may* be accessed by the VM; do not rename.*/private transient volatile Object stackState;/*** A fully-expanded representation of the stack trace.*/private StackTraceElement[] stackTrace;/*** Constructs a new {@code Throwable} that includes the current stack trace.*/public Throwable() {fillInStackTrace();}/*** Constructs a new {@code Throwable} with the current stack trace and the* specified detail message.** @param detailMessage* the detail message for this {@code Throwable}.*/public Throwable(String detailMessage) {this();this.detailMessage = detailMessage;}/*** Constructs a new {@code Throwable} with the current stack trace, the* specified detail message and the specified cause.** @param detailMessage* the detail message for this {@code Throwable}.* @param throwable* the cause of this {@code Throwable}.*/public Throwable(String detailMessage, Throwable throwable) {this();this.detailMessage = detailMessage;cause = throwable;}/*** Constructs a new {@code Throwable} with the current stack trace and the* specified cause.** @param throwable* the cause of this {@code Throwable}.*/public Throwable(Throwable throwable) {this();this.detailMessage = throwable == null ? null : throwable.toString();cause = throwable;}/*** Constructs a new {@code Throwable} with the current stack trace, the* specified detail message and the specified cause.** @param enableSuppression if false, throwables passed to {@link* #addSuppressed(Throwable)} will be silently discarded.* @since 1.7* @hide 1.7*/protected Throwable(String detailMessage, Throwable throwable, boolean enableSuppression) {this(detailMessage, throwable);if (!enableSuppression) {this.suppressedExceptions = null;}}/*** 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 this {@code Throwable} instance.*/public Throwable fillInStackTrace() {// Fill in the intermediate representationstackState = nativeFillInStackTrace();// Mark the full representation as emptystackTrace = null;return this;}/*** Returns the extra information message which was provided when this* {@code Throwable} was created. Returns {@code null} if no message was* provided at creation time.** @return this {@code Throwable}'s detail message.*/public String getMessage() {return detailMessage;}/*** Returns the extra information 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.** @return this {@code Throwable}'s localized detail message.*/public String getLocalizedMessage() {return getMessage();}/*** Returns 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.** @return a copy of the array of {@code StackTraceElement}s representing* the call stack. Changes in the array obtained from this call will* not change the call stack stored in this {@code Throwable}.* @see #printStackTrace()*/public StackTraceElement[] getStackTrace() {return getInternalStackTrace().clone();}/*** 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 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()*/public void setStackTrace(StackTraceElement[] trace) {StackTraceElement[] newTrace = trace.clone();for (int i = 0; i < newTrace.length; i++) {if (newTrace[i] == null) {throw new NullPointerException("trace[" + i + "] == null");}}stackTrace = newTrace;}/*** Writes a printable representation of this {@code Throwable}'s stack trace* to the {@code System.err} stream.**/public void printStackTrace() {printStackTrace(System.err);}/*** Counts the number of duplicate stack frames, starting from the* end of the stack.** @param currentStack a stack to compare* @param parentStack a stack to compare** @return the number of duplicate stack frames.*/private static int countDuplicates(StackTraceElement[] currentStack,StackTraceElement[] parentStack) {int duplicates = 0;int parentIndex = parentStack.length;for (int i = currentStack.length; --i >= 0 && --parentIndex >= 0;) {StackTraceElement parentFrame = parentStack[parentIndex];if (parentFrame.equals(currentStack[i])) {duplicates++;} else {break;}}return duplicates;}/*** Returns an array of StackTraceElement. Each StackTraceElement* represents a entry on the stack.** @return an array of StackTraceElement representing the stack*/private StackTraceElement[] getInternalStackTrace() {if (stackTrace == null) {stackTrace = nativeGetStackTrace(stackState);stackState = null; // Clean up intermediate representation}return stackTrace;}/*** Writes a printable representation of this {@code Throwable}'s stack trace* to the specified print stream. If the {@code Throwable} contains a* {@link #getCause() cause}, the method will be invoked recursively for* the nested {@code Throwable}.** @param err* the stream to write the stack trace on.*/public void printStackTrace(PrintStream err) {try {printStackTrace(err, "", null);} catch (IOException e) {// Appendable.append throws IOException but PrintStream.append doesn't.throw new AssertionError();}}/*** 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 err* the writer to write the stack trace on.*/public void printStackTrace(PrintWriter err) {try {printStackTrace(err, "", null);} catch (IOException e) {// Appendable.append throws IOException, but PrintWriter.append doesn't.throw new AssertionError();}}/*** @param indent additional indentation on each line of the stack trace.* This is the empty string for all but suppressed throwables.* @param parentStack the parent stack trace to suppress duplicates from, or* null if this stack trace has no parent.*/private void printStackTrace(Appendable err, String indent, StackTraceElement[] parentStack)throws IOException {err.append(toString());err.append("\n");StackTraceElement[] stack = getInternalStackTrace();if (stack != null) {int duplicates = parentStack != null ? countDuplicates(stack, parentStack) : 0;for (int i = 0; i < stack.length - duplicates; i++) {err.append(indent);err.append("\tat ");err.append(stack[i].toString());err.append("\n");}if (duplicates > 0) {err.append(indent);err.append("\t... ");err.append(Integer.toString(duplicates));err.append(" more\n");}}// Print suppressed exceptions indented one level deeper.if (suppressedExceptions != null) {for (Throwable throwable : suppressedExceptions) {err.append(indent);err.append("\tSuppressed: ");throwable.printStackTrace(err, indent + "\t", stack);}}Throwable cause = getCause();if (cause != null) {err.append(indent);err.append("Caused by: ");cause.printStackTrace(err, indent, stack);}}@Overridepublic String toString() {String msg = getLocalizedMessage();String name = getClass().getName();if (msg == null) {return name;}return name + ": " + msg;}/*** Initializes the cause of this {@code Throwable}. The cause can only be* initialized once.** @param throwable* the cause of this {@code Throwable}.* @return this {@code Throwable} instance.* @throws IllegalArgumentException* if {@code Throwable} is this object.* @throws IllegalStateException* if the cause has already been initialized.*/public Throwable initCause(Throwable throwable) {if (cause != this) {throw new IllegalStateException("Cause already initialized");}if (throwable == this) {throw new IllegalArgumentException("throwable == this");}cause = throwable;return this;}/*** Returns the cause of this {@code Throwable}, or {@code null} if there is* no cause.** @return Throwable this {@code Throwable}'s cause.*/public Throwable getCause() {if (cause == this) {return null;}return cause;}/*** 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* @hide 1.7*/public final void addSuppressed(Throwable throwable) {if (throwable == this) {throw new IllegalArgumentException("throwable == this");}if (throwable == null) {throw new NullPointerException("throwable == null");}if (suppressedExceptions != null) {// suppressed exceptions are enabledif (suppressedExceptions.isEmpty()) {// ensure we have somewhere to place suppressed exceptionssuppressedExceptions = new ArrayList<Throwable>(1);}suppressedExceptions.add(throwable);}}/*** Returns the throwables suppressed by this.** @since 1.7* @hide 1.7*/public final Throwable[] getSuppressed() {return (suppressedExceptions != null && !suppressedExceptions.isEmpty())? suppressedExceptions.toArray(new Throwable[suppressedExceptions.size()]): EmptyArray.THROWABLE;}private void writeObject(ObjectOutputStream out) throws IOException {// ensure the stackTrace field is initializedgetInternalStackTrace();out.defaultWriteObject();}private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {in.defaultReadObject();if (suppressedExceptions != null) {// the deserialized list may be unmodifiable, so just create a mutable copysuppressedExceptions = new ArrayList<Throwable>(suppressedExceptions);}}/** Creates a compact, VM-specific collection of goodies, suitable for* storing in the "stackState" field, based on the current thread's* call stack.*/private static native Object nativeFillInStackTrace();/** Creates an array of StackTraceElement objects from the data held* in "stackState".*/private static native StackTraceElement[] nativeGetStackTrace(Object stackState);
}
从源码中容易理解他们的层次和调用关系。
这篇关于AssertionError、Error和Throwable的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
