java处理异常这一篇就够了

java 异常

package com.text01;

import java.util.Scanner;

public class Text {
    public static void main(String[] args) {
        //实现一个功能：
        //键盘录入俩个数，求商
        Scanner scanner = new Scanner(System.in);
        System.out.println("cin one:");
        int num1 = scanner.nextInt();
        System.out.println("cin two:");
        int num2 = scanner.nextInt();
        System.out.println("s = "+num1/num2);

        //测试过程中发现问题
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

第一行提示异常的类型，最后一行提示异常出现的位置

Exception in thread "main" java.util.InputMismatchException
	at java.base/java.util.Scanner.throwFor(Scanner.java:939)
	at java.base/java.util.Scanner.next(Scanner.java:1594)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
	at com.text01.Text.main(Text.java:13)
//输入不匹配异常
    
    
    java.util.InputMismatchException//输入不匹配
    at com.text01.Text.main(Text.java:13)//在第13行出现
1
2
3
4
5
6
7
8
9
10
11

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.text01.Text.main(Text.java:14)
	//算术异常
1
2
3

异常：Exception：在程序的运行过程中，发生了不正常的现象，称之为异常

处理异常

if - else

package com.text01;

import java.util.Scanner;

public class Text {
    public static void main(String[] args) {
        //实现一个功能：
        //键盘录入俩个数，求商
        Scanner scanner = new Scanner(System.in);
        System.out.println("cin one:");
        int num1 = scanner.nextInt();
        System.out.println("cin two:");
        int num2 = scanner.nextInt();
        if(num2 == 0){
            System.out.println("sorry,num is not 0");
        }else {
            System.out.println("s = " + num1 / num2);
        }
        //测试过程中发现问题
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

缺点：

1. 业务代码和处理异常的代码混在一起
2. 可读性差
3. 需要花费大量的精力来维护漏洞
4. 很难堵住所有的漏洞

try…catch

package com.text01;

import java.util.Scanner;

public class Text02 {
    public static void main(String[] args) {
        //实现一个功能：
        //键盘录入俩个数，求商
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.println("cin one:");
            int num1 = scanner.nextInt();
            System.out.println("cin two:");
            int num2 = scanner.nextInt();
            System.out.println("s = " + num1 / num2);
        }catch (Exception ex){
            System.out.println("break down");
        }

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

异常捕获后，不影响程序的下一步执行！

原理：

把可能出现异常的代码放入try代码块中，然后将异常封装为对象，被catch后面的（）中的那个异常对象接收，接收后，：执行catch后面的{}代码，然后try-catch后面的代码该怎么执行怎么执行

Exception：属于异常的父类，故可以用Exception来接收异常，当异常不匹配的时候，即使出现异常，catch{}中的代码也不会执行

catch如何处理异常？

package com.text01;

import java.util.Scanner;

public class text03 {
    public static void main(String[] args) {
        //实现一个功能：
        //键盘录入俩个数，求商
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.println("cin one:");
            int num1 = scanner.nextInt();
            System.out.println("cin two:");
            int num2 = scanner.nextInt();
            System.out.println("s = " + num1 / num2);
        }catch (Exception ex){
            //1.什么都不写
            //2.
            //System.out.println("break down");

            //3.打印异常信息
            System.out.println(ex);
            System.out.println(ex.toString());
            System.out.println(ex.getMessage());
            ex.printStackTrace();//将异常信息捕获后，在控制台展示出来，用的最多

            //4.抛出异常
            throw ex;
            //捕获后重新把异常抛出去，后面的代码也不再执行
        }
        System.out.println("hh");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

finally

在什么情况下catch后面的代码不执行？

1. throw ex抛出异常的时候，后面的代码就不再执行
2. catch中没有正常的进行异常捕获
3. 在catch中遇到return

那么咋样让try-catch后面的代码，必须执行？

只要将必须执行的代码放入finally中，那么这个代码无论如何一定执行

package com.text01;

import java.util.Scanner;

public class text04 {
    public static void main(String[] args) {
        //实现一个功能：
        //键盘录入俩个数，求商
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.println("cin one:");
            int num1 = scanner.nextInt();
            System.out.println("cin two:");
            int num2 = scanner.nextInt();
        } catch (Exception ex) {
            throw ex;
        } finally {
            System.out.println("hh");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

假如出现return：

先执行finally中的代码最后执行return

什么代码放在finally中？

1. 关闭数据库资源
2. 关闭IO流资源
3. 关闭socket资源……

只有程序强制退出，能让finally不执行。

System.exit(1);

多重catch

package com.text01;

import java.util.InputMismatchException;
import java.util.Scanner;

public class text04 {
    public static void main(String[] args) {
        //实现一个功能：
        //键盘录入俩个数，求商
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.println("cin one:");
            int num1 = scanner.nextInt();
            System.out.println("cin two:");
            int num2 = scanner.nextInt();
        } catch (InputMismatchException ex) {
            System.out.println("Input is not Int");
        } catch (ArithmeticException ex) {
            System.out.println("The divisor cannot be empty");
        } finally {
            System.out.println("hh");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

针对不同的异常，输出不同的语句，比较顺序为：依次比对，在安排顺序的时候，我们一般先将小范围的先在前面，大范围的写在后面，即子类在前，父类在后。

异常的分类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MnGQ72if-1667472517584)(D:\图片\image-20221103165921005.png)]

我们的重点在Exception，因为Error异常我们一般是无法解决的。程序中的语法错误，逻辑错误，不属于上面的Error，Exception

package com.text01;

public class Text05 {
    public static void main(String[] args) {
        //运行时异常
        int[] arr = {1,2,3};
        System.out.println(arr.length);
        int[] arr1 = null;
        System.out.println(arr1.length);
        //空指针异常
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

属于运行时异常

package com.text01;

public class Text06 {
    public static void main(String[] args) {
        //检查异常
        Class.forName("com.text01.Text");
    }
}
1
2
3
4
5
6
7
8

起到一个防患于未然的效果，在写代码的时候就要对代码的异常进行处理

属于检查时异常

throw和throws

共同点

两者在抛出异常时，抛出异常的方法并不负责处理，顾名思义，只管抛出，由调用者负责处理。

区别

（1）throws用于方法头，表示的只是异常的申明，而throw用于方法内部，抛出的是异常对象。

（2）throws可以一次性抛出多个异常，而throw只能一个
（3）throws抛出异常时，它的上级（调用者）也要申明抛出异常或者捕获，不然编译报错。而throw的话，可以不申明或不捕获（这是非常不负责任的方式）但编译器不会报错。

重载和重写的区别

重载：在同一个类中，当方法名相同，形参列表不同的时候，多个方法构成了重载

重写：在不同的类中，子类对父类提供的方法不满意的时候，要对父类的方法进行重写

package com.text01;

public class Demo {
    public void a() throws Exception{

    }
    public void a(int age) throws ArithmeticException{
        
    }
}

1
2
3
4
5
6
7
8
9
10
11

package com.text01;

public class ddmo {
    public class Person{
        public void eat() throws RuntimeException{
            System.out.println("父类方法");
        }
    }
    public class Student extends Person{
        @Override
        public void eat() throws RuntimeException {
            System.out.println("子类方法");
        }
    }
    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

子类<=父类