왜 예외 처리를 하는가? Java 예외 처리 메커니즘에 대한 자세한 설명

1. 배경 소개

예외 처리를 수행해야 하는 이유는 무엇인가요?

컴퓨터 프로그램의 경우 실행 시 오류가 발생하지 않을 것이라고 누구도 보장할 수 없습니다.

• 코드 오류

• 잘못된 사용자 입력

• 장비 오류 및 물리학 제한 사항: 디스크 가득 참, 메모리 오버플로, 하드웨어 문제, 네트워크 중단...

프로그램 오류, 어떻게 해결하나요? Java 언어에서는 이 문제를 처리하는 데 도움이 되는 예외 처리 메커니즘을 제공합니다.

       예외 메커니즘은 프로그램의 예외 처리 코드를 일반 비즈니스 코드와 분리하여 프로그램 코드를 더욱 우아하게 만들고 프로그램의 견고성을 향상시킬 수 있습니다.

      Java의 예외 메커니즘은 주로 try, catch, finally, throw 및 throws의 5가지 키워드에 의존합니다.

                                                                          뒤에는 중괄호로 묶인 코드 블록(중괄호는 생략할 수 없음)이 따르며, 다음을 포함합니다. 예외를 일으킬 수 있는 코드, catch 후 해당 예외 유형과 코드 블록을 사용하여 나타냅니다. catch 블록은 이러한 유형의 코드 블록을 처리하는 데 사용됩니다. 여러 catch 블록 뒤에 finally 블록이 올 수도 있습니다. finally 블록은 try 블록에서 열린 물리적 리소스를 재활용하는 데 사용됩니다. 블록은 항상 실행됩니다. throws 키는 메소드 서명에서 주로 메소드에서 발생할 수 있는 예외를 선언하는 데 사용됩니다. throw는 실제 예외를 발생시키는 데 사용되며, 특정 예외를 발생시키는 별도의 명령문으로 사용될 수 있습니다. 예외 객체.

간단한 예시는 다음과 같습니다. r

try {
   // args表示传入的形参，args[0]表示传入的第一个形参，args[1]表示传入的第二个形参
   int a = Integer.parseInt(args[0]);
   int b = Integer.parseInt(args[1]);
   int c = a / b;
   System.out.println("您输入的两个数相除的结果是："+c);
} catch (IndexOutOfBoundsException ie){
   System.out.println("数组越界：运行程序时输入的参数个数不够");
} catch (NumberFormatException ne){
   System.out.println("数字格式异常：程序只能接收整数参数");
} catch (ArithmeticException ae){
   // 除0异常
   System.out.println("算术异常");
} catch (Exception e){
   System.out.println("未知异常");
}

E

2, Knowledge Analysis

2.1 예외 처리 메커니즘

2.1.1 Try ... Catch 캡처 이상 현상 {

// 비즈니스 구현 코드} Catch(Exception(Exception(Exception e ){

//예외 처리 코드

}

실행 프로세스(또는 로직):

try 블록의 코드가 원활하게 실행될 수 있으면 try 블록의 비즈니스 로직 코드가 "모든 것이 정상"입니다. 실행됨 예외가 발생하면 시스템은 자동으로 예외 객체를 생성하고 이를 Java 런타임 환경에 제출합니다. 이 프로세스를 예외 발생이라고 합니다. Java 런타임 환경은 예외 개체를 수신하면 해당 예외 개체를 처리할 수 있는 catch 블록을 찾고, 적절한 catch 블록이 발견되면 해당 예외 개체가 처리를 위해 catch 블록으로 전달됩니다. 예외; Java 런타임 환경이 예외를 포착하는 catch 블록을 찾을 수 없으면 런타임 환경이 종료되고 Java 프로그램도 종료됩니다.

참고: 프로그램 코드 블록이 try 블록에 있는지 또는 심지어 catch 블록에 있는지 여부에 관계없이 코드 블록을 실행할 때 예외가 발생하는 한 시스템은 항상 자동으로 예외 개체를 생성합니다. 프로그램이 이 코드에 대한 catch 블록을 정의하지 않으면 Java 런타임 환경은 예외를 처리할 catch 블록을 찾을 수 없으며 프로그램이 종료됩니다.

2.1.2 예외 클래스의 상속 시스템

