【原】Java学习笔记030 - 异常

package cn.temptation;

public class Sample01 {
    public static void main(String[] args) {
        /*
         * 异常：Java程序在运行过程中出现的错误
         * 
         * 类 Throwable：Java 语言中所有错误或异常的超类。
         * 只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。
         * 类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。 
         * 
         * 类 Error：Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。
         * 大多数这样的错误都是异常条件。虽然 ThreadDeath 错误是一个“正规”的条件，但它也是 Error 的子类，因为大多数应用程序都不应该试图捕获它。 
         * 
         * 类 Exception：Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。 
         * 
         * 异常的分类：
         * 1、编译时异常：Exception类中除去RuntimeException及其子类以外其他的
         * 2、运行时异常：RuntimeException及其子类
         * 
         * 异常的处理方式：
         * 1、try...catch...finally格式及其变体
         * 2、throws/throw
         * 
         * try...catch...finally处理方式：
         * try {
         *         可能出现问题的代码
         * } catch(异常名称   变量) {
         *         针对问题的处理
         * } finally {
         *         释放资源等操作
         * }
         * 
         * try...catch...finally处理的变体方式：
         * try {
         *         可能出现问题的代码
         * } catch(异常名称   变量) {
         *         针对问题的处理
         * }
         */
        
        // 下句语句编译阶段无语法错误，但是执行时产生异常，这个异常不是由开发人员来处理，应该由开发人员编写代码时就进行判断处理
//        System.out.println(2 / 0);
        
        // 【针对单个异常】
//        try {
//            System.out.println(2 / 0);
//        } catch (ArithmeticException e) {
//            System.out.println("除数不能为0");
//        }
        
        // 【针对多个异常】
        int[] arr = { 1, 2, 3 };
        
//        try {
//            // 如果没有进行异常处理，执行时，首先JVM捕获数组越界异常
//            System.out.println(arr[3]);
//            System.out.println(2 / 0);
//        } catch (ArrayIndexOutOfBoundsException e) {
//            System.out.println("数组的索引越界");
//        } catch (ArithmeticException e) {
//            System.out.println("除数不能为0");
//        }
        
        // 上述的异常处理代码会显示"数组的索引越界"，因为代码的顺序执行，首先捕获到索引越界异常，如果解决掉这个问题，再执行会捕获到除数为0的异常
        
//        try {
//            System.out.println(arr[3]);
//            System.out.println(2 / 0);
//        } catch (Exception e) {
//            System.out.println("代码有问题");
//        }
        
        // 上述的异常处理代码使用异常基类Exception类，这样不用明确指出是哪一种异常（偷懒写法）
        
        // 【JDK 1.7之后开始支持的语法】
        try {
            System.out.println(arr[3]);
            System.out.println(2 / 0);
        } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {
            System.out.println("代码有问题");
        }
        
        // 上述的异常处理代码需要多个异常是针对同一类类型的问题，否则无法明确具体是什么异常
    }
}

package cn.temptation;

public class Sample02 {
    public static void main(String[] args) {
        /*
         * 对异常的两种处理方式的理解：
         * 类比生病
         * 1、哪里有病了哪里疼痛，直接就在对应的问题就发现问题
         * 2、有病的地方并不是病因产生的地方，而是病状呈现的地方，也就是问题不断抛出最后得到的结果
         */
        
        // try...catch...finally处理时的注意问题：
        // 1、同时使用父类异常 和  子类异常时，父类异常不能写在子类异常之前，否则有语法错误
//        try {
//            System.out.println(2 / 0);
//        } catch (Exception e) {
//            System.out.println("代码有问题");
//        } catch (ArithmeticException e) {
//            // 语法错误：Unreachable catch block for ArithmeticException. It is already handled by the catch block for Exception
//            System.out.println("除数不能为0");
//        }
        
        // 下面语句执行时显示子类异常信息
        try {
            System.out.println(2 / 0);
        } catch (ArithmeticException e) {
            // 语法错误：Unreachable catch block for ArithmeticException. It is already handled by the catch block for Exception
            System.out.println("除数不能为0");
        } catch (Exception e) {
            System.out.println("代码有问题");
        }
    }
}

package cn.temptation;

public class Sample03 {
    public static void main(String[] args) {
        /*
         * Throwable类的常用成员方法：
         * 1、String getMessage() ：返回此 throwable 的详细消息字符串。
         * 2、String toString() ：返回此 throwable 的简短描述。
         * 3、void printStackTrace() ：将此 throwable 及其追踪输出至标准错误流。 
         */
        
        try {
            System.out.println(2 / 0);
        } catch (Exception e) {
            System.out.println(e.getMessage());        // / by zero
            System.out.println(e.toString());        // java.lang.ArithmeticException: / by zero
            e.printStackTrace();                    // java.lang.ArithmeticException: / by zero at cn.temptation.Sample03.main(Sample03.java:13)
        }
    }
}

package cn.temptation;

public class Sample04 {
    public static void main(String[] args) {
        /*
         * throws 关键字的使用：
         * 定义方法时，使用throws关键字标记需要暴露出来被开发人员处理的问题
         */
        
        // 下句语句对calc方法的调用，因为在主函数中没有对calc方法抛出的异常进行处理，所以异常还是由jvm进行捕获
        // 调用calc方法，收到其抛出的异常，没有进行处理
//        calc();
        
        try {
            // 调用calc方法，收到其抛出的异常，并进行处理
            calc();
        } catch (ArithmeticException e) {
            System.out.println("除数不为0");
        }
    }
    
