Java-异常

• 异常分为Checked异常和运行时异常
  –Checked异常必须捕获或者声明抛出
  –运行时异常不要求必须捕获或者声明抛出
• try-catch-finally中存在return语句的执行顺序
  1、不管是否出现异常，finally块中代码都会执行；
  2、当try和catch中有return时，finally仍然会执行；
  3、finally是在return后面的表达式运算之后执行的，此时并没有返回运算之后的值，而是把值保存起来，不管finally对该值做任何的改变，返回的值都不会改变，依然返回保存起来的值。也就是说方法的返回值是在finally运算之前就确定了的；
  4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。
  含有return语句的执行情况资料
• finally块中语句不执行的情况
  1.在finally语句块中发生异常。
  2.在全面的代码中使用了System.exit()退出程序。
  3.程序所在的线程死亡。
  4.关闭CPU。
• throw和throws关键字的区别
  throws是声明异常
  throw是抛出异常
  1.throws出现在方法函数头；throw出现在函数体。
  2.throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。
  3.两者都只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

常见的异常类型

try…catch

package com.petrel;

import java.io.File;
import java.util.InputMismatchException;
import java.util.Scanner;

/**
 * @author Petrel
 * @data 2020/6/20 10:47
 */

/**
 * 异常:
 *       在程序运行过程中，出现的不正常情况叫做异常
 *
 *       注意：
 *           1、相同的代码在运行的时候，根据输入的参数或者操作的不同，有可能会发生异常，有可能不会发生异常
 *               应该在写代码的过程中尽可能的保证代码的正确性，不要到处都bug
 *           2、如果要解决代码中出现的异常，需要添加非常复杂的代码逻辑来进行判断，会使代码变得非常臃肿，不利于维护，可读性比较差
 *               因此，推荐大家使用异常机制来处理程序运行过程中出现的问题（太多if else了）
 *           3、程序在运行过程中如果出现了问题，会导致后面的代码无法正常执行，而使用异常机制之后，可以对异常情况进行处理
 *              同时后续的代码会继续执行，不会中断整个程序（使用try catch可以继续运行后面的）
 *           4、在异常的处理过程中，不要只是简单的输出错误，要尽可能的讲详细的异常信息进行输出（输出异常）
 *                  e.printStackTrace():打印异常的堆栈信息，可以从异常信息的最后一行开始追踪，寻找自己编写的java类
 *                  （也可以使用e.getMessage()，但是还是e.printStackTrace():这个好用）
 *
 *      异常处理的方式：
 *          1、捕获异常
 *              try{代码逻辑}catch(具体的异常Exception e){异常处理逻辑}catch(具体的异常)：
 *                    可以针对每一种具体的异常做相应的更丰富的处理
 *                      注意：当使用多重的catch的时候一定要注意相关异常的顺序，将子类放在最前面的catch，父类放在后面的catch   （Exception e这个是父类）
 *              try{代码逻辑}catch(Exception e){异常处理逻辑}
 *              执行过程中可能存在的情况：              （异常具体点，但如果异常不对，就报错）
 *                  1、正常执行，只执行try中的代码
 *                  2、遇到异常情况，会处理try中异常代码之前的逻辑，后面的逻辑不会执行，最后会执行catch中的代码
 *                  3、使用多重catch的时候，会遇到异常子类不匹配的情况，此时依然会报错，因此建议在catch的最后将所有的异常的父类写上
 *InputMismatchException
 * ArithmeticException
 *
 *      异常的分类：
 *                  Throwable是异常的父类
 *                  Throwable包括Error和Exception
 *                      Error是系统层面的错误，代码无法解决
 *                      Exception包括idea编译时的Checked异常和运行异常
 */