Java 런타임 환경은 예외 개체를 수신하면 예외 개체가 예외 클래스의 인스턴스인지 아니면 catch 블록 다음의 하위 클래스인지 확인합니다. 환경 예외를 처리하기 위해 catch 블록이 호출됩니다. 그렇지 않으면 예외 개체는 다음 catch 블록의 예외 클래스와 다시 비교됩니다.

Java 예외 처리 프로세스

그림에서 볼 수 있듯이 try 블록 뒤에 여러 개의 catch 블록이 있을 수 있습니다. 이는 다양한 예외 클래스에 대해 서로 다른 예외 처리 방법을 제공하기 위한 것입니다. 시스템에서 서로 다른 예상치 못한 상황이 발생하면 시스템은 서로 다른 예외 개체를 생성하고 Java 런타임은 예외 개체가 속한 예외 클래스를 기반으로 예외를 처리하는 데 사용할 catch 블록을 결정합니다.

             일반적인 상황에서는 try 블록이 한 번 실행되면 try 블록 이후에 하나의 catch 블록만 실행되며 여러 개의 catch 블록이 실행되는 것은 절대 불가능합니다. 다음 루프를 시작하기 위해 루프에서 continue를 사용하지 않고 try 블록이 다음 루프에서 다시 실행되지 않으면 이로 인해 여러 catch 블록이 실행될 수 있습니다.

Java의 일반적인 예외 클래스 간의 상속 관계

Java把所有的非正常情况分为两种：异常和错误，它们都继承Throwable父类。

        Error错误，一般指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败、资源耗尽  等，这种错误无法恢复或不可能捕获，将导致应用程序中断。通常应用程序无法处理这些错误，因此应用程序不应该试图使用catch块来捕获Error对象，也无须声明可能抛出Error及其任何子类对象。

常见异常：

IndexOutOfBoundsException：数组越界异常，原因在于运行程序时输入的参数个数不够

NumberFormatException：数字格式异常，原因在于运行程序时输入的参数不是数字，而是字母

ArithmeticException：除0异常

Exception:当发生未知异常时，该异常对象总是Exception类或其子类的实例，可用Exception对应的catch块处理该异常

NullPointerException:空指针异常，当试图调用一个null对象的实例或者实例变量时，会引发此异常

注：进行异常捕获时不仅应该把Exception类对应的catch块放在最后，而且所有父类异常的catch块都应该排在子类异常catch块的后面，即先捕获小异常，再捕获大异常，否则将出现编译错误。（若父类在前，则排在它后面的子类的catch块将永远不会获得执行的机会，因为检索catch块是从上到下依次执行的）

2.1.3 Java7提供多异常捕获

在Java7之前，每个catch块只能捕获一种类型的异常，但从Java7开始，一个catch块可以捕获多种类型的异常。

使用一个catch块捕获多种类型的异常时需要注意如下两个地方：

• 捕获多种类型的异常时，多种异常类型之间用 | 隔开。

• 捕获多种类型的异常时，异常变量有隐式的final修饰，因此程序不能对异常变量重新赋值。

try {
         int a = Integer.parseInt(args[0]);
         int b = Integer.parseInt(args[1]);
         int c = a / b;
         System.out.println("您输入的两个数相除的结果是："+c);
      } catch (IndexOutOfBoundsException|NumberFormatException|ArithmeticException e){
         System.out.println("程序发生了数组越界、数字格式异常、算术异常之一");
         
         // 捕获多异常时，异常变量默认有final修饰
         // 所以下面代码编译报错
//        e = new ArithmeticException("text");
      } catch (Exception e){
         System.out.println("未知错误");
         
         // 捕获一种类型的异常时，异常变量没有final修饰
         // 所有下面代码完全正确
         e = new RuntimeException("test");
      }

2.1.4 访问异常信息

         如果程序需要在catch块中访问异常对象的相关信息，则可以通过访问catch后面括号中的异常形参来获得。当Java运行时决定调用某个catch块来处理该异常对象时，会将异常对象赋给catch块后的异常参数，程序即可通过该参数来获得异常的相关信息。

所有的异常对象都包含了如下几个常用方法：

• getMessage()：返回该异常的详细描述字符串。

• printStackTrace()：将该异常的跟踪栈信息输出到标准错误流。

• printStackTrace(PrintStream s)：将该异常的跟踪栈信息输出到指定输出流。

• getStackTrace()：返回该异常的跟踪栈信息。

2.1.5 使用finally

 有时，程序在try块里打开了一些物理资源（例如数据库连接、网络连接和磁盘文件等），这些物理资源都必须显示回收。