    // 在方法内部对异常不进行处理，在方法的声明上通过throws标记需要处理的异常，并向外抛出
    // 定义计算方法
    public static void calc() throws ArithmeticException {
        System.out.println(2 / 0);
    }
}

package cn.temptation;

public class Sample05 {
    public static void main(String[] args) {
        /*
         * throw关键字的使用：
         * 用在方法内部，出现某种情况程序无法继续运行时，需要进行跳转通过throw把异常对象进行抛出
         * 
         * 
         * throws 和 throw 的区别：
         * 1、throws
         * A：用在方法声明中，后面是异常类名
         * B：throws后可以有多个异常类名，之间使用英文逗号分隔
         * C：表示抛出异常，由方法的调用者进行处理
         * D：throws表示出现异常的可能，不一定会发生这些异常
         * 
         * 2、throw
         * A：用在方法内，后面是异常类的对象
         * B：throw后只能抛出一个异常对象
         * C：表示抛出异常，由方法内的语句处理，方法被调用时，调用方法处进行捕获处理
         * D：throw表示抛出异常，执行throw一定是抛出了某种异常
         */
        
        // 使用throw关键字，在方法中抛出异常的实例对象，方法调用时没有语法错误
//        calc();
        
        // 下面代码捕获到ArithmeticException异常，并执行catch代码块的处理
//        try {
//            calc();
//        } catch (ArithmeticException e) {
//            System.out.println("计算异常");
//        }
        
        // 方法声明上throws出的异常 和 方法内throw出的异常是父子关系，必须进行异常处理，否则就语法出错
//        method1();
        
//        try {
//            method1();
//        } catch (Exception e) {
//            System.out.println("除数不为0");
//        }
        
        // 方法声明上throws出的异常 和 方法内throw出的异常同级且不相同，以throw出的异常为准
        method2();
    }
    
    // 声明计算方法
    public static void calc() {
        int i = 2;
        int j = 0;
        
        if (j == 0) {        // 判断除数是0
            throw new ArithmeticException();
        } else {
            System.out.println(i / j);
        }
    }
    
    public static void method1() throws Exception {
        int i = 2;
        int j = 0;
        
        if (j == 0) {        // 判断除数是0
            throw new ArithmeticException();
        } else {
            System.out.println(i / j);
        }
    }
    
    public static void method2() throws ArrayIndexOutOfBoundsException {
        int i = 2;
        int j = 0;
        
        if (j == 0) {        // 判断除数是0
            throw new ArithmeticException();
        } else {
            System.out.println(i / j);
        }
    }
}

package cn.temptation;

public class Sample06 {
    public static void main(String[] args) {
        /*
         * 两种异常处理方式的选择：
         * 1、如果在方法内部进行处理，选择try...catch...finally结构
         * 2、如果在方法外部进行处理，选择throws/throw
         * 
         * finally的特点：finally中的语句一定会被执行
         * 注意：在执行finally语句块之前虚拟机终止了，那么finally语句块中的语句不会执行
         */
        
        try {
            System.out.println(2 / 0);
        } catch (Exception e) {
            System.out.println("异常处理");
            /*
             * System类的常用成员方法：
             * static void exit(int status) ：终止当前正在运行的 Java 虚拟机。 
             */
            System.exit(0);
        } finally {
            System.out.println("finally中的语句一定会被执行");
        }
    }
}

package cn.temptation;

public class Sample07 {
    public static void main(String[] args) {
        // 在try...catch...finally...结构中使用return的问题：
        // 1、catch语句块中有return语句，finally语句块中没有return语句，执行顺序为：
        //        先执行catch语句块中return语句之前的语句，再执行finally语句块中的语句，最后执行catch中的return语句，显示结果为4
        // 2、catch语句块中有return语句，finally语句块中也有return语句，执行顺序为：
        //        先执行catch语句块中return语句之前的语句，再执行catch中的return语句，然后执行finally语句块中的语句，最后执行finally语句块中的return语句，显示结果为5
        System.out.println(show());
    }
    
    public static int show() {
        try {
            System.out.println(2 / 0);
            return 3;
        } catch (Exception e) {
            System.out.println("异常处理");
            return 4;
        } finally {
            System.out.println("finally中的语句");
            return 5;
        }
    }
}

package cn.temptation;

public class Sample08 {
    public static void main(String[] args) {
        // try...catch...finally...形式
        // 完整形式
        try {
            
        } catch (Exception e) {

        } finally {
            
        }
        
        // try...catch..（单个异常）
        try {
            
        } catch (Exception e) {

        }
        
        // try...catch..（多个异常）
        try {
            
        } catch (ArithmeticException e) {
            
        } catch (Exception e) {
            
        }
        
        // try...finally...
        // 没有catch代码块结构语法也正确，这种形式目的是为了使用后释放资源
        try {
            
        } finally {

        }
        
        // 语法错误
//        try {
//            
//        }
        
        // 语法错误
//        catch (Exception e) {
//
//        }

        // 语法错误
//        catch (Exception e) {
//
//        } finally {
//            
//        }
        
        // 语法错误
//        finally {
//            
//        }
    }
}

package cn.temptation;

public class Sample09 {
    public static void main(String[] args) {
        // 自定义异常类
        try {
            show(200);
        } catch (TestException e) {
            e.printStackTrace();
        }
    }
    
    public static void show(int age) throws TestException {
        if (age < 0 || age > 150) {
            throw new TestException("年龄错误！");
        } else {
            System.out.println("年龄为：" + age);
        }
    }
}

/**
 * 自定义异常类
 */
class TestException extends Exception {
    // 构造函数
    public TestException() {
        
    }
    
    public TestException(String msg) {
        super(msg);
    }
}