精华内容
下载资源
问答
  • Throwable和Exception的区别
    2021-03-14 20:40:29

    Java语言要求java程序中(无论是谁写的代码)所有抛出(throw)的异常都必须是从Throwable派生而来。当然,实际的Java编程中,由于JDK平台已经为我们设计好了非常丰富和完整的异常对象分类模型。因此,java程序员一般是不需要再重新定义自己的异常对象。而且即便是需要扩展自定义的异常对象,也往往会从Exception派生而来。所以,对于java程序员而言,它一般只需要在它的顶级函数中catch(Exception ex)就可以捕获出所有的异常对象。 所有异常对象的根基类是 Throwable ,Throwable从Object直接继承而来(这是java系统所强制要求的),并且它实现了 Serializable接口(这为所有的异常对象都能够轻松跨越Java组件系统做好了最充分的物质准备)。从Throwable直接派生出的异常类有Exception和Error 。Exception是java程序员所最熟悉的,它一般代表了真正实际意义上的异常对象的根基类。也即是说, Exception 和从它派生而来的所有异常都是应用程序能够catch到的,并且可以进行异常错误恢复处理的异常类型。而Error则表示Java系统中出现了一个非常严重的异常错误,并且这个错误可能是应用程序所不能恢复的,例如LinkageError ,或 ThreadDeath 等。

    Error 和 RuntimeException 的子类是 unchecked 的,也就是不需要明确地 throws Error 也能编译通过。RuntimeException 表示这种异常是否出现经常不可预料,出现了的话,就中止处理。Error 一般表示无法恢复的故障,也就是你再试一次依然会出错,比如 OutOfMemoryError,试多少次很大概率出错的。Exception 则表示一般性的异常,而且这种异常是设计中早已考虑到很常见的错误,并且一定要求在设计中说明如果处理这种异常。RuntimException 更接近我们日常生活中的“意外”。Exception 这个更接近我们日常生活中所说的“常见错误”。Error 更像是”见鬼,看来周末国庆不加班是搞不定的“。技术上讲,Error/RuntimeException 和 Exception 仅是 unchecked 和 checked 这种编译过程上不同,它们的主要区别还是在设计时它的重要程序及处理例程。就好像有时候,我们在说一句话是,说成 A->B 和 B

    Throwable是java.lang包中一个专门用来处理异常的类。它有两个子类,即Error 和Exception,它们分别用来处理两组异常。Error用来处理程序运行环境方面的异常,比如,虚拟机错误、装载错误和连接错误,这类异常主要是和硬件有关的,而不是由程序本身抛出的。

    Exception是Throwable的一个主要子类。Exception下面还有子类,其中一部分子类分别对应于Java程序运行时常常遇到的各种异常的处理,其中包括隐式异常。比如,程序中除数为0引起的错误、数组下标越界错误等,这类异常也称为运行时异常,因为它们虽然是由程序本身引起的异常,但不是程序主动抛出的,而是在程序运行中产生的。

    Exception 子类下面的另一部分子类对应于Java程序中的非运行时异常的处理(在下图中将它们直接属于Exception了),这些异常也称为显式异常。它们都是在程序中用语句抛出、并且也是用语句进行捕获的,比如,文件没找到引起的异常、类没找到引起的异常等。 一些主要子类对应的异常处理功能简要说明如下: ArithmeticException——由于除数为0引起的异常; ArrayStoreException——由于数组存储空间不够引起的异常; ClassCastException—一当把一个对象归为某个类,但实际上此对象并不是由这个类 创建的,也不是其子类创建的,则会引起异常; IllegalMonitorStateException——监控器状态出错引起的异常; NegativeArraySizeException—一数组长度是负数,则产生异常; NullPointerException—一程序试图访问一个空的数组中的元素或访问空的对象中的 方法或变量时产生异常; OutofMemoryException——用new语句创建对象时,如系统无法为其分配内存空 间则产生异常; SecurityException——由于访问了不应访问的指针,使安全性出问题而引起异常; IndexOutOfBoundsExcention——由于数组下标越界或字符串访问越界引起异常; IOException——由于文件未找到、未打开或者I/O操作不能进行而引起异常; ClassNotFoundException——未找到指定名字的类或接口引起异常; CloneNotSupportedException——一程序中的一个对象引用Object类的clone方法,但 此对象并没有连接Cloneable接口,从而引起异常; InterruptedException—一当一个线程处于等待状态时,另一个线程中断此线程,从 而引起异常,有关线程的内容,将在下一章讲述; NoSuchMethodException一所调用的方法未找到,引起异常; Illega1AccessExcePtion—一试图访问一个非public方法; StringIndexOutOfBoundsException——访问字符串序号越界,引起异常; ArrayIdexOutOfBoundsException—一访问数组元素下标越界,引起异常; NumberFormatException——字符的UTF代码数据格式有错引起异常; IllegalThreadException—一线程调用某个方法而所处状态不适当,引起异常; FileNotFoundException——未找到指定文件引起异常; EOFException——未完成输入操作即遇文件结束引起异常。

    Error类和Exception类的父类都是throwable类,他们的区别是:

    Error类一般是指与虚拟机相关的问题,如系统崩溃,虚拟机错误,内存空间不足,方法调用栈溢等。对于这类错误的导致的应用程序中断,仅靠程序本身无法恢复和和预防,遇到这样的错误,建议让程序终止。

    Exception类表示程序可以处理的异常,可以捕获且可能恢复。遇到这类异常,应该尽可能处理异常,使程序恢复运行,而不应该随意终止异常。

    Exception类又分为运行时异常(Runtime Exception)和受检查的异常(Checked Exception ),运行时异常;ArithmaticException,IllegalArgumentException,编译能通过,但是一运行就终止了,程序不会处理运行时异常,出现这类异常,程序会终止。而受检查的异常,要么用try。。。catch捕获,要么用throws字句声明抛出,交给它的父类处理,否则编译不会通过。

    错误和异常的区别(Error vs Exception)

    今天面试问了这样一个问题,"Error" 和 "Exception"之间有啥区别?我觉得挺有意思,但是似乎又不能脱口而出。查找了一番资料之后,稍微总结了一下。

    1)  error都是继承自父类java.lang.Error,而exception都继承自java.lang.Exception.

    2)  再看看JDK中对于java.lang.Error和java.lang.Exception的解释。

    java.lang.Error: An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch. Most such errors are abnormal conditions. 即:Error是Throwable的子类,用于标记严重错误。合理的应用程序不应该去try/catch这种错误。绝大多数的错误都是非正常的,就根本不该出现的。     java.lang.Exception: The class Exception and its subclasses are a form of Throwable that indicates conditions that a reasonable application might want to catch. 即Exception 是Throwable的一种形式的子类,用于指示一种合理的程序想去catch的条件。即它仅仅是一种程序运行条件,而非严重错误,并且鼓励用户程序去catch它。

    3)  Error和RuntimeException 及其子类都是未检查的异常(unchecked exceptions),而所有其他的Exception类都是检查了的异常(checked exceptions).

    checked exceptions:通常是从一个可以恢复的程序中抛出来的,并且最好能够从这种异常中使用程序恢复。比如FileNotFoundException, ParseException等。

    unchecked exceptions:通常是如果一切正常的话本不该发生的异常,但是的确发生了。比如ArrayIndexOutOfBoundException, ClassCastException等。从语言本身的角度讲,程序不该去catch这类异常,虽然能够从诸如RuntimeException这样的异常中catch并恢复,但是并不鼓励终端程序员这么做,因为完全没要必要。因为这类错误本身就是bug,应该被修复,出现此类错误时程序就应该立即停止执行。 因此,面对Errors和unchecked exceptions应该让程序自动终止执行,程序员不该做诸如try/catch这样的事情,而是应该查明原因,修改代码逻辑。

    更多相关内容
  • 主要介绍了Java异常处理 Throwable实现方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java Exception中Throwable和Exception之间的区别
  • 主要介绍了Java中所有错误和异常的父类java.lang.Throwable,文章中简单地分析了其源码,说明在代码注释中,需要的朋友可以参考下
  • 节点API的Throwable HTTP错误。 安装 npm i throwable-http-errors 用法 const Errors = require ( 'throwable-http-errors' ) // for example, using express.js router . post ( '/' , wrap ( async ( req , res ,...
  • 捕获Exception时,不会捕获error,像out of memory这种问题会在中间件的日志...捕获Throwable时,会捕获Exception和Error,像out of memory这种问题也会被捕获到,而程序对于这种Error没法进行处理,没有捕获的必要性。
  • Throwable源码异常分析

    2021-09-09 17:02:59
    Throwable是所有异常的父类,那么异常到底包含哪些信息呢? 1.Throwable包含哪些成员变量? public class Throwable implements Serializable { private transient volatile Object backtrace; //异常信息 ...

    问题:

    Throwable是所有异常的父类,那么异常到底包含哪些信息呢?

    1.Throwable包含哪些成员变量?

    public class Throwable implements Serializable {
        private transient volatile Object backtrace;
        //异常信息
        private String detailMessage;
        //当前异常是由哪个Throwable所引起的
        private Throwable cause = this;
        //引起异常的堆栈跟踪信息
        private StackTraceElement[] stackTrace = libcore.util.EmptyArray.STACK_TRACE_ELEMENT;
    }

    backtrace:这个变量由native方法赋值,用来保存栈信息的轨迹;

    detailMessage:这个变量是描述异常信息,比如new  InsertFailException("can't insert table"),记录的是传进去描述此异常的描述信息"can't insert table";

    case:记录当前异常是由哪个异常所引起的,默认是this,可通过构造器自定义;可以通过initCase方法进行修改:

    public synchronized Throwable initCause(Throwable cause) {
            if (this.cause != this)
                throw new IllegalStateException("Can't overwrite cause with " +
                                                Objects.toString(cause, "a null"), this);
            if (cause == this)
                throw new IllegalArgumentException("Self-causation not permitted", this);
            this.cause = cause;
            return this;
        }

    可以看到case只能被修改一次,当发现case已经被修改,则会抛出IllegalStateException异常;默认case=this,如果再次修改case为this也是不允许的;

    case一般这样使用:

          try {
              lowLevelOp();
          } catch (LowLevelException le) {
              throw (HighLevelException)
                    new HighLevelException().initCause(le); // Legacy constructor
          }

    stackTrace:记录当前异常堆栈信息,数组中每一个StackTraceElement表示当前方法调用的一个栈帧,表示一次方法调用;StackTraceElement中保存的有当前方法的类名,方法名,文件名,行号信息;

    public final class StackTraceElement implements java.io.Serializable {
        // Normally initialized by VM (public constructor added in 1.5)
        private String declaringClass;
        private String methodName;
        private String fileName;
        private int    lineNumber;
        
        public String toString() {
            // Android-changed: When ART cannot find a line number, the lineNumber field is set
            // to the dex_pc and the fileName field is set to null.
            StringBuilder result = new StringBuilder();
            result.append(getClassName()).append(".").append(methodName);
            if (isNativeMethod()) {
                result.append("(Native Method)");
            } else if (fileName != null) {
                if (lineNumber >= 0) {
                    result.append("(").append(fileName).append(":").append(lineNumber).append(")");
                } else {
                    result.append("(").append(fileName).append(")");
                }
            } else {
                if (lineNumber >= 0) {
                    // The line number is actually the dex pc.
                    result.append("(Unknown Source:").append(lineNumber).append(")");
                } else {
                    result.append("(Unknown Source)");
                }
            }
            return result.toString();
        }
    }

    下面代码为打印堆栈信息:

    public class Main {
    	public static void main(String[] args) {
    		b();
    	}
    	public static void b() {
    		Throwable th = new Throwable();
    		for (StackTraceElement e : th.getStackTrace()) {
    			System.out.println(e);
    		}
    	}
    }
    -------运行结果------
    com.gome.test.exception.Main.b(Main.java:24)
    com.gome.test.exception.Main.main(Main.java:20)

    2.Throwable的构造函数

        public Throwable() {
            fillInStackTrace();
        }
    
        public Throwable(String message) {
            fillInStackTrace();
            detailMessage = message;
        }
    
        public Throwable(String message, Throwable cause) {
            fillInStackTrace();
            detailMessage = message;
            this.cause = cause;
        }
    
        public Throwable(Throwable cause) {
            fillInStackTrace();
            detailMessage = (cause==null ? null : cause.toString());
            this.cause = cause;
        }
    
        protected Throwable(String message, Throwable cause,
                            boolean enableSuppression,
                            boolean writableStackTrace) {
            if (writableStackTrace) {
                fillInStackTrace();
            } else {
                stackTrace = null;
            }
            detailMessage = message;
            this.cause = cause;
            if (!enableSuppression)
                suppressedExceptions = null;
        }

    Throwable提供了4个public构造器和1个protected构造器(该构造器由JDK1.7引入);4个public构造器共同点是都调用了fillInStackTrace()方法;

    3.fillInStackTrace()方法

    public synchronized Throwable fillInStackTrace() {
            if (stackTrace != null ||
                backtrace != null /* Out of protocol state */ ) {
                backtrace = nativeFillInStackTrace();
                stackTrace = libcore.util.EmptyArray.STACK_TRACE_ELEMENT;
            }
            return this;
        }

    fillInStackTrace会首先判断stackTrace是否为null,如果不为null则会调用native方法nativeFillInStackTrace()将当前线程的栈帧信息记录到此Throwable中,那么什么时候为null呢,答案是上面的protected构造器可以指定writableStackTrace为false,这样stackTrace就为null了,就不会调用nativeFillInStackTrace获取堆栈信息。

    nativeFillInStackTrace将当前线程的栈帧信息记录到此Throwable中,为了理解我们看一个例子:

    正常情况下我们抛出RuntimeException,异常打印是带有异常堆栈信息的:

    package com.gome.childrenmanager;
    
    public class InsertUserException extends RuntimeException{
        public static void insert1(){
            System.out.println("Method:insert1()");
            insert2();
        }
    
        public static void insert2(){
            System.out.println("Method:insert2()");
            insert3();
        }
    
        public static void insert3(){
            System.out.println("Method:insert3()");
            insert4();
        }
        public static void insert4(){
            throw new InsertUserException();
        }
    
        public static void main(String[] args) {
            insert1();
        }
    }
    

    运行结果:

    Method:insert1()
    Method:insert2()
    Method:insert3()
    Class transformation time: 0.0137006s for 112 classes or 1.2232678571428573E-4s per class
    Exception in thread "main" com.gome.childrenmanager.InsertUserException
    	at com.gome.childrenmanager.InsertUserException.insert4(InsertUserException.java:19)
    	at com.gome.childrenmanager.InsertUserException.insert3(InsertUserException.java:16)
    	at com.gome.childrenmanager.InsertUserException.insert2(InsertUserException.java:11)
    	at com.gome.childrenmanager.InsertUserException.insert1(InsertUserException.java:6)
    	at com.gome.childrenmanager.InsertUserException.main(InsertUserException.java:23)

    我们来重写fillInStackTrace()方法,看一下运行效果:

    public class InsertUserException extends RuntimeException{
        
        @Override
        public synchronized Throwable fillInStackTrace() {
            return this;
        }
    
        public static void insert1(){
            System.out.println("Method:insert1()");
            insert2();
        }
    
        public static void insert2(){
            System.out.println("Method:insert2()");
            insert3();
        }
    
        public static void insert3(){
            System.out.println("Method:insert3()");
            insert4();
        }
        public static void insert4(){
            throw new InsertUserException();
        }
    
        public static void main(String[] args) {
            insert1();
        }
    }

    输出:

    Method:insert1()
    Method:insert2()
    Method:insert3()
    Class transformation time: 0.0099176s for 112 classes or 8.855E-5s per class
    Exception in thread "main" com.gome.childrenmanager.InsertUserException

    从例子可以看到**fillInStackTrace作用是将当前线程的栈帧信息记录到此Throwable中**。

    4.addSuppressed()方法和getSuppressed()方法

     public final synchronized void addSuppressed(Throwable exception) {
            if (exception == this)
                throw new IllegalArgumentException(SELF_SUPPRESSION_MESSAGE, exception);
    
            if (exception == null)
                throw new NullPointerException(NULL_CAUSE_MESSAGE);
    
            if (suppressedExceptions == null) // Suppressed exceptions not recorded
                return;
    
            if (suppressedExceptions.isEmpty())
                suppressedExceptions = new ArrayList<>(1);
    
            suppressedExceptions.add(exception);
        }
    
        private static Throwable[] EMPTY_THROWABLE_ARRAY;
    
        public final synchronized Throwable[] getSuppressed() {
            if (EMPTY_THROWABLE_ARRAY == null) {
                EMPTY_THROWABLE_ARRAY = new Throwable[0];
            }
    
            if (suppressedExceptions == null || suppressedExceptions.isEmpty())
                return EMPTY_THROWABLE_ARRAY;
            else
                return suppressedExceptions.toArray(EMPTY_THROWABLE_ARRAY);
        }

    如果try中抛出异常,在执行流程转移到方法栈上一层之前,finall语句块会执行,但是,如果在finally语句块中又抛出了一个异常,那么这个异常会覆盖掉之前抛出的异常,这有点像finally中return被覆盖了,比如下面这个例子:

    public static void main(String[] args) {
            try{
                Integer.valueOf("one");
            }catch (NumberFormatException e){
                throw new RuntimeException("One", e);
            }finally {
                try{
                    Integer.valueOf("two");
                }catch (NumberFormatException e){
                    throw new RuntimeException("Two", e);
                }
            }
        }

    输出:

    Exception in thread "main" java.lang.RuntimeException: Two
    	at com.gome.childrenmanager.InsertUserException.main(InsertUserException.java:39)
    Caused by: java.lang.NumberFormatException: For input string: "two"
    	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    	at java.lang.Integer.parseInt(Integer.java:580)
    	at java.lang.Integer.valueOf(Integer.java:766)
    	at com.gome.childrenmanager.InsertUserException.main(InsertUserException.java:37)

    Throwable对象提供了addSupperssed和getSupperssed方法,允许把finally语句块中产生的异常通过addSupperssed方法添加到try语句产生的异常中。

    public static void main(String[] args) {
            RuntimeException e1 = null;
            try{
                Integer.valueOf("one");
            }catch (NumberFormatException e){
                e1 =new RuntimeException("One", e);
                throw e1;
            }finally {
                try{
                    Integer.valueOf("two");
                }catch (NumberFormatException e){
                    RuntimeException e2 = new RuntimeException("Two", e);
                    e1.addSuppressed(e2);
                    throw e1;
                }
            }
        }

    输出:

    Exception in thread "main" java.lang.RuntimeException: One
    	at com.gome.childrenmanager.InsertUserException.main(InsertUserException.java:35)
    	Suppressed: java.lang.RuntimeException: Two
    		at com.gome.childrenmanager.InsertUserException.main(InsertUserException.java:41)
    	Caused by: java.lang.NumberFormatException: For input string: "two"
    		at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    		at java.lang.Integer.parseInt(Integer.java:580)
    		at java.lang.Integer.valueOf(Integer.java:766)
    		at com.gome.childrenmanager.InsertUserException.main(InsertUserException.java:39)
    Caused by: java.lang.NumberFormatException: For input string: "one"
    	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
    	at java.lang.Integer.parseInt(Integer.java:580)
    	at java.lang.Integer.valueOf(Integer.java:766)
    	at com.gome.childrenmanager.InsertUserException.main(InsertUserException.java:33)
    Class transformation time: 0.0109227s for 113 classes or 9.666106194690266E-5s per class

    5.PrintStackTrace

    printStackTrace()方法分四个方面打印出当前异常信息

    1)打印出当前异常的详细信息

    2) 打印出异常堆栈中的栈帧信息

    3) 打印出suppress异常信息

    4) 递归打印出引起当前异常的异常信息

        public void printStackTrace() {
            printStackTrace(System.err);
        }
    
    
        public void printStackTrace(PrintStream s) {
            printStackTrace(new WrappedPrintStream(s));
        }
    
        private void printStackTrace(PrintStreamOrWriter s) {
            // Guard against malicious overrides of Throwable.equals by
            // using a Set with identity equality semantics.
            Set<Throwable> dejaVu =
                Collections.newSetFromMap(new IdentityHashMap<Throwable, Boolean>());
            dejaVu.add(this);
    
            synchronized (s.lock()) {
                // 打印当前异常的详细信息
                s.println(this);
                // 打印当前堆栈中的栈帧信息
                StackTraceElement[] trace = getOurStackTrace();
                for (StackTraceElement traceElement : trace)
                    s.println("\tat " + traceElement);
    
                // 打印suppressed exceptions
                for (Throwable se : getSuppressed())
                    se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION, "\t", dejaVu);
    
                // 递归打印出引起当前异常的异常信息
                Throwable ourCause = getCause();
                if (ourCause != null)
                    ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, "", dejaVu);
            }
        }
    
        /**
         * Print our stack trace as an enclosed exception for the specified
         * stack trace.
         */
        private void printEnclosedStackTrace(PrintStreamOrWriter s,
                                             StackTraceElement[] enclosingTrace,
                                             String caption,
                                             String prefix,
                                             Set<Throwable> dejaVu) {
            if (dejaVu.contains(this)) {
                s.println("\t[CIRCULAR REFERENCE:" + this + "]");
            } else {
                dejaVu.add(this);
                // Compute number of frames in common between this and enclosing trace
                StackTraceElement[] trace = getOurStackTrace();
                int m = trace.length - 1;
                int n = enclosingTrace.length - 1;
                while (m >= 0 && n >=0 && trace[m].equals(enclosingTrace[n])) {
                    m--; n--;
                }
                int framesInCommon = trace.length - 1 - m;
    
                // Print our stack trace
                s.println(prefix + caption + this);
                for (int i = 0; i <= m; i++)
                    s.println(prefix + "\tat " + trace[i]);
                if (framesInCommon != 0)
                    s.println(prefix + "\t... " + framesInCommon + " more");
    
                // Print suppressed exceptions, if any
                for (Throwable se : getSuppressed())
                    se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION,
                                               prefix +"\t", dejaVu);
    
                // Print cause, if any
                Throwable ourCause = getCause();
                if (ourCause != null)
                    ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, prefix, dejaVu);
            }
        }

    参考:

    https://blog.csdn.net/weixin_39787628/article/details/111118098

    https://zhuanlan.zhihu.com/p/402638614

    展开全文
  • Throwable类的详细解释

    2021-10-24 11:24:34
    ) IllegalStateException - 如果此 throwable 通过 Throwable(Throwable) 或 Throwable(String,Throwable) 创建,或者此方法已经在此 throwable 上进行调用。 从以下版本开始: 1.4 ---------------------------...

    概述  软件包   类  使用  树  已过时  索引  帮助  
     JavaTM 2 Platform
    Standard Ed. 5.0  
     上一个类   下一个类 框架    无框架    所有类  
    摘要: 嵌套 | 字段 | 构造方法 | 方法 详细信息: 字段 | 构造方法 | 方法 


    --------------------------------------------------------------------------------
    object 老祖宗
    要点:是所有异常信息的祖宗类


    java.lang 
    类 Throwable
    java.lang.Object
      继承者 java.lang.Throwable
    所有已实现的接口: 
    java.io.Serializable 
    直接已知子类: 
    Error, Exception 


    --------------------------------------------------------------------------------


    public class Throwableextends Objectimplements java.io.SerializableThrowable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类(或其子类之一)的实例时,才能通过 Java 虚拟机或者 Java throw 语句抛出。类似地,只有此类或其子类之一才可以是 catch 子句中的参数类型。 


    两个子类的实例,Error 和 Exception,通常用于指示发生了异常情况。通常,这些实例是在异常情况的上下文中新近创建的,因此包含了相关的信息(比如堆栈跟踪数据)。 


    Throwable 包含了其线程创建时线程执行堆栈的快照。它还包含了给出有关错误更多信息的消息字符串。最后,它还可以包含 cause(原因):另一个导致此 throwable 抛出的 throwable。此 cause 设施在 1.4 版本中首次出现。它也称为异常链 设施,因为 cause 自身也会有 cause,依此类推,就形成了异常链,每个异常都是由另一个异常引起的。 


    导致 throwable 可能具有 cause 的一个原因是,抛出它的类构建在低层抽象的基础上,从而高层操作由于低层操作的失败而失败。因此让低层抛出的 throwable 向外传播并非一种好的设计方法,因为它通常与高层提供的抽象不相关。此外,这样做会将高层 API 与其实现细节关联起来,并认为低层异常是经过检查的异常。抛出“经过包装的异常”(即包含 cause 的异常)允许高层与其调用方交流失败详细信息,而不会招致上述任何一个缺点。这种方式保留了改变高层实现而不改变其 API 的灵活性(尤其是,异常集合通过其方法抛出)。 


    导致 throwable 可能具有 cause 的另一个原因是,抛出它的方法必须符合不允许方法直接抛出 cause 的通用接口。例如,假定持久集合符合 Collection 接口,而其持久性在 java.io 的基础上实现。假定 put 方法的内部可以抛出 IOException。实现可以与其调用方交流 IOException 的详细消息,同时通过以一种合适的未检查的异常来包装 IOException,使其符合 Collection 接口。(持久集合的规范应该指示它能够抛出这种异常。) 


    Cause 可以通过两种方式与 throwable 关联起来:通过一个将 cause 看作参数的构造方法;或者通过 initCause(Throwable) 方法。对于那些希望将 cause 与其关联起来的新 throwable 类,应该提供带有 cause 的构造方法,并委托(可能间接)给一个带有 cause 的 Throwable 构造方法。例如: 


         try {
             lowLevelOp();
         } catch (LowLevelException le) {
             throw new HighLevelException(le);  // Chaining-aware constructor
         }
     因为 initCause 方法是公共的,它允许 cause 与任何 throwable 相关联,甚至包括“遗留 throwable”,它的实现提前将异常链机制的附件应用到 Throwable。例如: 
         try {
             lowLevelOp();
         } catch (LowLevelException le) {
             throw (HighLevelException)
                     new HighLevelException().initCause(le);  // Legacy constructor
         }
     在版本 1.4 之前,许多 throwable 有自己的非标准异常链机制( ExceptionInInitializerError、 ClassNotFoundException、 UndeclaredThrowableException、 InvocationTargetException、 WriteAbortedException、 PrivilegedActionException、 PrinterIOException、 RemoteException 和 javax.naming.NamingException)。所有这些 throwable 都已经更新过,可以使用标准异常链机制,同时继续实现其“遗留”链机制,以保持兼容性。 


    此外,从版本 1.4 开始,许多通用的 Throwable 类(例如,Exception、RuntimeException、Error)都已经更新,具有带 cause 的构造方法。由于有 initCause 方法存在,这并非严格的要求,但委托给一个带有 cause 的构造方法将更方便也更形象。 


    根据惯例,Throwable 类及其子类有两个构造方法,一个不带参数,另一个带有 String 参数,此参数可用于生成详细消息。此外,对于那些与其相关联的 cause 的子类,它们应有两个构造方法,一个带 Throwable(cause),一个带 String(详细消息)和 Throwable(cause)。 


    在版本 1.4 中还引入了 getStackTrace() 方法,它允许通过各种形式的 printStackTrace() 方法编程访问堆栈跟踪信息,这些信息以前只能以文本形式使用。此信息已经添加到该类的序列化表示形式,因此 getStackTrace 和 printStackTrace 将可在反序列化时获得的 throwable 上正确操作。 


    从以下版本开始: 
    JDK1.0 
    另请参见:
    序列化表格


    --------------------------------------------------------------------------------


    构造方法摘要 
    Throwable() 
              构造一个将 null 作为其详细消息的新 throwable。 
    Throwable(String message) 
              构造带指定详细消息的新 throwable。 
    Throwable(String message, Throwable cause) 
              构造一个带指定详细消息和 cause 的新 throwable。 
    Throwable(Throwable cause) 
              构造一个带指定 cause 和 (cause==null ? null :cause.toString())(它通常包含类和 cause 的详细消息)的详细消息的新 throwable。 
      方法摘要 
     Throwable fillInStackTrace() 
              记录异常堆栈跟踪。 
     Throwable getCause() 
              返回此 throwable 的 cause;或者如果 cause 不存在或未知,则返回 null。 
     String getLocalizedMessage() 
              创建此 throwable 的本地化描述。 
     String getMessage() 
              返回此 throwable 的详细消息字符串。 
     StackTraceElement[] getStackTrace() 
              提供编程访问由 printStackTrace() 输出的堆栈跟踪信息。 
     Throwable initCause(Throwable cause) 
              将此 throwable 的 cause 初始化为指定值。 
     void printStackTrace() 
              将此 throwable 及其追踪输出至标准错误流。 
     void printStackTrace(java.io.PrintStream s) 
              将此 throwable 及其追踪输出到指定的输出流。 
     void printStackTrace(java.io.PrintWriter s) 
              将此 throwable 及其追踪输出到指定的 PrintWriter。 
     void setStackTrace(StackTraceElement[] stackTrace) 
              设置将由 getStackTrace() 返回,并由 printStackTrace() 和相关方法输出的堆栈跟踪元素。 
     String toString() 
              返回此 throwable 的简短描述。 
      从类 java.lang.Object 继承的方法 
    clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait 
      


    构造方法详细信息 


    Throwable
    public Throwable()构造一个将 null 作为其详细消息的新 throwable。Cause 尚未进行初始化,可在以后通过调用 initCause(java.lang.Throwable) 来初始化。 
    调用 fillInStackTrace() 方法来初始化新创建的 throwable 中的堆栈跟踪数据。 


    --------------------------------------------------------------------------------


    Throwable
    public Throwable(String message)构造带指定详细消息的新 throwable。Cause 尚未进行初始化,可在以后通过调用 initCause(java.lang.Throwable) 来初始化。 
    调用 fillInStackTrace() 方法来初始化新创建的 throwable 中的堆栈跟踪数据。 


    参数:
    message - 详细消息。保存这个详细消息,以便以后通过 getMessage() 方法对其进行检索。


    --------------------------------------------------------------------------------


    Throwable
    public Throwable(String message,
                     Throwable cause)构造一个带指定详细消息和 cause 的新 throwable。
    注意,与 cause 相关的详细消息不会 被自动合并到此 throwable 的详细消息中的。 


    调用 fillInStackTrace() 方法来初始化新创建的 throwable 中的堆栈跟踪数据。 


    参数:
    message - 详细消息(保存此消息,以便以后通过 getMessage() 方法检索它)。
    cause - 原因(保存此 cause,以便以后通过 getCause() 方法检索它)。(允许 null 值,指出 cause 是不存在的或是未知的。)
    从以下版本开始: 
    1.4 


    --------------------------------------------------------------------------------


    Throwable
    public Throwable(Throwable cause)构造一个带指定 cause 和 (cause==null ? null :cause.toString())(它通常包含类和 cause 的详细消息)的详细消息的新 throwable。此构造方法对于那些与其他 throwable(例如,PrivilegedActionException)的包装器相同的 throwable 来说是有用的。 
    调用 fillInStackTrace() 方法来初始化新创建的 throwable 中的堆栈跟踪数据。 


    参数:
    cause - 原因(保存此 cause,以便以后通过 getCause() 方法检索它)。(允许 null 值,指出 cause 是不存在的或是未知的。)
    从以下版本开始: 
    1.4 
    方法详细信息 


    getMessage
    public String getMessage()返回此 throwable 的详细消息字符串。 


    返回:
    此 Throwable 实例的详细消息字符串(可以为 null)。


    --------------------------------------------------------------------------------


    getLocalizedMessage
    public String getLocalizedMessage()创建此 throwable 的本地化描述。子类可以重写此方法,以便生成特定于语言环境的消息。对于不重写此方法的子类,默认实现返回与 getMessage() 相同的结果。 


    返回:
    此 throwable 的本地化描述。
    从以下版本开始: 
    JDK1.1 


    --------------------------------------------------------------------------------


    getCause
    public Throwable getCause()返回此 throwable 的 cause;或者如果 cause 不存在或未知,则返回 null。(该 Cause 是导致抛出此 throwable 的throwable。) 
    此实现返回由一个需要 Throwable 的构造方法提供的 cause,或者在创建之后通过 initCause(Throwable) 方法进行设置的 cause。虽然通常不需要重写此方法,但子类可以重写它,以返回一个通过某些其他方式设置的 cause。这适用于在异常链(异常嵌套)机制被加入到 Throwable 之前存在“遗留 Throwable 链机制”的情况。注意,不必 重写任何 PrintStackTrace 方法,所有方法都调用 getCause 方法来确定 throwable 的 cause。 


    返回:
    此 throwable 的 cause,如果 cause 不存在或是未知的,则返回 null。
    从以下版本开始: 
    1.4 


    --------------------------------------------------------------------------------


    initCause
    public Throwable initCause(Throwable cause)将此 throwable 的 cause 初始化为指定值。(该 Cause 是导致抛出此 throwable 的throwable。) 
    此方法至多可以调用一次。此方法通常从构造方法中调用,或者在创建 throwable 后立即调用。如果此 throwable 通过 Throwable(Throwable) 或 Throwable(String,Throwable) 创建,此方法甚至一次也不能调用。 


    参数:
    cause - 原因(保存此 cause,以便以后通过 getCause() 方法检索它)。(允许 null 值,指出 cause 是不存在的或是未知的。) 
    返回:
    对此 Throwable 实例的引用。 
    抛出: 
    IllegalArgumentException - 如果 cause 是此 throwable。(throwable 不能是它自己的 cause。) 
    IllegalStateException - 如果此 throwable 通过 Throwable(Throwable) 或 Throwable(String,Throwable) 创建,或者此方法已经在此 throwable 上进行调用。
    从以下版本开始: 
    1.4 


    --------------------------------------------------------------------------------


    toString
    public String toString()返回此 throwable 的简短描述。如果此 Throwable 对象是利用非空详细消息字符串创建的,则结果是三个字符串的串联: 
    此对象的实际类的名称 
    ": "(冒号和空格) 
    此对象的 getMessage() 方法的结果 
    如果此 Throwable 对象利用 null 详细消息字符串创建,则返回此对象的实际类的名称。 


    覆盖:
    类 Object 中的 toString
    返回:
    该 throwable 的字符串表示形式。


    --------------------------------------------------------------------------------


    printStackTrace
    public void printStackTrace()将此 throwable 及其追踪输出至标准错误流。此方法将此 Throwable 对象的堆栈跟踪输出至错误输出流,作为字段 System.err 的值。输出的第一行包含此对象的 toString() 方法的结果。剩余行表示以前由方法 fillInStackTrace() 记录的数据。此信息的格式取决于实现,但以下示例是最常见的: 
     java.lang.NullPointerException
             at MyClass.mash(MyClass.java:9)
             at MyClass.crunch(MyClass.java:6)
             at MyClass.main(MyClass.java:3)
     本示例通过运行以下程序生成: 
     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]);
         }
     }
     对于带初始化非空 cause 的 throwable 的追踪,通常应该包括 cause 的追踪。此信息的格式取决于实现,但以下示例是最常见的: 
     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
     注意包含字符 "..." 的行。这些行指示此异常的椎栈跟踪的其余部分是从“终止”异常(由此异常引起的异常)的堆栈跟踪底部算起的指定数量帧。这种简写形式可以大大缩短通常情况下的输出长度,通常情况下抛出经过包装的异常所采用的方法与捕获“作为 cause 的异常”所采用的方法相同。上述示例通过运行以下程序生成: 
     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 {
     }
     


    --------------------------------------------------------------------------------


    printStackTrace
    public void printStackTrace(java.io.PrintStream s)将此 throwable 及其追踪输出到指定的输出流。 


    参数:
    s - 用于输出的 PrintStream


    --------------------------------------------------------------------------------


    printStackTrace
    public void printStackTrace(java.io.PrintWriter s)将此 throwable 及其追踪输出到指定的 PrintWriter。 


    参数:
    s - 用于输出的 PrintWriter
    从以下版本开始: 
    JDK1.1 


    --------------------------------------------------------------------------------


    fillInStackTrace
    public Throwable fillInStackTrace()记录异常堆栈跟踪。此方法在此 Throwable 对象中记录与当前线程堆栈帧的当前状态有关的信息。 


    返回:
    对此 Throwable 实例的引用。
    另请参见:
    printStackTrace()


    --------------------------------------------------------------------------------


    getStackTrace
    public StackTraceElement[] getStackTrace()提供编程访问由 printStackTrace() 输出的堆栈跟踪信息。返回堆栈跟踪元素的数组,每个元素表示一个堆栈帧。数组的第零个元素(假定数据的长度为非零)表示堆栈顶部,它是序列中最后的方法调用。通常,这是创建和抛出该 throwable 的地方。数组的最后元素(假定数据的长度为非零)表示堆栈底部,它是序列中第一个方法调用。 
    某些虚拟机在某些情况下可能会省略堆栈跟踪中的一个或多个堆栈帧。在极端情况下,没有该 throwable 堆栈跟踪信息的虚拟机可以从该方法返回一个零长度数组。一般说来,对于由 printStackTrace 输出的每个帧,此方法返回的数组都将包含一个对应的元素。 


    返回:
    堆栈跟踪元素的数组,表示与此 throwable 相关的堆栈跟踪。
    从以下版本开始: 
    1.4 


    --------------------------------------------------------------------------------


    setStackTrace
    public void setStackTrace(StackTraceElement[] stackTrace)设置将由 getStackTrace() 返回,并由 printStackTrace() 和相关方法输出的堆栈跟踪元素。 此方法设计用于 RPC 框架和其他高级系统,允许客户端重写默认堆栈跟踪,这些默认堆栈跟踪要么在构造 throwable 时由 fillInStackTrace() 生成,要么在从序列化流读取 throwable 时反序列化。 


    参数:
    stackTrace - 要与此 Throwable 关联的堆栈跟踪元素。指定的数组由此调用复制;在方法调用返回后,指定数组中的改变将不会对此 Throwable 的堆栈跟踪产生影响。 
    抛出: 
    NullPointerException - 如果 stackTrace 为 null,或者如果 stackTrace 中的任何元素为 null
    从以下版本开始: 
    1.4 


    --------------------------------------------------------------------------------
    概述  软件包   类  使用  树  已过时  索引  帮助  
     JavaTM 2 Platform
    Standard Ed. 5.0  
     上一个类   下一个类 框架    无框架    所有类  
    摘要: 嵌套 | 字段 | 构造方法 | 方法 详细信息: 字段 | 构造方法 | 方法 


    --------------------------------------------------------------------------------
    提交错误或意见
    有关更多的 API 参考资料和开发人员文档,请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述,以及总体概述、术语定义、使用技巧和工作代码示例。 
     

    展开全文
  • Throwable

    2021-04-02 21:43:36
    各大异常

    各大异常
    在这里插入图片描述

    展开全文
  • 为了支持此功能,添加到 Throwable 的任何新字段需要初始化为非空值,都需要协调 JVM 更改 */ /** * 导致该 throwable 被抛出的 throwable,如果该 throwable 不是由另一个 throwable 引起的, * 或者如果导致该 ...
  • lang——Throwable子类

    2021-03-16 14:27:48
    本文导引:Throwable概述Throwable是lang包的一级子类,是 Java 语言中所有错误或异常的超类。Throwable有两个子类,即Error 和Exception。Error用于指示合理的应用程序不应该试图捕获的严重问题不会被捕获 --> ...
  • Java中throw、throws和Throwable的联系与区别
  • PHP 中的 Exception, Error, ThrowablePHP 中将代码自身异常(一般是环境或者语法**所致)称作错误Error,将运行**现的逻辑错误称为异常Exception错误是...该接口由Error和Exception实现,用户不能直接实现Throwable...
  • java异常的根类为java.lang.Throwable,整个类有两个直接子类java.lang.Error和java.lang.Exception。 Error是程序本身无法恢复的严重错误,一般是虚拟机或者系统运行出现错误,和程序无关。Exception则表示可以被...
  • 一、throwable的正常语意throwable是一个正常的英文单词,该英文单词翻译成中文的语意是异常的意思,也表示抛出、没有测试以及可抛出异常的中文意思。像这种英文单词其实在不同的语境中扮演着不同的角色都有多重含义...
  • PHP Throwable接口

    2021-03-26 14:33:12
    介绍在PHP 7中,Throwable接口充当任何对象的基础,该对象可以是throw语句的参数,包括Error和Exception。...以下抽象方法在Throwable接口中定义-语法Throwable{/*Methods*/abstractpublicgetMessage(voi...
  • 有几个现象是需要总结的:--------------------------------------在java语言中,错误类的基类是...相同点:java.lang.Error和java.lang.Exception都是java.lang.Throwable的子类,因此java.lang.Error和java.lang...
  • 应该catch什么 其实只要是Throwable和其子类都是可以throw和catch的,那么如果在需要统一处理异常的地方,我们应该catch (Throwable th) 还是 catch (Exception)呢? 这两种处理的区别在于,catch throwable会把...
  • java.lang.*中Throwable 源代码详解Throwable详解Throwable的使用场景核心方法 学习Java的同学注意了!!! 学习过程中遇到什么问题或者想获取学习资源的话,欢迎加入Java学习交流群,群号码:543120397 我们一起学...
  • JAVA异常类Throwable解析

    2021-02-12 14:20:10
    在 Java 中,所有的异常都有一个共同的祖先java.lang包中的 Throwable类。Throwable: 有两个重要的子类:Exception(异常)和 Error(错误) ;二者都是Java 异常处理的重要子类,各自都包含大量子类。Error(错误):是...
  • Throwable异常树 受查异常(编译异常):在编译时被强制检查的异常,必须处理,否则程序编译不通过。 子类1:Error(错误) 是程序无法处理的错误。指示合理的应用程序不应尝试捕获的严重问题。这些错误是不...
  • 在Java中,当你需要统一处理异常的时候,你是会选择catch (Exception),还是直接catch (Throwable)?Java的异常体系Throwable: Java中所有异常和错误类的父类。只有这个类的实例(或者子类的实例)可以被虚拟机抛出...
  • /*//Throwable所有异常的超类Exception -编译异常,可以throws或者try{}catch{} -子类RuntimeException -运行异常,可以不处理,让JVM处理Error -无法处理,必须修改源代码,内存溢出,系统崩溃 -子类异常处理过程:...
  • Java---Throwable

    千次阅读 2019-08-16 14:59:06
    文章目录Throwable类什么是Throwable?异常的分类为什么需要将Throwable设计成普通类?问题引入:为什么需要处理异常?JVM处理异常的方式我们处理异常的方式try...catch...finally异常处理方法Throws异常处理方法...
  • Java中异常的集成关系: Throwable : 所有异常均集成自这个接口 Error 和 Exception : Throwable 接口在JDK中只有两个子类,分别是Error 和Exception。Error,代表有严重的事情发生了,不可恢复 Excep...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 397,164
精华内容 158,865
关键字:

throwable

友情链接: 新建文件夹 (4).zip