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 =;
        int y = ;
        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[];
         System.out.println("赋值：");
         try {
             for(int i = ; 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 >=  && age <= ) {
             this.age = age;
         }else {
             //抛异常 运行时异常
             throw new AgeException("年龄必须在 0 - 150之间");
         }
     }
 }
 public class TestEmployee {

     public static void main(String[] args) {

         try {
             new Employee().setAge();

         } catch (AgeException e) {

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

 }

异常处理的原则

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

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

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

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

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