注：Java的垃圾回收机制不会回收任何物理资源，垃圾回收机制只能回收堆内存中对象所占用的内存。

         为了保证一定能回收try块中打开的物理资源，异常处理机制提供了finally块。不管try块中的代码是否出现异常，也不管哪一个catch块是否被执行，甚至在try块或者catch块中执行了return语句，finally块总会被执行。

完整的Java异常处理语法结构：

try{

// 业务实现代码

} catch (Exception1 e){

// 异常处理块1

} catch (Exception2 e){

// 异常处理块2

} finally {

// 资源回收块

}      

예외 처리 구문 구조에는 try 블록만 필요합니다. try 블록이 없으면 다음 catch 블록이 있을 수 없으며 finally 블록은 모두 선택 사항이지만 catch 블록은 있습니다. 마지막으로 블록은 적어도 그 중 하나가 나타날 수 있거나 동시에 나타날 수 있습니다. 여러 개의 catch 블록이 있을 수 있으며 상위 클래스 예외를 포착하는 catch 블록은 catch 하위 클래스 예외 뒤에 위치해야 합니다. try 블록만 있고 catch 블록은 없으며 finally 블록은 없습니다. multiple catch 블록은 try 블록 뒤에 배치되어야 하며 finally 블록은 모든 catch 블록 뒤에 배치되어야 합니다.

참고: try 블록이나 catch 블록에서 가상 머신을 종료하는 메서드가 호출되지 않는 한, try 블록이나 catch 블록에서 어떤 코드가 실행되는지, 어떤 상황이 발생하더라도 finally 블록은 예외 처리는 항상 실행됩니다.

일반적인 상황에서는 메소드를 종료시키는 finally 블록에서 return 또는 throw와 같은 문을 사용하지 마십시오. 그렇지 않으면 매우 이상한 상황이 발생할 수 있습니다.

2.1.6 예외 처리 중첩

완전한 예외 처리 프로세스가 try 블록, catch 블록 또는 finally 블록에 포함되는 상황을 예외 처리 중첩이라고 합니다.

                                                                                                                                                                                       실행 코드가 배치될 수 있는 모든 위치에 배치할 수 있습니다. 따라서 전체 예외 처리 프로세스는 try 블록이나 catch에 배치할 수 있습니다. 블록.

중첩 예외 처리의 깊이에는 명확한 제한이 없지만 일반적으로 두 수준 이상의 중첩 예외 처리를 사용할 필요는 없습니다. 수준이 너무 깊으면 필요하지 않습니다. 그러나 이는 프로그램의 가독성을 감소시킵니다.

2.1.7 리소스를 자동으로 닫는 Java7의 try 문

Java7에서는 try 키워드 뒤에 괄호 쌍을 선언할 수 있도록 하는 try 문의 기능이 향상되었습니다. 여기서 리소스는 프로그램이 끝날 때 명시적으로 닫혀야 하는 리소스(예: 데이터베이스 연결, 네트워크 연결 등)를 참조합니다. try 문은 프로그램이 끝날 때 이러한 리소스를 자동으로 닫습니다. 성명.

참고: try 문이 리소스를 정상적으로 닫을 수 있도록 하려면 이러한 리소스 구현 클래스가 AutoCloseable 또는 Closeable 인터페이스를 구현해야 합니다. 이 두 인터페이스를 구현하려면 close() 메서드를 구현해야 합니다. . (Closeable은 AutoCloseable의 하위 인터페이스입니다. Closeable 인터페이스의 close() 메서드는 IOException을 발생시킨다고 선언하므로 해당 구현 클래스는 close() 메서드를 구현할 때 IOException 또는 그 하위 클래스만 발생한다고 선언할 수 있습니다. AutoCloseable 인터페이스() 메소드 선언은 Exception을 발생시키므로 해당 구현 클래스는 close() 메소드를 구현할 때 모든 예외를 발생시키도록 선언할 수 있습니다)

리소스를 자동으로 닫는 try 문은 암시적 finally 블록(이 finally 블록은 리소스를 닫는 데 사용됨)이므로 이 try 문에는 catch 블록이나 finally 블록이 있을 수 없습니다. 프로그램에 필요한 경우 리소스를 자동으로 닫는 try 문 뒤에 여러 개의 catch 블록과 finally 블록을 포함할 수 있습니다.

