JavaSE----异常及异常处理

Java 异常概念

    前言： 在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善 尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠 代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等的诸多问题。
    异常： 在Java语言中，将程序执行中发生的不正常情况称为“异常”。Java程序在执行过程中所发生的异常(运行时一切不正常情况)事件可分为两类：广义上的异常（Error）和狭义上的异常（Exception）。
    Error： Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理（基本上都是外界因素的影响）。
    Exception： 其它因编程错误或偶然的外在因素导致的一般性问题，可 以使用针对性的代码进行处理
比如说：

public class ExcptionTest { 
  public void test(){ 
     System.out.println( "====运行前====" ); 
     int a=10/0; 
     System.out.println( "====运行后====" ); 
   }
 public static void main(String[] args) { 
     ExcptionTest et= new ExcptionTest(); 
     et.test(); 
   } 
}

异常的结果：

异常的体系

    异常分为运行期异常和编译期异常两种

    运行期异常：程序运行时抛除的异常，所有RuntimeException的子类都 是运行期异常，比如数学异常 、空指针异常 、 数组下标越界、等等…
    编译器异常：编译期异常(Checked Exception)：除去运行期的异常都是编译期异常， 也称为检测异常（也就是编译器在你敲完一段代码后打红线的部分）

    Exception异常类、Error类都是直接继承Throwable父类

    我们现在常见的异常就是有：ArrayIndexOutOfBoundsException 数组索引异常、StringIndexOutOfBoundsException 字符串索引异常、NumberFormatException 数字化格式异常、NullPointerException 空指针异常、ClassCastException 类的类型转换异常、ArithmeticException、除数为0异常

public static void main(String[] args) {
        /**
         * ArrayIndexOutOfBoundsException 索引异常
         * 抛出以表示使用非法索引访问数组。 索引为负数或大于或等于数组的大小。
         * Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
         * at Demo1.Demo1D1.main(Demo1D1.java:15)
         */
        //int []arr1 = new int[]{1,2,3,4,5};
        //System.out.println(arr1[5]);

        /**
         * StringIndexOutOfBoundsException  索引异常
         * 抛出String方法来指示索引为负或大于字符串的大小。 对于某些方法（如charAt方法），当索引等于字符串的大小时，也会抛出此异常。
         * Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 3
         * 	at java.lang.String.charAt(String.java:658)
         * 	at Demo1.Demo1D1.main(Demo1D1.java:23)
         */
        //String str1 = "123";
        //System.out.println(str1.charAt(3));

        /**
         * NumberFormatException数字化格式异常
         * 抛出以表示应用程序已尝试将字符串转换为其中一个数字类型，但该字符串不具有相应的格式。
         *Exception in thread "main" java.lang.NumberFormatException: For input string: "a"
         * 	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
         * 	at java.lang.Integer.parseInt(Integer.java:580)
         * 	at java.lang.Integer.<init>(Integer.java:867)
         * 	at Demo1.Demo1D1.main(Demo1D1.java:36)
         */
        //String str = "a";
        //Integer integer = new Integer(str);

        /**
         * NullPointerException空指针异常
         * 当应用程序尝试在需要对象的情况下使用null时抛出。 这些包括：
         * 调用一个null对象的实例方法。
         * 访问或修改null对象的字段。
         * 取null的长度，好像是一个数组。
         * 访问或修改的时隙null就好像它是一个数组。
         * 投掷null好像是一个Throwable价值。
         *
         *Exception in thread "main" java.lang.NullPointerException
         * 	at Demo1.Demo1D1.main(Demo1D1.java:48)
         */
        //String str = null;
        //System.out.println(str.length());

        /**
         *ClassCastException 类的类型转换异常
         * 抛出表示代码尝试将对象转换为不属于实例的子类
         * Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
         * 	at Demo1.Demo1D1.main(Demo1D1.java:63)
         */
        //Object obj = new Integer(0);
        //System.out.println((String)obj);

        /**
         * 广义异常：
         */
        //System.out.println(sum(5));
}

异常处理

    Java编程语言使用异常处理机制为程序提供了错误处理的能力。Java的异常处理是通过5个关键字来实现的：try、catch、 finally、 throw、throws

public static void main(String[] args) {
        try{
        /*
        检测不安全的代码块（发现异常） try块中任何一条语句发生了异常，
        下面的代码将不会被执行，程序将 跳转到异常处理代码块中，
        即catch块。因此，不要随意将不相关的代 码放到try块中，
        因为随时可能会中断执行。
        */
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入两个数字");
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            System.out.println(a/b);
        }catch (ArithmeticException e){
        /*
        把抓到的类型匹配的异常捕获，
        保证程序能继续运行下去 catch语句必须紧跟着try语句之后，
        称为捕获异常，也就是异常处理函数， 
        一个try后面可以写多个catch，
        分别捕获不同类型的异常，要从子类往父类 的顺序写，否则有编译错误
        */
            e.printStackTrace();
            /**
             * 拿出异常
             * 
             */
            System.out.println("0不能作为除数");
        }
    }

       getMessage() 获取异常信息，返回字符串
       printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的 位置。返回值void
       Finally关键字：
      与final很像，但是完全不是一个意思。
final是在面向对象语法时出现的关键字，其用于修饰属性、方法和类

