异常关键字
try	尝试，抓捕异常
eatch	获取异常
finally	不管是抓捕到异常，finally都会执行（把一些重要的代码放在finally下，比如资源释放）
throws	抛出异常，让调用者自己解决或再次抛出异常
throw	异常对象

try语法块：

如果没有抓捕到异常，则程序正常运行，不会进入到异常块中（catch中）！！！，继续向下进行

如果抓捕到异常，会从出现异常的行立即进入到异常块中，try语法不会向下进行，继续向下进行

抓捕异常：

尝试着抓捕对应的异常，针对具体问题，具体解决。

例：（异常捕获提高代码的稳定性）



public class Test {
    public static void main(String[] args) {
        int num=division(2,0);
        System.out.println(num);
    }
    public static int division(int x,int y){
        int num=0;
        
        try {
            //try抓捕异常
            //当感觉当前代码会中出现问题
            num=x/y;
        }catch (ArithmeticException e){
            //catch 获取异常
            //当出现“ArithmeticException”这个异常时会进入到下面代码当中
            System.out.println("除数不能为0。");
        }
       
        return num;
    }
}

多行异常的处理：

try {
            //try抓捕异常
            //当感觉当前代码会中出现问题
            //代码块
 }catch (异常名称1 异常别名){
            //catch 获取异常
            //当出现“异常名称1”这个异常时会进入到下面代码当中
          
}catch (异常名称2 异常别名){

            //当出现“异常名称2”这个异常时会进入到下面代码当中
}


//方法二（多态特性，不推荐使用）
try {
            //try抓捕异常
            //当感觉当前代码会中出现问题
            //代码块
 }catch (Exception 异常别名){
            //catch 获取异常
            //当出现异常时会进入到下面代码当中，在Java中所以异常都是Exception的子类
}

查看出现的异常情况

 
异常别名.printStackTrace();

//输出异常信息

异常别名.getMessage()

//在控制台上打印输出异常错误情况（调用栈的情况）

自定义异常和抛出异常

Java中异常继承关系

Throwable下有 Error （错误）与Exception（异常：分类：RuntimeException "运行时异常" ，非运行时异常）

异常抛出：

向上抛出异常（谁调用出现的异常，谁解决，查找继承对应的解决，都没有就结束程序）

自定义异常：

在Java中，只要继承了Exception类，该类就是一个异常类。


public class MYException extends Exception{
    //继承Exception就是一个异常类
    //可以重写父类Exception的全部方法或者需要的代码
    public MYException(){
        super();
    }
    
}

建议继承RuntimeException异常类，好处就是不用抛出异常



public class MYException extends RuntimeException{
    //继承RuntimeException就是一个异常类
    //可以不用抛出异常
}

抛出异常（第二种解决异常的方法）：

public class Test {
    public static void main(String[] args)  {
        int num = 0;
        try {
            //解决抛出的异常
            num = add(-1,0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(num);
    }
    public static int add(int x,int y)throws NullPointerException,Exception{
        
        //throws抛出异常，可以一个或者多个，让调用者解决
        if(x<0 ||y<0){
            throw new RuntimeException("二个数必须是正数");
        }
        int num=x+y;
        return num;
    }
}

RuntimeException （运行时异常）：只有在运行时，才能知道是否会有异常，并且异常可以不用抛出

非运行时异常：在javac（编译时，就会报错），必须处理（进行处理或者抛出）

finally关键字

常见的写法结构，（利用finally的特性，finally中尽量不要使用return）

try {
      
  }finally {
      //重要的必须要执行，如资源释放，垃圾回收      
 }

想一想在finally前return会发生什么？（面试题

）

疑问：为什么会有二个return，不会报错？

原因：在try中的return可能会因为异常的影响，不被执行，所以需要外面一个return进行返回值。

当没有异常时，就不会进行return+2.


public class Test {
    public static void main(String[] args)  {
       int i=tst();
       System.out.println(i);
    }
    public static int tst(){
        int num=10;
        try {
            System.out.println(num);
            return num+1;
            //在函数当中，如果在finally前使用return关键字，则在return完成前，先执行finally，在return
        }catch (Exception e){
            System.out.println("haha");
        }finally {
            System.out.println("必须要执行");
        }
        return num+2;
    }
}

在函数当中，如果在finally前使用return关键字，则在return完成前，先执行finally，在return

想一想nums是多少？


public class Test {
    public static void main(String[] args)  {
       int i=tst();
       System.out.println(i);
    }
    public static int tst(){
        int num=10;
        try {
            System.out.println(num);
            return num;
        }catch (Exception e){
            num+=10;
            System.out.println("haha");
        }finally {
            num++;
            System.out.println("必须要执行");
        }
        return num;
    }
}

原因：虽然return进行了让步，但return的值已经固定了。（如果try当中的return没有成功，num的值才是11，如果捕获了异常了，则先num+10再+1，num值为21）

以上是关于慢慢学习，然后惊呆所有人（八，异常）的主要内容，如果未能解决你的问题，请参考以下文章

慢慢学习，然后惊呆所有人（六，面向对象，二，构造函数）

慢慢学习，然后惊呆所有人（数组）

慢慢学习，然后惊呆所有人（七 IDEA的介绍与安装（Java集成开发工具，超详细！）

慢慢学习，然后惊呆所有人（Arrays类）

慢慢学习，然后惊呆所有人（六面向对象）

慢慢学习，然后惊呆所有人（五函数的重载）