Java 예외를 처리하는 방법은 무엇입니까?

예외란 무엇인가요?

우리가 코드를 작성할 때 예외는 매우 흔합니다. 왜냐하면 프로그래머는 대부분의 시간을 버그 수정에 소비하기 때문입니다. Java에서 throwable의 최상위 클래스는 두 개로 나눌 수 있는데, 하나는 Error(오류)이고 다른 하나는 Exception(예외)입니다. ).

Error(오류): Error와 예외의 차이점은 오류는 처리할 수 없지만 프로그래머에 의해 발생하는 문제입니다. 예를 들어 구문 오류가 있으면 프로그래머는 자신의 구문을 확인해야 합니다. 결과적으로 오류(StackOverflowError 및 OutOfMemoryError

)가 발생하면 프로그래머는 자체 논리를 확인해야 합니다.

예외: 이는 나중에 설명할 throws(예외 선언) 및 try{}catch{}(예외 처리)와 같은 몇 가지 방법으로 처리될 수 있으며, 예외를 처리하는 방법은 다음과 같습니다. 이는 확인된 예외(컴파일 시 예외)와 확인되지 않은 예외(런타임 예외 RuntimeException)입니다.

컴파일 타임 예외: 프로그램을 컴파일할 수 없습니다. 이는 컴파일 타임 예외입니다. 예: 복제 시 예외를 throw를 통해 선언해야 합니다.

런타임 예외: 컴파일을 통과할 수 있는 프로그램을 말합니다. , 그러나 런타임 중에 예외가 발생합니다. 예: NullPointerException,

에서 발생한 예외는 ArrayIndexOutOfBoundsException 또는 ArithmeticException입니다.

위의 예외는 처리할 수 있지만 오류가 발생하면 프로그래머가 코드를 직접 확인해야 합니다.

예외 처리

이를 처리하는 방법에는 두 가지가 있습니다.

하나는 사전에 방어적인 유형입니다.

boolean ret = false;
ret = login game();
if (!ret) {
로그인 게임 처리 error;
return;
} r
et = 매칭 시작();
if (!ret) {
매칭 오류 처리;
return;
} r
et = 게임 확인();
if (!ret ) {
게임 확인 오류 처리;
return;
} r
et = 영웅 선택();
if (!ret) {
영웅 선택 오류 처리;
return;
} r
et = 게임 화면 로드() ;
if ( !ret) {
게임 로딩 오류 처리;
return;
} .
...

미리 방어하는 방식은 매 단계마다 오류가 있는지 확인하는 것입니다. 이 방법의 단점은 코드가 매우 혼란스럽다는 것입니다.

하나는 나중에 실수를 인정하는 것입니다.

try {
게임에 로그인();
매칭 시작();
게임 확인();
영웅 선택();
게임 화면 로드( );
...
} catch(로그인 게임 예외) {
로그인 게임 예외 처리;
} catch(매칭 시작 예외) {
handle 매칭 시작 예외;
} catch(게임 확인 예외) {
게임 확인 예외 처리 ;
} catch(영웅 선택 시 예외) {
영웅 선택 시 예외 처리;
} catch(게임 로딩 화면 예외) {
게임 로딩 화면 예외 처리;
} .
....

이것은 코드에서 발생할 수 있는 모든 예외를 try에 넣습니다. 예외가 발견되어 포착되면 먼저 작업을 수행하고 문제를 처리합니다.

우리는 코드를 간결하고 명확하며 더 효율적으로 만들기 위해 두 번째 trycatch를 자주 사용합니다.

예외 발생

코드 조각이 기대에 미치지 못하는 경우 Java에서 throw 키워드를 사용하여 예외를 발생시켜야 합니다.

신택스는 새로운 예외를 발생시키는 것입니다(발생하려는 예외)

public class TestDemo {
    public static void func(int a) {
        if(a==10) {
            throw new RuntimeException("a==10不符合预期，抛出这个异常");
        }
    }
    public static void main(String[] args) {
           func(10);
    }
}

이 코드를 보세요: 예를 들어 숫자 10은 프로그램의 기대치를 충족하지 않으므로 예외를 발생시키려면 다음을 수행할 수 있습니다. 다음과 같이 실행됩니다: throw new RuntimeException("a==10이 예상과 다릅니다. 이 예외를 발생시킵니다.");

