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 representation stackState = nativeFillInStackTrace(); // Mark the full representation as empty stackTrace = 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); } } @Override public 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 enabled if (suppressedExceptions.isEmpty()) { // ensure we have somewhere to place suppressed exceptions suppressedExceptions = 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 initialized getInternalStackTrace(); 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 copy suppressedExceptions = 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,布布扣,bubuko.com
AssertionError、Error和Throwable
原文:http://blog.csdn.net/u010142437/article/details/25052509