• 被final修饰的成员对象必须在定义时赋初值，或者用构造方法为其赋值，其值后期不能改变
• 被final修饰的静态变量必须在定义的时候就就赋初值，且不能改变
• 被final修饰的成员方法不能被重写
• 被final修饰的类不能被继承

finally是在异常处理时会用到的关键字。

• finally语句往往写在try后、catch后。
• 先执行try语句或者catch的异常
• 但是执行末尾时总会去执行finally语句
• finally语句不管在什么条件下都会执行完尽管执行后不再执行try或者catch里面剩余的语句

请欣赏下面一段代码（可以直接放在编译器上运行）

/**
 * finally的基本语法
 * try{
 *     可能会发生异常的代码
 *   }catch(异常类型 引用名){
 *   异常处理代码
 *   }finally{
 *   必须执行代码
 *   }
 *
 *   finally该内ly容总是会执行的，只能有一个finally语句
 */
public class DemoFinally {
    public static void main(String[] args) {
        try{
            int a = 10;
            int b = 0;
            System.out.println(a/b);
            System.out.println("aaaaa");
        }catch(ArithmeticException e){
            e.printStackTrace();
            System.out.println("出错啦");
        }finally{//不管程序有没有异常，都会执行finally的语句
            System.out.println("bbbbbb");
        }
        //System.out.println(m1(10,0));
        /**
         * 如果try体系中没有catch语句来捕获异常，但是有finally语句
         * 如果出现异常，那么程序会在报错前执行完finally的语句，最后停止
         */
        /*try{
            int m = 5;
            int n = 0;
            System.out.println(m/n);
        }finally {
            System.out.println("aaaaaa");
        }
        System.out.println("aaaa");*/
    }
    public static int m1(int a,int b){
        try{
            int c=a/b;
            return c;
        }catch (ArithmeticException e){
            e.printStackTrace();
            System.out.println("出错啦");
            return -1;
        }finally{//在return之前，总会执行finally语句
            System.out.println("finally");
            //既是finally也是一段return，程序也是会执行，然后结束；
            return 0;
        }
    }
}

throws 和 throw

       Throws：定义一个方法的时候可以使用throws关键字声明 （必须放在方法名的括号后） 表示此方法 不处理异常，而交给方法调用处进行处理。 例如: public void test throws 异常1，异常2，异常3{ }。但是这种用法一般只会出现在基层的方法中，而顶层方法就不能再抛，在抛就抛给虚拟机，虚拟机哪会处理异常，他就直接给你报错。而且任何方法都可以使用throws关键字声明异常类型，包括抽象方法。
       子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常(针对编 译期异常)。 使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要 么继续使用throws声明。顶层只能用try-catch
       Throw：throw关键字用于显式抛出异常,抛出的时候是抛出的是一个异常类的实 例化对象. 在异常处理中，try语句要捕获的是一个异常对象，那么此异常对象也 可以自己抛出。throw往往写在语句中，而非方法名后面。自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的 子类

 public static void main(String[] args) {
         try{
             m1();
         }catch (NullPointerException e){
             e.printStackTrace();
         }
         System.out.println("aaa");

    }
    public static void m1(){
        System.out.println(m2(null));

    }
    public static int m2(String a){
        if(a==null){//如果报错，则直接抛出一个异常类的对象
            throw new NullPointerException("空指针异常");
        }
        return a.length();
    }

异常代码：

  Exception in thread "main" java.lang.NullPointerException: 空指针异常
  at Demo1.异常处理.DemoThrow.m2(DemoThrow.java:17)
  at Demo1.异常处理.DemoThrow.m1(DemoThrow.java:12)
  at Demo1.异常处理.DemoThrow.main(DemoThrow.java:9)

       Throw和Throws的区别：

• throw用于 方法体中，用来抛出一个实际的异常对象，使用throw后， 要么使用try catch捕获异常，要么使用throws声明异常

• throws用于 方法声明处，用来声明该方法可能发生的异常类型，可以是 多个异常类型，用来强制调用该方法时处理这些异常

• Throw写在方法体时，明确的告诉你这会抛出异常

• 它抛出的异常基本上由自己内部的方法快来处理掉，有Throw必有Throws

• Throws写在方法名括号的后面用来显示异常

• Throws会表示抛出异常的类型，往往由上一级（调用次方法的）来try catch解决异常而自身不解决

自定义异常

    自定义异常就是自己定义的异常类，也就是API中的标准异常类的直接或间接的子类。自定义异常类中往往不写其他方法，只重载需要使用的构造方法。继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或 throws抛出

public class DemoCreatThrow extends Exception{
    public DemoCreatThrow(){
        super();
    }
    public DemoCreatThrow(String a){
        super(a);
    }
}

    作用：用自定义异常标记业务逻辑的异常，避免与标准异常混淆
代码演示：

class DemoThrow1{
    public static void main(String[] args) {
        try{
            System.out.println(m1(10,0));
        } catch (DemoCreatThrow e) {
            e.printStackTrace();
        }
    }
    public static int m1(int a,int b) throws DemoCreatThrow {
        if(b==0){
            throw new DemoCreatThrow("自定义的异常");
        }
        return a/b;
    }
}