初识java——javaSE（8）异常

---

一 异常的概念与体系结构

1.1 什么是异常？

 //异常是指代码中除了语法错误之外，出现的问题导致代码出现不正常行为的状况称之为异常！
 //在java中用异常类来表示异常，因为java的思想是一切皆对象。

比如数组越界，除0，栈溢出：这三种异常：

//数组越界：
        int array[] = {1,2,3,4,5};
        System.out.println(array[10]);

结果：
显示为：ArrayIndexOutOfBoundsException异常（此异常为数组越界异常）
后面是原因： Index 10 out of bounds for length 5

//除0
 System.out.println(10/0);

结果：

显示为： ArithmeticException异常（此异常为算术异常）
后面显示原因： / by zero

1.2 异常的体系结构！

异常种类繁多，为了对不同异常或者错误进行很好的分类管理，Java内部维护了一个异常的体系结构：

大体的体系结构：

具体的：

    其中RunTimeException以及其子类对应的异常，都称为运行时异常。

1.3 编译时异常与运行时异常与Error

编译时异常：

所谓编译时异常是指在编译阶段发生的异常，为此我们必须对可能出现的编译异常进行操作，声明以便抛出或者直接处理。而不是像对运行时异常那样，可以既不声明，也不处理（异常的处理下面会阐述到！）。

异常声明：throws关键字

throws关键字处于方法声明时参数列表之后，当方法中抛出编译时异常，表示该方法并没有处理异常，而是交
给方法的调用者来处理。即此关键字的作用在于提醒方法的调用者处理异常。

举例： 克隆对象:

我们必须进行对可能出现的异常进行声明或者处理！

用throws关键字进行声明：
后面跟上可能出现的异常类：CloneNotSupportedException

运行时异常：

运行时异常是指程序在编译阶段结束后，生成了.class文件，在JVM执行时，出现的异常。
对于可能出现的运行时异常，我们可以不进行声明或者处理。

比如：数组越界

//数组越界：
        int array[] = {1,2,3,4,5};
        System.out.println(array[10]);

什么是Error?

//Error是指java虚拟机无法解决的严重问题，比如：JVM内部错误，资源耗尽 如：栈溢出

举例：

   public static  void func1 (){
        func1();
    }


    public static void main(String[] args) {
       func1();

    }

要注意，红圈的部分其他的是Exception，而此处是Error.

我们是不会用throws声明Error类及其子类的异常的，因为出现了就没救（JVM无法解决），无意义。

二 处理异常

当异常出现时，我们可以选择进行处理，或者什么都不做，交给JVM处理
JVM处理的结果即抛出异常，结束程序！
在Java中，异常处理主要的5个关键字：throw、try、catch、finally、throws。

2.1 异常的抛出：throw(注意与throws有区别！)

异常的抛出用于当程序出现问题时，报告给调用者情况。

举例：

public class Test {

    public static  void func1 (){
        func1();
    }

    public static void main(String[] args) {
        //throw关键字
        int a = 10;
        if(a<20){
            throw new ArithmeticException("胡乱调用了异常类");
        }
        System.out.println(a);
        
    }
    }

我们设定的条件是当a<20时，抛出异常，结果成功。

结果还表明：当抛出异常后，异常后面的代码不被执行。

2.2 异常的捕获（具体处理）：

异常的捕获即异常的具体处理，主要有两种方式：一种是throws声明，这个在前面讲过，不再赘述，另一种则是try—catch捕获

try—catch语句

try—catch语句的语法格式是：

  try{
            //此处放置要执行的代码，可以会出现异常

        }catch (要捕获的异常类型 e){
            // 如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类
          //   时，就会被捕获到 ，对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码

        }[catch(要捕获的异常类型 e){
            //此处放置处理异常的代码
        }
         finally{
            //此处放置的代码，必定会被执行

        }
        ]
        //后续代码:

            //此处的代码，如果没出现异常或者出现了异常并处理了，则此处代码会被执行
            //若出现了异常但没有被处理，则此处的代码不会被执行！
     注： (1) [] 中的内容可加可不加
              (2) try中的代码块不一定会报异常！