예외 처리

일반적으로 예외를 처리하는 방법에는 두 가지가 있습니다. 하나는 throw를 통해 예외를 선언하는 것입니다. 다른 하나는 try{}catch를 통합니다. {} try를 통해 코드 블록에 예외가 있는지 확인합니다. 예외가 있으면 catch합니다. 다음 코드는 정상입니다.

throws 선언 예외

구문: throws 예외, 예외, 예외... (여러 예외가 선언될 수 있음)

public class TestDemo {
    public static void function(int[] array) {
        System.out.println(array[100]);
    }
    public static void main(String[] args) {
        int[] array = {7, 8, 9, 5, 6};
        function(array);
    }
}

여기에서 100개의 첨자에 액세스하는 것은 범위를 벗어난 배열 예외라는 것을 누구나 알고 있습니다.

계속 다음으로 throw를 통해 예외를 선언합니다.

오류는 계속 보고됩니다.

main 함수에서도 예외를 선언하는 경우:

대답은 여전히 ​​오류입니다.

그래서 여기서 우리는 결론을 내립니다. Throw는 이 예외가 이 메서드에서 발생할 수 있음을 컴파일러에 알리는 것일 뿐이며 예외는 처리되지 않습니다. 또한 특정 메소드에서 예외가 발생하면 이 메소드가 예외를 처리하는지 여부를 확인할 수 있습니다. 예외를 처리하지 않으면 상위 호출자가 예외를 처리하는지 확인할 수 있습니다. 여기서 func는 예외만 선언하고 예외를 처리하지 않습니다. 그런 다음 상위 호출자가 예외(즉, 기본 메서드)를 처리하는지 여부를 확인하고 최종적으로 이를 JVM에 맡겨 프로그램을 처리하고 종료합니다. . 예외 선언은 Exception 클래스 또는 그 하위 클래스에 속해야 합니다.

要处理异常，就需要使用接下来所述的try{}catch语句。

捕获异常

try{

}catch(){

}

在Java我们利用try{}catch{}来处理异常；

语法：

    try{
     //可能发生异常的代码
    }catch(异常 变量){//例如：ArrayIndexOutOfBoundsException(要捕获的异常) e(变量)
      //如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，
      //或者是try中抛出异常的基类时，就会被捕获到
      // 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
    }finally{
      //此处代码一定会执行，用于资源清理扫尾等工作
    }

我们先来讲一下try{}catch(){}

/*在方法中处理异常*/
public class TestDemo {
    public static void function(int[] array) throws ArrayIndexOutOfBoundsException {
        try{
            System.out.println(array[100]);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("array[100]->数组下标越界异常catch->捕获成功");
        }
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException {
        int[] array = {7, 8, 9, 5, 6};
        function(array);
    }
}
/*在main方法中处理异常*/
public class TestDemo {
    public static void function(int[] array) throws ArrayIndexOutOfBoundsException {
            System.out.println(array[100]);
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException {
        int[] array = {7, 8, 9, 5, 6};
        try{
            function(array);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("array[100]->数组下标越界异常catch->捕获成功");
        }
    }
}

我们使用try{}catch(){}就可以对异常进行处理，既可以在方法中处理异常也可以在main方法中处理异常，同时这里throws虽然没有什么用处，但是可以清晰的告诉程序员，这个方法未来可能会发生这个异常，所以还是有必要的。

try{}catch{}注意点 一：

当捕获异常成功的时候，后面的业务代码正常执行，如果没有捕获那就不会执行。

try{}catch{}注意点 二：

 当try里检查到异常，catch就会捕获，计算这个异常后面还有异常也不会执行。

try{}catch{}注意点三：

throws只是声明异常，并没有处理异常，我们要通过try{}catch(){}来处理异常。

try{}catch{}注意点四：

 当catch捕获的异常类型与发生异常类型不符合，就不会被捕获，就继续往外抛异常知道JVM收到后终止程序

try{}catch{}注意点五：

 当发生多种异常的时候，那就要多种catch来捕获，多种异常，多次捕获。

try{}catch{}注意点六：