public class TestException {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        try {
            System.out.print("请输入被除数:");
            int num1 = in.nextInt();
            System.out.print("请输入除数:");
            int num2 = in.nextInt();
            System.out.println(String.format("%d / %d = %d",
                    num1, num2, num1 / num2));
            System.out.println("前面没有出现异常");
        /*}catch(Exception e){
//            System.out.println("出现异常");
            e.printStackTrace();
//            System.out.println("--------");
            System.out.println(e.getMessage());
        }*/
        }catch(ArithmeticException e){
            System.out.println("数学异常，除数不能是0");
            e.printStackTrace();
        }catch (InputMismatchException e){
            System.out.println("输入的参数值类型不匹配");
            e.printStackTrace();
        }catch (NullPointerException e){
            System.out.println("空指针异常");
            e.printStackTrace();
        }
        System.out.println("感谢使用本程序！");

    }
}

运行结果：

finally

package com.petrel;

/**
 * @author Petrel
 * @data 2020/6/20 15:26
 */

/**
 * （finall最后会运行）
 * 在程序运行过程中，如果处理异常的部分包含finally的处理，那么无论代码是否发生异常，finally中的代码总会执行
 *   finally包含哪些处理逻辑？
 *       1、IO流的关闭操作一般设置在finally中
 *       2、数据库的连接关闭操作设置在finally中
 *
 */

public class FinallyDemo {
    public static void main(String[] args) {
        try {
            System.out.println(1/10);
            return;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            System.out.println("finally处理块");
        }
    }
}

运行结果：

throw、throws

package com.petrel;

/**
 * @author: 马士兵教育
 * @create: 2019-09-07 15:28
 */
/*
throws:声明异常
* 在异常情况出现的时候，可以使用try...catch...finally的方式对异常进行处理，除此之外，可以将异常向外跑出，由外部的进行处理
*   1、在方法调用过程中，可能存在N多个方法之间的调用，此时假如每个方法中都包含了异常情况
*       那么就需要在每个方法中都进行try...catch，另外一种比较简单的方式，就是在方法的最外层调用处理一次即可
*       使用throws的方法，对所有执行过程中的所有方法出现的异常进行统一集中处理
*   2、如何判断是使用throws还是使用try...catch..
*       最稳妥的方式是在每个方法中都进行异常的处理
*       偷懒的方式是判断在整个调用的过程中，外层的调用方法是否有对异常的处理，如果有，直接使用throws,如果没有
*           那么就要使用try...catch...

* throw：抛出异常
*
* */
public class Excepton2 {
    public static void main(String[] args) {
        try {
            show();
        } catch (GenderException e) {
            e.printStackTrace();
        }

//        new FileInputStream(new File(""));  编译时的异常
        System.out.println("hehe");
    }

    public static void show() throws GenderException{
        String gender = "1234";
        if (gender.equals("man")){
            System.out.println("man");
        }else if(gender.equals("woman")){
            System.out.println("woman");
        }else{
//            throw new Exception("性别出现错误");
            throw new GenderException("gender is wrong");
        }
    }


    public static void test1() throws Exception{
        System.out.println(1/0);
    }
    public static void test2() throws Exception {
        test1();
        System.out.println(100/0);
    }
    public static void test3() throws Exception{
        test2();
    }
    public static void test4() throws Exception{
        test3();
    }
}

运行结果：

自定义异常

package com.petrel;

/**
 * @author Petrel
 * @data 2020/6/22 8:49
 */

/**
 * 自定义异常：
 *       在java的api中提供了非常丰富的异常类，但是在某些情况下不太满足我们的需求，此时需要自定义异常
 *       步骤：
 *           1、继承Exception类
 *           2、自定义实现构造方法
 *           3、需要使用的时候，使用throw new 自定义异常的名称；（见Excepton2中的例子）
 *       什么时候需要自定义异常？
 *           一般情况下不需要
 *           但是在公司要求明确，或者要求异常格式规范统一的时候是必须要自己实现的
 *
 */
public class GenderException extends Exception{

    public GenderException(){
        System.out.println("性别异常");
    }

    public GenderException(String msg){
        System.out.println(msg);
    }
}

try-catch-finally中存在return语句的执行顺序

package com.petrel;

/**
 * finally要在return之前执行
 */
public class TryTest{
	public static void main(String[] args){
		System.out.println(test().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("number.num>20 : " + number.num);
			}
			System.out.println("finally");
			number.num = 100;
		}
		return number;
	}
}

class Num{
	public int num = 10;
}

运行结果：