Java에서 예외가 발생하는 원인 및 처리 방법

Java의 예외(예외라고도 함)는 프로그램 실행 중에 발생하는 이벤트로, 이로 인해 실행 중인 프로그램의 정상적인 명령 흐름이 중단됩니다. 프로그램의 실행 오류를 신속하고 효과적으로 처리하기 위해서는 예외 클래스를 사용해야 합니다.

1. 예외의 원인 및 분류

1.1 예외의 원인

예외는 주로 세 가지 이유로 발생합니다.

(1) 프로그램 코드 작성 오류로 인해 발생 out-of-bounds, null 포인터 예외 등 이러한 종류의 예외를 확인되지 않은 예외라고 합니다. 일반적으로 이러한 예외는 클래스

에서 처리해야 합니다. (2) Java 내부 오류, Java 가상 머신으로 인해 발생하는 예외입니다. 예외 생성

(3) throw 문을 통해 수동으로 생성된 예외입니다. 이 예외를 확인된 예외라고 합니다. 일반적으로 메서드 호출자에게 필요한 정보를 제공하는 데 사용됩니다.

1.2 예외 분류

(1) Throwable: 두 개의 중요한 하위 클래스인 Error와 Exception

                                                  두 개의 하위 클래스 Error 및 Exception을 파생하는 예외 시스템의 최상위 클래스입니다.

Unchecked Exception과 Checked Exception의 차이점은 다음과 같습니다.

(2) Exception 클래스는 사용자 프로그램에서 발생할 수 있는 예외에 사용되는 클래스이기도 합니다.

(3) 오류는 일반적인 상황에서 프로그램이 포착할 수 없을 것으로 예상되는 예외를 정의합니다. Error 유형의 예외는 Java 런타임에서 런타임 시스템 자체와 관련된 오류를 표시하는 데 사용됩니다. 스택 오버플로가 이 오류의 예입니다.

예외는 컴파일 중에 또는 프로그램이 실행되는 동안 발생할 수 있습니다. 발생 시기에 따라 다음과 같이 나눌 수 있습니다.

런타임 예외는 모두 RuntimeException 클래스 및 해당 하위 클래스의 예외입니다. NullPointerException, IndexOutOfBoundsException 등. 이러한 예외는 확인되지 않은 예외입니다. 프로그램에서 이를 캡처하거나 처리하지 않도록 선택할 수 있습니다. 이러한 예외는 일반적으로 프로그램 논리 오류로 인해 발생하므로 프로그램은 논리적 관점에서 이러한 예외가 발생하지 않도록 노력해야 합니다.

예:

컴파일 시간 예외는 RuntimeException 이외의 예외를 참조하며 모두 Exception 클래스와 해당 하위 클래스에 속합니다. 프로그램 구문의 관점에서 처리해야 하는 예외입니다. 처리되지 않으면 프로그램이 컴파일되지 않습니다. IOException, ClassNotFoundException 등 및 사용자 정의 예외 예외는 일반적으로 사용자 정의 확인 예외가 사용되지 않습니다.

예를 들어

class Person implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Test01 {

    public static void main(String[] args) {
        Person person =new Person();
        Person person1 =(Person) person.clone();
    }
}

2. 예외 처리

2.1 방어적인 프로그래밍

오류는 코드에 객관적으로 존재하므로 프로그램에 문제가 있을 경우 프로그래머에게 신속하게 알려야 합니다.

알림 방법은 두 가지가 있습니다.

(1) LBYL은 작업 전 충분한 확인을 합니다

private static int pide() {
        int a = 0, b = 0;
        Scanner scanner = new Scanner(System.in);
        a = scanner.nextInt();
        b = scanner.nextInt();
        if (b == 0) {
            System.out.println("除数为0");
            return 0;
        } else {
            return a / b;
        }
    }

단점: 일반 프로세스와 오류 처리 프로세스 코드가 섞여 있어 전체적인 코드가 명확하지 않습니다.

(2) EAFP는 먼저 작동하고 문제가 발생한 후 처리합니다

private static int pide() {
        int a = 0, b = 0;
        try (Scanner scanner = new Scanner(System.in)) {
            a = scanner.nextInt();
            b = scanner.nextInt();
            return a / b;
        } catch (ArithmeticException exception) {
            System.out.println("除数为0");
            return 0;
        } 
    }

장점: 일반 프로세스와 오류 프로세스가 분리되어 있어 프로그래머가 일반 프로세스에 더 많은 관심을 기울이고 코드가 더 명확하며 쉽습니다. 코드를 이해하려면

예외 처리의 핵심 아이디어는 EAFP입니다.

2.2 예외 던지기

프로그램을 작성할 때 프로그램에 오류가 발생하면 호출자에게 알려야 합니다. 오류 정보

여기에서 throw 키워드를 사용하여 지정된 예외 개체를 던지고 호출자에게 오류 메시지를 알릴 수 있습니다.

예를 들어 런타임 예외를 작성합니다.

    public static void func2(int a) {
        if(a == 0) {
           //抛出的是一个指定的异常，最多的使用方式是，抛出一个自定义的异常
            throw new RuntimeException("a==0");
        }
    }
    public static void main(String[] args) {
        func2(0);
    }

참고:

(1) throw는 메서드 본문 내부에 작성해야 합니다.

(2) 컴파일 시간 예외가 발생하는 경우, 그렇지 않으면 컴파일을 통과하지 못할 것입니다

(3) 런타임 예외가 발생하면 처리할 필요가 없으며 처리를 위해 JVM에 직접 넘겨질 수 있습니다.

(4) 예외가 발생하면 다음 코드가 실행되지 않습니다

2.3 异常的捕获

2.3.1 throws异常声明

 throws处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，

此时就可以借助throws将异常抛 给方法的调用者来处理。

格式：  

修饰符 返回值类型 方法名(参数列表) throws 异常类型 {  

}  

如果说方法内部抛出了多个异常，throws之后就必须跟多个异常类型，用逗号进行分隔

    public static void func2(int a) throws CloneNotSupportedException, FileNotFoundException {
        if(a == 0) {
            throw new CloneNotSupportedException("a==0");
        }
        if(a == 1) {
            throw new FileNotFoundException();
        }
    }

  如果抛出多个异常类型有父子关系，直接声明父类

    public static void func2(int a) throws Exception {
        if(a == 0) {
            throw new CloneNotSupportedException("a==0");
        }
        if(a == 1) {
            throw new FileNotFoundException();
        }
    }

调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出

   public static void main(String[] args) throws FileNotFoundException, CloneNotSupportedException {
        func2(0);
    }

2.3.2 try-catch捕获异常并处理

当程序抛出异常的时候，程序员通过try-each处理了异常

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }
        System.out.println("其他程序！");
    }

如果程序抛出异常，不处理异常，那就会交给JVM处理，JVM处理就会把程序立即终止

并且，即使用了try-each 也必须捕获一个对应的异常，如果不是对应异常，也会让JVM进行处理

 如果try抛出多个异常，就必须用多个catch进行捕获

这里注意，用多个catch进行捕获，不是同时进行捕获的，因为不可能同时抛不同的异常

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }
        System.out.println("其它代码逻辑！");
    }

也可以简写一下

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException  | ArithmeticException e) {
            System.out.println("捕获到了一个空指针或算术异常！");
        }
        System.out.println("其它代码逻辑！");
    }

如果异常之间具有父子关系，那就必须子类异常在前，父类异常在后catch，不然会报错  

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (Exception) {
            System.out.println("捕获到了一个算术异常！");
        }
        System.out.println("其它代码逻辑！");
    }

---

2.3.3 finally

finally用来进行资源回收，不论程序正常运行还是退出，都需要回收资源

并且异常会引发程序的跳转，可能会导致有些语句执行不到

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }finally {
            scanner.close();
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

如果不为空，那么finally还会被执行吗

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            int[] array = {1,2,3};
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }finally {
            scanner.close();
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

所以，不管程序会不会抛出异常，finally都会执行

如果将资源写在try中会自动帮助，关掉资源的

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            int[] array = {1, 2, 3};
            System.out.println(array.length);
        } catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        } catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        } finally {
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

下面看这一段代码

    public static int func(int a) {
        try{
            if(a == 0) {
                throw  new ArithmeticException();
            }
            return a;
        } catch (ArithmeticException e) {
            System.out.println("算术异常！");
        } finally {
            return 20;
        }
    }

    public static void main(String[] args) {
        System.out.println(func(10));
    }

可以发现即使有return，finally也会被执行

总结一下：

throw抛出异常，throws声明异常

finally语句一定会执行

3.自定义异常类

虽然java中有很多异常类，但是在实际开发中所遇到的一些异常，不能完全表示，

所以这就需要我们自定义异常类

举一个例子

先自定义一个运行时异常

//自定义了一个运行时异常
public class MyException extends RuntimeException{
    public MyException() {

    }
    public MyException(String message) {
        super(message);
    }
}

写一个类来捕获这个自定义异常

public class Test04 {
    public static void func(int a ) {
        throw new MyException("呵呵！");
    }

    public static void main(String[] args) {
        try {
            func(20);
        }catch (MyException myException) {
            myException.printStackTrace();
        }finally {
            System.out.println("sadasdasd");
        }

    }
}

下面写一个用户登录的自定义异常类

class UserNameException extends RuntimeException {
    public UserNameException() {

    }
    public UserNameException(String message) {
        super(message);
    }
}
class PasswordException extends RuntimeException {

    public PasswordException() {
    }

    public PasswordException(String message) {
        super(message);
    }
}

public class LogIn {
    private static String uName = "admin";
    private static String pword = "1111";

    public static void loginInfo(String userName, String password) {
        if ( !uName.equals(userName)) {
            throw new UserNameException("用户名错误！");
        }
        if ( !pword.equals(password)) {
            throw new RuntimeException("密码错误！");

        }
        System.out.println("登录成功！");
    }

    public static void main(String[] args) {
        try {
            loginInfo("admin","1111");
        } catch (UserNameException e) {
            e.printStackTrace();
        } catch (PasswordException e) {
            e.printStackTrace();
        }
    }
}

注意：

自定义异常默认会继承 Exception 或者 RuntimeException  

继承于 Exception 的异常默认是受查异常  

继承于 RuntimeException 的异常默认是非受查异常  

위 내용은 Java에서 예외가 발생하는 원인 및 처리 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!