其中finally关键字的代码块用于回收系统资源，不管是程序退出，还是抛出异常都需要回收资源
比如在打开文件后，需要关闭文件，即回收系统资源。

举例1 ：有多个异常时，try-catch语句能否同时捕获？

       //try—catch语句
    //    int [] array = {1,2,3,4,5};
        int [] array = null;
        try{
            System.out.println(10/0);
            System.out.println(array.length); //打印数组的长度
        

        }catch (NullPointerException e){//空指针异常
            System.out.println("空指针异常");

        }catch (ArithmeticException e){
           // 异常的处理方式
            System.out.println(e.getMessage());   // 只打印异常信息
            System.out.println(e);               // 打印异常类型：异常信息
            e.printStackTrace();                    // 打印信息最全面
         


        }finally {
            System.out.println("finally中执行的代码");
        }
        System.out.println("后续代码块");

 结果表明：我们通过try—catch语句只能捕获一个异常
 因为：  try块内抛出异常位置之后的代码将不会被执行

举例2：
如果多个异常的处理方式是相同的，则简写成：

   int[] array = null;
        try {
            System.out.println(10 / 0);
            System.out.println(array.length); //打印数组的长度


        } catch (NullPointerException | ArithmeticException e) {//空指针异常
            System.out.println(e.getMessage()); //只打印异常信息——/by zero
            System.out.println(e);               // 打印异常类型：异常信息
            e.printStackTrace();                       //打印信息最全面 ——打印异常类型，打印异常信息，还打印异常所在的代码！



        } finally {
            System.out.println("finally中执行的代码");
        }
        System.out.println("后续代码块");
    }

举例三：

 如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误：

2.3 关于异常的处理方式：

2.4 异常处理流程总结：

1. 先执行try块中的代码
2. 如果发现异常，则在catch中判断是否与catch的异常类型相同，如果相同则执行catch中的代码，如果不同则将异常向上传递给上一层调用者。
3. 无论异常是否被处理，finally中的代码都会被执行（在该方法结束之前执行），但是如果异常并没有被处理，则后续代码不会被执行。
4. 如果上层调用者依然无法处理异常，则继续传递给上层，直到传递到main方法，main方法也无法处理，则交给JVM,最终异常结束程序。

  public static void func() {
        int[] arr = {1, 2, 3};
        System.out.println(arr[100]);

    }
    public static void main(String[] args) {
            func();
            System.out.println("after try catch");
        }

结果表明：显示了异常的调用栈，且最终after try catch语句没有被执行！

三 自定义异常类

java中提供的异常类不能代表所有我们在日常开发中遇到的问题，所以我们需要自己定义异常类

举例：

package demo1;

public class PasswordException extends Exception{
    public PasswordException(String message){
        super(message);

    }

}

package demo1;

public class UserNameException extends Exception{
    public UserNameException(String message){
        super(message);
    }
}

public class Test {
    private String userName = "admin";
    private String password = "123456";

    public  void loginInfo(String userName, String password)
                                 throws UserNameException,PasswordException{
       if (! this.userName.equals(userName)) {
             throw new UserNameException("用户名错误！");
    }
        if (! this.password.equals(password)) {
             throw new PasswordException("用户名错误！");
    }
           System.out.println("登陆成功");
  }

    public static void main(String[] args) {
          try {
           new Test(). loginInfo("admin", "123456");
               } catch (UserNameException e) {
                e.printStackTrace();
               } catch (PasswordException e) {
               e.printStackTrace();
  }
  }

注意事项
自定义异常通常会继承自 Exception 或者 RuntimeException
继承自 Exception 的异常默认是受查异常
继承自 RuntimeException 的异常默认是非受查异常.