java（4） 异常

1.Throwable 继承体系
    * Eorro
    * Exception
      --RuntimeException 该类及其子类用于表示运行时异常，Exception类下所有其他子类都用于表示编译时异常。
      --其他子类

2.Throwable 常用方法
    * String getMessage()   返回此 throwable 的详细消息字符串
    * void printStackTrace() 将此throwable 及其追踪输出至标准错误流
    * void printStackTrace(PrintStream s) 将此throwable 及其追踪输出到指定的输出流

3.try ... catch 
    * 程序发生异常会立即终止，无法继续向下执行。为了解决这样的问题，Java中提供了一个中对异常进行处理的方式--异常捕获

        class ExampleTest{

            public static void main(String[] args){

                try{
                    int result = divide(4,0);
                    System.out.println(result);

                }catch(Exception e){
                    System.out.println("捕获异常信息为："+e.getMessage());
                }
                System.out.println("程序继续向下执行");
            }

            public static int divide(int x,int y){
                int result = x / y;
                return result;
            }
        }
        --对可能发生异常的代码用 try ... catch语句进行处理。
        --在try代码中发生被0除的异常，程序会转而执行catch中的代码。
        --在try代码中，发生异常语句后面的代码是不会被执行的【System.out.println(result);】。
        --catch代码块对异常处理完毕后，程序仍会向下执行，而不会异常终止。语句【System.out.println("程序继续向下执行");】仍会被执行

4.finally
    * 程序中有些语句无论程序是否发生异常都要被执行，这时就可以在try...catch语句后加一个finally代码块。
        class ExampleTest{

            public static void main(String[] args){

                try{
                    int result = divide(4,0);
                    System.out.println(result);

                }catch(Exception e){
                    System.out.println("捕获异常信息为："+e.getMessage());
                    return;                                                    //用于结束当前语句
                }finally{
                    System.out.println("进入finally代码块");
                }
                System.out.println("程序继续向下执行");
            }

            public static int divide(int x,int y){
                int result = x / y;
                return result;
            }
        }
        --catch代码块中增加了return语句，用于结束当前方法，此时语句【System.out.println("程序继续向下执行");】就不会再被执行
        --finally 中的代码块仍会被执行
        --由于finally代码块的特性，通常用finally代码块释放系统资源

    * finally代码块有一种情况下是不会被执行的，那就是在try...catch语句中执行了【System.exit(0)】,该语句表示退出当前虚拟机。

5.throws 关键字
    -- 在上面的例子中，由于调用的是自己写的divide()的方法，因此很清楚该方法可能会发生异常。试想一下，如果是别人来调用该divide()方法，他如何判断该方法是否会产生异常及什么类型的异常？
    -- 针对这种情况，java中允许在方法的后面使用throws关键字对外声明该方法有可能产生何种类型的异常。这样，调用者就明确知道该方法有异常，并且必须在程序中对异常进行处理，否则编译无法通过
    -- throws 关键字声明抛出异常的语法格式：修饰符 返回值类型 方法名([参数1,参数2.....]) throws Exception1[,Exception2.......]

        class ExampleTest{

            public static void main(String[] args){

                int result = divide(4,2);
                System.out.println(result);
            }

            // 使用throws 关键字声明抛出异常
            public static int divide(int x,int y) throws Exception{
                int result = x / y;
                return result;
            }
        }        

        --由于定义divide()方法时声明抛出异常，但调用divide()方法时未做处理(异常捕获或在main方法级别继续throws),因此无法编译        

        class ExampleTest{

            public static void main(String[] args){

                try{
                    int result = divide(4,0);
                    System.out.println(result);

                }catch(Exception e){
                    System.out.println("捕获异常信息为："+e.getMessage());
                    return;                                                    //用于结束当前语句
                }
            }

            // 使用throws 关键字声明抛出异常
            public static int divide(int x,int y) throws Exception{
                int result = x / y;
                return result;
            }
        }        

6.自定义异常
    * 自定义异常类必须继承自Exception或其子类

        //自定义一个异常类继承自 Exception
        public class DivideByMinusException extends Exception {

            public DivideByMinusException() {
                super();                          //调用 Exception 无参的构造方法
            }

            public DivideByMinusException(String message) {
                super(message);                   //调用 Exception 有参的构造方法
            }

        }    

    * 自定义异常类的使用 需要用到关键字 throw，其格式：throw new 异常对象

        public class ExampleTest {

            public static void main(String[] args)  {

                    int result = divide(4,-2);
                    System.out.println(result);

            }

            // 未使用throws 关键字声明抛出异常
            public static int divide(int x,int y)  {
                if(y<0){
                    throw new DivideByMinusException ("被除数是负数");
                }

                int result = x / y;
                return result;
            }
        }     

        --程序在编译时会发生异常。在一个方法内使用throw关键字抛出异常对象时，需要在该方法上使用throws关键字声明抛出异常。并在上一级调用中使用try...catch捕获异常

        public class ExampleTest {
            public static void main(String[] args)  {

                    int result;
                    try {
                        result = divide(4,-2);
                        System.out.println(result);
                    } catch (DivideByMinusException e) {
                        e.printStackTrace();
                    }
            }

            // 使用throws 关键字声明抛出异常
            public static int divide(int x,int y) throws DivideByMinusException {
                if(y<0){
                    throw new DivideByMinusException ("被除数是负数");
                }

                int result = x / y;
                return result;
            }    

        }