JavaSE认识异常及异常的处理

        我们在日常编程中经常会爆出一些异常的问题，比如数组越界、访问null对象，这些都会爆出一些异常，这些异常我们今天就来归类一下。

1.防御式编程

LBYL: Look Before You Leap. 在操作之前就做充分的检查。

EAFP: It's Easier to Ask Forgiveness than Permission. "事后获取原谅比事前获取许可更容易". 也就是先操作, 遇到问题再处理。

而异常的核心思想就是第二种EAPP，即先做，再处理问题。

2异常的基本用法

2.1捕获异常

try{
    有可能出现异常的语句 ;
}[catch (异常类型 异常对象) {
} ... ]
[finally {
    异常的出口
}]

try 代码块中放的是可能出现异常的代码.

catch 代码块中放的是出现异常后的处理行为.

finally 代码块中的代码用于处理善后工作, 会在最后执行.

其中 catch 和 finally 都可以根据情况选择加或者不加

代码示例1：不处理异常时

public class TestDemo3 {
    public static void main(String[] args) {
        int[] array = {1,2,3};
        System.out.println("bit");
        System.out.println(array[4]);
        System.out.println("hello");
    }
}

遇到异常并没有处理，因此程序会直接结束，后面的hello并不会打印。其中的code 1表示程序非正常结束。

代码2：使用try catch的处理过程

public class TestDemo3 {
    public static void main(String[] args) {
        int[] array = {1,2,3};
       try {
           System.out.println("bit");
           System.out.println(array[4]);
           System.out.println("hello");
       }catch(ArrayIndexOutOfBoundsException e){
           e.printStackTrace();//打印异常的调用栈
        }
        System.out.println("xixi");
    }
}

       方法之间是存在相互调用关系的, 这种调用关系我们可以用 "调用栈" 来描述. 在 JVM 中有一块内存空间称为 "虚拟机栈" 专门存储方法之间的调用关系. 当代码中出现异常的时候, 我们就可以使用 e.printStackTrace(); 的方式查看出现异常代码的调用栈。

 当try中的代码出现异常时，就会交给catch中的代码来捕捉异常，然后打印异常。最后再继续往下执行

代码3：catch可以有多个

public static void main(String[] args) {
        int[] array = {1,2,3};
        try {
            array = null;
            System.out.println(array[2]);
            System.out.println("haha!");
        }catch (ArrayIndexOutOfBoundsException e) {
            e.printStackTrace();
            System.out.println("我捕捉到了一个数组越界异常，这里开始处理异常了");
        }catch (NullPointerException e) {
            e.printStackTrace();
            System.out.println("捕捉到了空指针异常");
        }
        System.out.println("哈喽！！！");
    }

 因为try里面爆的是空指针异常，第一个catch里面捕捉的是数组越界异常，因此等待第二个catch来捕捉空指针异常。如果catch始终没有捕获这个异常，那么程序将会交给JVM来执行，则程序会立刻终止。code 0表示程序正常结束

代码3也可以简化：

public static void main(String[] args) {
        int[] array = {1,2,3};
        try {
            array = null;
            System.out.println(array[2]);
            System.out.println("haha!");
        }catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
            e.printStackTrace();
            System.out.println("我捕捉到了一个数组越界/空指针异常，这里开始处理异常了");
        }finally{

         System.out.println("哈喽！！！");//不管try和catch是否执行，finally一定会执行
    }
}

代码4：如果本方法中没有合适的处理异常的方式, 就会沿着调用栈向上传递

public static void main(String[] args) {
   try {
    func();
   } catch (ArrayIndexOutOfBoundsException e) {
    e.printStackTrace();
   }
     System.out.println("after try catch");
   }
    public static void func() {
    int[] arr = {1, 2, 3};
    System.out.println(arr[100]);
  }



 //结果：java.lang.ArrayIndexOutOfBoundsException: 100
        at demo02.Test.func(Test.java:18)
        at demo02.Test.main(Test.java:9)
        after try catch

代码5：避免在finally中写return

public class TestDemo{
public static int func3() {
        int a = 10;
        try {
            //System.out.println(10/0);
            return a;
        }catch (ArithmeticException e) {
            e.printStackTrace();
        }finally {
            return 20;
        }
    }

    public static void main13(String[] args) {
        System.out.println(func3());
    }
}

此时会打印20，因此要避免在finally使用return;

异常处理的整个流程：

程序先执行 try 中的代码

如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.

如果找到匹配的异常类型, 就会执行 catch 中的代码

如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.

无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).

如果上层调用者也没有处理的了异常, 就继续向上传递.

一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止

2.2抛出异常

 3.java异常体系

顶层类 Throwable 派生出两个重要的子类, Error 和 Exception

其中 Error 指的是 Java 运行时内部错误和资源耗尽错误. 应用程序不抛出此类异常. 这种内部错误一旦出现，除了告知用户并使程序终止之外, 再无能无力. 这种情况很少出现.

Exception 是我们程序猿所使用的异常类的父类.其中 Exception 有一个子类称为RuntimeException , 这里面又派生出很多我们常见的异常类NullPointerException , IndexOutOfBoundsException等
 其中将派生于 Error 类或 RuntimeException 类的所有异常称为 非受查异常, 所有的其他异常称为 受查异常，如果一段代码出现受查异常，就必须进行显示处理

 此时我们点击Alt+回车即添加一个异常到方法的声明

 

此时异常会向上传递，即到main方法区，如果都不能处理异常，则此时会交给JVM来处理。

 

 第二种方式则使用try catch去包裹

 4.自定义异常类

实现一个用户登录功能

class NameException extends RuntimeException{
    public NameException(String message) {
        super(message);
    }
}
class PasswordException extends RuntimeException{
    public PasswordException(String message) {
        super(message);
    }
}
public class TestDemo {

    private static final String name = "bit";
    private static final String password = "123";

    public static void login(String name,String password) throws  NameException,PasswordException{
        if(!TestDemo.name.equals(name)) {
            throw new NameException("用户名错误");
        }
        if(!TestDemo.password.equals(password)) {
            throw new PasswordException("密码错误！");
        }
    }
    public static void main(String[] args) {
        try {
            login("bit","1234");
        }catch (NameException e) {
            System.out.println("用户名错误了！");
        }catch (PasswordException e) {
            e.printStackTrace();
            System.out.println("密码错误了！");
        }finally {
            System.out.println("finally执行了！");
        }
    }

注意：自定义异常通常会继承自 Exception 或者 RuntimeException
         

          继承自 Exception 的异常默认是受查异常

         

          继承自 RuntimeException 的异常默认是非受查异常.

习题一：使用while循环建立类似“恢复模型”的异常处理行为，他将不断重复，直到异常不再抛出

public static void main(String[] args) {
        int i = 0;
        while (i < 10) {
            try {
                if( i < 10) {
                    throw new Exception();
                }
            }catch (Exception e) {
                e.printStackTrace();
                System.out.println("尝试连接网络第"+i+"次.........");
                i++;
            }
        }
        System.out.println("终于有网了,程序继续执行！！！！！");
    }