Day12 Java异常处理与程序调试

什么是异常？

不正常的，会影响程序的正常执行流程。

例如下面的程序

public static void main(String[] args) {
        TestDemo1 t = new TestDemo1();
        t.a();
        System.out.println("其它程序代码");
    }
    public void a() {
        b();
    }
    public void b() {
        int x =5;
        int y = 0;
        int z = x / y;
        System.out.println("结果是:"+z);
    }

Error：错误

 JVM自身的错误，程序员不能处理。

Exception：异常

受检异常（非运行时异常）

程序员必须进行异常处理，否则编译通不过

运行时异常

RuntimeException类和它的子类。

程序员可以不做处理。改代码。

也可以处理，处理了程序可以不中断。

 

异常处理机制

 Java的异常处理是通过5个关键字来实现的:try、catch、finally、throw和throws。

try...catch基本语法

可以添加多个catch

public void method() {
        try {
            //代码段（此处可能会产生异常）
        }catch(异常类型 ex) {
            //对异常进行处理的代码段
        }
        //代码段
    }

try...catch三种情况

1.没有引发异常，不执行catch块

2.异常类型匹配，可以处理，程序不会中断，执行catch块，其他代码正常执行

3.异常类型不匹配，程序中断，不执行catch块

try...catch...catch...

public void method() {
        try {
            //代码段（此处可能会产生异常）
        }catch(异常类型 ex1) {
            //对异常进行处理的代码段
        }catch(异常类型 ex2) {
            //对异常进行处理的代码段
        }
        //代码段
    }

多重catch块的好处

 对不同的异常，进行不同的处理

为了避免漏掉异常，在最后catch块中使用Exception父类。

但是，遵循规则:

1.先子类后父类。

2.先普通后特殊。

 try...catch...catch...finally...

保证一些资源释放的代码一定会执行

public void method() {
        try {
            //代码段（此处可能会产生异常）
        }catch(异常类型 ex1) {
            //对异常进行处理的代码段
        }catch(异常类型 ex2) {
            //对异常进行处理的代码段
        }finally{
              //此代码块一定会执行，无论是否引发异常
              System.out.println("此代码块一定会执行");
        }
        //代码段
    }

public class TestException2 {
    
    public void showArr() {
        Scanner input = new Scanner(System.in);
        int [] arr = new int[5];
        System.out.println("赋值：");
        try {
            for(int i = 0; i < arr.length; i++) {
                arr[i] = input.nextInt();
            }
            Arrays.stream(arr).forEach(System.out::println);
        } catch (InputMismatchException e) {
            System.out.println("赋值出错了");
            e.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("赋值出错了");
            e.printStackTrace();
        } catch (Exception e) {
            System.out.println("赋值出错了");
            e.printStackTrace();
        } finally {
            input.close();//释放资源
            System.out.println("程序运行结束");
        }
    }
    public static void main(String[] args) {
        new TestException2().showArr();
        
    }

}

throws

声明异常，是把异常抛给了调用者。

调用者处理方式

1.try - catch 建议使用

2.throws

throws 运行时异常：调用者可不做处理。

class Demo{
    public void div() throws RuntimeException{
        //我不想处理
        //处理不了
        Scanner input = new Scanner(System.in);
        System.out.println("输入数字");
        int n1 = input.nextInt();
        int n2 = input.nextInt();
        int n3 = n1 / n2;
        System.out.println(n3);
    }
}
public class TestException3 {
   // 2.继续 throws  向上抛出  throws Exception 
    public static void main(String[] args){
        Demo demo = new Demo();
        //调用者
        //(1)处理了 用try - catch
    /*    try {
            demo.div();
        } catch (Exception e) {
            e.printStackTrace();
        }*/
        demo.div();
        
    }

}

throw

自定义异常

定义类继承自系统异常父类

class AgeException extends Exception{
    String str;
    AgeException(String str){
//        this.str = str;
        super(str);
    }
    @Override
    public String getMessage() {
        return "Message:年龄必须是 0 - 150";
    }
    @Override
    public String toString() {
        return "String:年龄必须是 0 - 150";
    }
    @Override
    public void printStackTrace() {
        System.out.println("stack:年龄必须是 0 - 150");
    }
}
class Employee{
    private int age;
    private String sex;//男 和 女 Gender
    
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) throws Exception{
        if(sex.equals("男") || sex.equals("女")) {
            this.sex = sex;
        }else {
            throw new Exception("性别必须是男 和女");
        }
        
    }
    public int getAge() {
        return age;
    }
/*    public void setAge(int age) throws Exception{
        if(age >= 0 && age <= 150) {
            this.age = age;
        }else {
            //抛异常
            throw new Exception("年龄必须在 0 - 150之间");
        }
    }*/
    public void setAge(int age) throws AgeException{
        if(age >= 0 && age <= 150) {
            this.age = age;
        }else {
            //抛异常 运行时异常
            throw new AgeException("年龄必须在 0 - 150之间");
        }
    }
}
public class TestEmployee {

    public static void main(String[] args) {
        
        try {
            new Employee().setAge(245);
            
        } catch (AgeException e) {

//            e.printStackTrace();
//            System.out.println(e);
            System.out.println(e.getMessage());
        }
    }

}

异常处理的原则

1.异常用于处理不正常的情况

2.尽量避免用过大的try块

3.尽量用多重catch块，对不同的异常进行不同的处理

4.尽量处理异常，不要避免异常

5.最好在@throws中标出异常类型