 Exception是所有类的父类不能在前面捕获，而是应该放在最末尾进行收尾工作。

既然Exception类是所对应异常类的父类，那可不可以捕获Exception，即多次异常，一次捕获呢？？

catch 进行类型匹配的时候, 不光会匹配相同类型的异常对象, 也会捕捉目标异常类型的子类对象

答案是不建议的。当代码变得复杂时，只捕获Exception类并不能明确哪些处理方式出现了问题。

打印异常信息

我们还可以利用printStackTrace来打印错误信息。

finally:

finally经常与try{}catch(){}进行一起使用，finally主要是进行资源的清理，的扫尾工作，且finally一定会被执行。

我们来看这样一段代码结果会是什么？？

public class TestDemo {
    public static int function(int[] array) throws ArrayIndexOutOfBoundsException {
        try {
            System.out.println(array[100]);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("array[100]->数组下标越界异常catch->捕获成功");
            return -1;
        }finally{
            System.out.println("finally主要进行资源回收和清理的扫尾工作~~~");
            return 9;
        }
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException,ArithmeticException {
        int[] array = {7, 8, 9, 5, 6};
        System.out.println(function(array));
        System.out.println("以下是业务代码~~~~~~");
    }
}

 答案并不是我们想的return-1,执行结束，而是return9，我们这里可以理解为finally的9将catch里的-1覆盖。所以finally里面的代码是一定会执行的。

异常的处理流程

我的理解：

第一步检查try里面的代码里是否有异常，如果有异常catch就进行捕获，如果没有异常接着往下执行，这里catch如果没有捕获到就看一看上层调用者有没有处理，有处理就进行处理，没有处理就交给JVM终止程序。如果catch捕获到了，下面正常的业务代码正常执行。无论catch是否捕获到异常，finally代码块都将被执行。

官方：

• 程序先执行 try 中的代码

• 如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.

• 如果找到匹配的异常类型, 就会执行 catch 中的代码

• 如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.

• 无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).

• 如果上层调用者也没有处理的了异常, 就继续向上传递.

• 一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止。

自定义异常

在我们做很大型的项目的时候，我们就会发现，我们遇到的异常，在Java中的内置异常并没有，所以我们就需要自己定义一个异常，来维护我们实际中遇到的异常。

java 中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时需要维护符合我们实际情况的异常结构

在Java中自己声明异常，不是说你写了个异常的名字就是一个异常，而是在你自己定义的异常需要取继承原有的内置异常。

我们通过一个登陆的代码来讲解自定义异常：

class LogIn {
    private String name ="Admin";//用户名
    private String password= "CsDn1263987..0";
    public void logInFor(String name,String password) throws UserNameErrorExecption, PasswordErrorException {
        if(!this.name.equals(name)){
            throw new UserNameErrorExecption("用户名参数异常！！！");
        }
        if(!this.password.equals(password)) {
            throw  new PasswordErrorException("用户密码参数异常！！！");
        }
        System.out.println("~~~登陆成功~~~");
    }
}
public class TestDemo{
    public static void main(String[] args) throws UserNameErrorExecption, PasswordErrorException {
        LogIn logIn = new LogIn();
        //logIn.logInFor("Admin","CsDn1263987..0");
        try{
            logIn.logInFor("Admin","CsDn126398..0");
        }catch(UserNameErrorExecption nameError) {
            nameError.printStackTrace();
            System.out.println("用户名错误！！！");
        }catch(PasswordErrorException passwordError) {
            passwordError.printStackTrace();
            System.out.println("密码错误！！！");
        }
    }
}

自定义异常：

class PasswordError extends Exception {
     public PasswordError(String message) {
           super(message);
     }
}

class UserNameError extends Exception {
    public UserNameError(String message) {
        super(message);
    }
}

这就是我们定义的两个异常。

通过继承Exception来定义两个异常。

通常我们自定义异常类要继承Exception或者RunTimeException类，除此之外也可以定义其他类作为异常类。

• 自定义异常通常会继承自 Exception 或者 RuntimeException

• 继承自 Exception 的异常默认是受查异常

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

위 내용은 Java 예외를 처리하는 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!