Java-异常

异常：

/*
* 在程序运行过程中，如果处理异常的部分包含finally的处理，无论代码是否发生异常，finally中的代码总会执行
* finally包含哪些处理逻辑？
* */
public class FinallyDemo {
    public static void main(String[] args) {
        try {
            System.out.println(10/0);
//出现异常后不向下继续执行
//            System.out.println("try中的语句");
            return;
        }catch (ArithmeticException e){
            e.printStackTrace();
            //不执行finally语句块的方式
            System.exit(1);
        }finally {
            System.out.println("看我什么时候执行？");
        }
        System.out.println("这是try...catch...finally  ..语句块后面的语句");
    }
}

在程序运行过程中，出现的不正常情况叫做异常
注意：
1、相同的代码在运行的时候，根据输入的参数或者操作不同，有可能会发生异常，有可能不会发生异常
应该在写代码的过程中尽可能的保证代码的正确性，不要到处都是bug
2、如果要解决代码中出现的异常，需要添加非常复杂的代码逻辑来进行判断，会使代码变得非常臃肿，不利于维护，可读性比较差
因此，推荐大家使用异常机制来处理程序运行过程中出现的问题
3、程序在运行过程中如果出现了问题，会导致后面的代码无法正常执行，而使用异常机制之后，可以对异常情况进行处理
同时后续的代码会继续执行，不会中断整个程序
4、在异常的处理过程中，不要只是简单的输出错误，要尽可能的将详细的异常信息进行输出
e.prinrStackTrace();打印异常的堆栈信息，可以从异常信息的最后一行开始追踪，寻找自己编写的java类

异常处理的方式：
1、捕获异常
try{可能出现异常的代码逻辑}cath(Exception e)(异常处理逻辑)
try{可能出现异常的代码逻辑}cath(具体的异常Exception e)(异常处理逻辑)cath(具体的异常)：
可以针对每一种具体的异常做相应的更丰富的处理
注意：当使用多重的catch的时候一定要注意相关异常的顺序，将子类放在最前面的catch，父类放在后面的catch
  执行的过程中可能存在的情况：
1、正常执行，只执行try中的代码
2、遇到异常情况，会处理try中异常代码之前的逻辑，后面的逻辑不会执行，最后会执行catch中的代码
3、使用多重catch的时候，会遇到异常子类不匹配的情况，此时依然会报错，因此建议在catch的最后将所有的异常的父类写上
inputMismatchException
ArithmeticException

在程序运行过程中，如果处理异常的部分包含finally的处理，那么无论代码是否发生异常，finally中的代码总会执行

public class TestException {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println("请输入被除数");
             int num1 = in.nextInt();
             System.out.println("亲输入除数");
             int num2 = in.nextInt();
             System.out.println(String.format("%d/%d=%d", num1, num2, num1 / num2));
             System.out.println("欢迎使用本程序");
    }//输入0、 abc（字母）都会出现异常
}


public class TestException {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println("请输入被除数");
        try {
            int num1 = in.nextInt();
            System.out.println("请输入除数");
            int num2 = in.nextInt();
            System.out.println(String.format("%d/%d=%d", num1, num2, num1 / num2));
        }catch (ArithmeticException e){  
               //对数字异常进行处理
            System.out.println("除数不能为0");
            e.printStackTrace();
    //堆栈信息
        }catchi (InputMismatchException e){
      //字母异常
        System.out.println("输入参数不匹配");
        e.printStackTrace();
       }catch( Exception e){//父类写在后面，子类写在前面
        e.printStackTrace();
}
        System.out.println("欢迎使用本程序");
        System.err.println("这是红色字体")
    }
}//Throwable  异常

public class Trytest {
    public static void main(String[] args) {
//        System.out.println(test().num);
    }

//    第一种情况
//    private static int test(){
//        int num=10;
//        try {
//            System.out.println("try");
//            return num +=80;
//        }catch (Exception e){
//            System.out.println("error");
//        }finally {
//            if(num>20){
//                System.out.println("num>20:"+num);
//            }
//            System.out.println("finally");
//        }
//        return num;
//    }


//    第二种情况
//    private static int test(){
//        int num=10;
//        try{
//            System.out.println("try");
//            return num+=80;
//        }catch(Exception e){
//            System.out.println("num>20:"+num);
//        }
//        System.out.println("finally");
//        num=100;
//        return num;
//    }

//    第三种情况
//    private static int test(){
//        int num=10;
//        try{
//            System.out.println("try");
//            return num;
//        }catch(Exception e){
//            System.out.println("error");
//        }finally{
//            if(num>20){
//                System.out.println("num>20:"+num);
//            }
//            System.out.println("finally");
//            num=100;
//        }
//        return num;
//    }

    //第四种情况
//    private static Num test() {
//        Num number = new Num();
//        try {
//            System.out.println("try");
//            return number;
//        } catch (Exception e) {
//            System.out.println("error");
//        } finally {
//            if (number.num > 20) {
//                System.out.println("num.num>20:" + number.num);
//            }
//            System.out.println("finally");
//            number.num = 100;
//        }
//        return number;
//    }
//}
//class Num{
//    public int num=10;
}

/*
* 从结果中可以看出，同样是在finally中改变了返回值num值，在情况三中，并没有被try中的return返回（test（）方法得到的不是100），但在这里却被try中的return语句返回了。
* 总结：
* try语句再返回钱，将其他所有的操作执行完，保留好要返回的值，而后转入执行finally中的语句，而后分为以下三种情况：
* 情况一：如果finally中没有return语句，则会将try中的return语句“覆盖”掉，直接执行finally中的return语句，得到返回值，这样便无法得到try之前保留好的返回值。
* 情况二：如果finally中没有return语句，也没有改变要返回值，则执行完finally中的语句后，会接着执行try中的return语句，返回之前保留的值
* 情况三：如果finally中没有return语句，但是改变了要返回的值，这里有点类似与引用传递和值传递的区别，分以下两种情况：
*（1）如果return的数据是基本数据类型或文本字符串，则在finally中对该基本数据的改变不起作用，try中的return语句return语句依然会返回进入finally块之前保留的值。
*（2）如果return的数据是引用数据类型，而在finally中对该引用数据类型的属性值得改变起作用，try中的return语句返回的就是在finally中改变后的该属性的值
* */

4种情况