Java7은 거의 모든 "리소스 클래스"(다양한 파일 IO 클래스, JDBC 프로그래밍 연결, 명령문 및 기타 인터페이스 포함)를 다시 작성했습니다. 다시 작성된 리소스 클래스는 모두 AutoCloseable 또는 Closeable 인터페이스를 구현했습니다.

2.2 확인된 예외 및 런타임 예외 시스템

Java 예외는 확인된 예외와 런타임 예외의 두 가지 범주로 나뉩니다(런타임 예외, 일부는 확인되지 않은 예외라고도 함). RuntimeException 클래스와 해당 하위 클래스의 모든 인스턴스를 런타임 예외라고 합니다. RuntimeException 클래스가 아닌 예외 인스턴스와 해당 하위 클래스를 확인된 예외라고 합니다. (사용 시 예외 유형을 식별하려면 선언된 예외 클래스를 보면 알 수 있습니다.)

Java 언어만 Checked 예외를 제공하고 다른 언어에서는 Checked 예외를 제공하지 않습니다. Java는 Checked 예외를 처리(수정)할 수 있는 예외라고 생각하므로 Java 프로그램은 Checked 예외를 명시적으로 처리해야 합니다. 프로그램이 Checked 예외를 처리하지 않으면 프로그램 컴파일 중에 오류가 발생하고 컴파일에 실패합니다.

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

• 현재 방법은 예외를 처리하는 방법을 명확하게 알고 있으며 프로그램은 try를 사용해야 합니다. .. .catch 블록을 사용하여 예외를 포착한 다음 해당 catch 블록에서 예외를 수정합니다.

• 현재 메서드는 이 예외를 처리하는 방법을 모르므로 메서드 정의 시 이 예외를 발생시키도록 선언해야 합니다.

런타임 예외는 더 유연합니다. 프로그램이 런타임 예외를 포착해야 하는 경우 런타임 예외를 명시적으로 선언할 필요가 없습니다. 시도해 보세요...블록을 잡아보세요.

참고: Java 핵심 기술

        在Exception层次结构中，有两个分支：一个分支派生于RuntimeException；另一个分支包含其他异常。划分这两个分支的规则是：由程序错误导致的异常属于RuntimeException；而程序本身没有问题，但由于像I/O错误这类问题导致的异常属于其他异常。

          Java语言规范将派生于Error类或RuntimeException类的所有异常称为未（不受？）检查异常（unchecked），所有其他的异常称为已检查异常（checked）。（在编译期间进行检查，编译器将检查是否为所有的已检查异常提供了异常处理器）  ？？？？？？？？？？？ 有待讨论

2.3 使用throws抛出异常

       使用throws声明抛出异常的思路是，当前方法不知道如何处理这种类型的异常，该异常应该由上一级调用者处理；如果main方法也不知道如何处理这种类型的异常，也可以使用throws声明抛出异常，该异常将交给JVM处理。JVM对异常的处理方法是，打印异常的跟踪栈信息，并中止程序运行，这就是平时我们的程序在遇到异常后自动结束的原因。

         throws声明抛出只能在方法签名中使用，throws可以声明多个异常类，多个异常类之间使用逗号隔开。

         一旦使用throws语句声明抛出异常，那么就无需使用try...catch块来捕获该异常了。

        使用throws声明抛出异常时有一个限制，就是方法重写时“两下”中的一条规则：子类方法声明抛出的异常类型应该是父类方法声明抛出的异常类型的子类或相同，子类方法声明抛出的异常不允许比父类方法声明抛出的异常多。（即设置了上限）

使用Checked异常至少存在如下两大不便之处：

• 对于程序中的Checked异常，Java要求必须显示捕获并处理该异常，或者显示声明抛出该异常，这增加了编程复杂度。

• 如果在方法中显示声明抛出Checked异常，将会导致方法签名与异常耦合，如果该方法是重写父类的方法，则该方法抛出的异常还会受到被重写方法所抛出异常的限制。

         在大部分时候推荐使用Runtime异常，而不使用Checked异常，尤其当程序需要自行抛出异常时，使用Runtime异常将更加简洁。

         当使用Runtime异常时，程序无需在方法中声明抛出Checked异常，一旦发生了自定义错误，程序只管抛出Runtime异常即可。对于Runtime异常，Java编译器不要求必须进行异常捕获处理或者抛出声明，由程序员自行决定。

         使用Runtime异常省事，但Checked异常也有其优势，Checked异常能在编译时提醒程序员代码可能存在的问题，提醒程序员必须注意处理该异常，或者声明该异常有方法的调用者来处理，从而避免程序员因为粗心而忘记处理该异常的错误。

2.4 使用throw抛出异常

       当程序出现错误时，系统会自动抛出异常，除此之外，Java也允许程序自行抛出异常，自行抛出异常使用throw语句来完成。

2.5 自定义异常类

       用户自定义异常都应该继承Exception基类，如果希望自定义Runtime异常，则应该继承RuntimeException基类。定义异常类时通常需要提供两个构造器：一个是无参数的构造器；另一个是带一个字符串参数的构造器，这个字符串将作为该异常对象的描述信息（即异常对象的getMessage()方法的返回值）。

package AuctionException;

// 自定义异常都要继承Exception基类，如果希望自定义Runtime异常，则应该继承RuntimeException基类。
// 自定义异常类需要提供两个构造器：一个是无参数的构造器；另一个是带一个字符串参数的构造器，这个字符串作为
// 该异常对象的描述信息(即异常对象的getMessage()方法的返回值)
public class AuctionException extends Exception{
   
   //1、无参数的构造器
   public AuctionException(){
   }
   //2、带一个字符串参数的构造器
   public AuctionException(String msg){
      // 通过super调用父类的构造器
      super(msg);
   }
}

2.6 catch和throw同时使用

       在实际应用中，当一个异常出现时，单靠某个方法无法完全处理该异常，必须由几个方法协作才可以完全处理该异常。也就是说，在异常出现的当前方法中，程序只对异常进行部分处理，还有些处理需要在该方法的调用者中才能完成，所以应该再次抛出异常，让该方法的调用者也能捕获到异常。

         为了实现这种通过多个方法协作处理同一个异常的情形，可以在catch块中结合throw语句来完成。

         这种catch和throw结合使用使用的情况在大型企业级应用中非常常用，企业级应用对异常的处理通常分成两个部分：一是后台需要通过日志来记录异常发生的详细情况；二是应用还需要根据异常向应用使用者传达某种提示。

package CatchAndThrow;

import AuctionException.AuctionException;

public class CatchAndThrow {
   
   private double initPrice = 30.0;
   
   // 因为该方法中显示抛出了AuctionException异常
   // 所以此处需要声明抛出AuctionException异常
   public void bid(String bidPrice) throws AuctionException{
      double d = 0.0;
      try {
         d = Double.parseDouble(bidPrice);
      } catch (Exception e){
         
         // 此处完成本方法中可以对异常执行的修复处理
         // 此处仅仅是控制台打印异常的跟踪栈信息
         e.printStackTrace();
         
         // 再次抛出自定义异常
         throw new AuctionException("竞拍价必须是数值，不能包含其他字符");
      }
      
      if (initPrice > d){
         throw new AuctionException("竞拍价比起拍价低，不允许竞拍");
      }
      
      initPrice = d;
   }
   
   public static void main(String[] args){
      
      CatchAndThrow catchAndThrow = new CatchAndThrow();
      try{
         catchAndThrow.bid("df");
      } catch (AuctionException ae){
         // 再次捕获到bid()方法中的异常，并对该异常进行处理，此处是将异常的详细描述信息输出到标准错误(err)输出
         System.err.println(ae.getMessage());
      }
   }
}

2.7 异常跟踪栈

       异常对象的printStackTrace()方法用于打印异常的跟踪栈信息，根据printStackTrace()方法的输出结果，开发者可以找到异常的源头，并跟踪到异常一路触发的过程。

3、常见问题

3.1 为什么在finally块中不能访问try块中声明的变量？

答：try块里声明的变量是代码块内局部变量，它只在try块内有效，在catch块及finally块中不能访问该变量。

3.2 为什么最好不要使用catch all语句？

答：所谓catch all语句指的是一种异常捕获模块，它可以处理程序发生的所有可能异常。例如使用Exception或者Throwable类捕获所有异常，虽然这种方式能够处理异常，但是它不能精确描述引发异常的原因，我们很难进行准确的排查。

3.3 有没有关于注解方式的异常处理？

答：有的，比如spring有基于注解的全局异常处理方式（使用@ExceptionHandler）

4、参考文献

摘自《疯狂Java讲义 》第三版，文中代码模仿书中例子所敲。

今天的分享就到这了，希望大家多多指正，互相学习~

相关推荐：

java异常（Exception）处理机制示例代码分享

简单介绍Java的异常和架构

위 내용은 왜 예외 처리를 하는가? Java 예외 처리 메커니즘에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!