JAVA 예외 및 예외 처리에 대한 자세한 설명

1. 예외 소개

이상 현상이란 무엇인가요?

예외란 표준과 다른 것, 정상적인 상황과 다른 것, 잘못된 것입니다. Java에서는 현재 메서드나 범위를 차단하는 상황을 예외라고 합니다.

Java의 예외 시스템이란 무엇인가요? (권장: java 비디오 튜토리얼)

1. Java의 모든 비정상적인 클래스는 Throwable 클래스에서 상속됩니다. Throwable에는 주로 두 가지 주요 범주가 포함됩니다. 하나는 Error 클래스이고 다른 하나는

2입니다. Error 클래스에는 오류가 발생하면 프로그램이 완전히 중단됩니다. , 프로그램 종료자로 알려져 있음

3. 일반적으로 "예외"라고 하는 예외 클래스입니다. 주로 코딩, 환경, 사용자 조작 입력에 관한 문제를 말합니다. 예외에는 주로 확인되지 않은 예외(RuntimeException)와 확인된 예외(일부 다른 예외)가 있습니다

4. 사실, 여기에 나열되지 않은 다른 예외도 많이 있습니다: 널 포인터 예외, 배열 첨자 범위를 벗어난 예외, 유형 변환 예외, 산술 예외. RuntimeException 예외는 자동으로 발생하고 Java 가상 머신에 의해 자동으로 캡처됩니다(예외 캡처 문을 작성하지 않더라도 런타임 중에 오류가 발생합니다!!). 문제를 해결하고 코드를 개선해야 합니다.

5. 예외가 발생하는지 확인하세요. 파일이 존재하지 않거나 연결 오류가 있는 등 다양한 이유가 있습니다. "형제" RuntimeException과 달리 이 예외의 경우 예외를 처리하기 위해 코드에 캡처 문을 수동으로 추가해야 합니다. 이는 Java 예외 문을 학습할 때 다루는 주요 예외 개체이기도 합니다.

2. try-catch-finally 문

(1) try 블록: try에서 예외가 발견되면 프로그램 제어권이 해당 예외에 넘겨집니다. catch 블록의 핸들러.

[try 문 블록은 독립적으로 존재할 수 없으며 catch 또는 finally 블록과 같은 위치에 있어야 함]

(2) Catch 블록: 어떻게 처리하나요? 예를 들어 경고 발행(프롬프트, 구성 확인, 네트워크 연결 확인, 오류 로그 등) catch 블록을 실행한 후 프로그램은 catch 블록에서 벗어나 다음 코드를 계속 실행합니다.

【Catch 블록 작성에 대한 참고 사항: 여러 catch 블록으로 처리되는 예외 클래스는 먼저 하위 클래스를 포착한 다음 상위 클래스를 포착하는 방식으로 처리되어야 합니다. 예외는 [근처에서](위에서 아래로) 처리되기 때문입니다. 】

(3) finally: 최종적으로 실행되는 코드는 리소스를 닫고 해제하는 데 사용됩니다.

구문 형식은 다음과 같습니다:

try{
//一些会抛出的异常
}catch（Exception e）{
//第一个catch
//处理该异常的代码块
}catch（Exception e）{
//第二个catch，可以有多个catch
//处理该异常的代码块
}finally{
//最终要执行的代码
}

예외가 발생하면 프로그램은 실행을 종료하고 예외 처리기(알림 표시 또는 로그 기록 등)로 넘겨지며, 예외 코드 블록 외부의 코드는 정상적으로 실행합니다. try는 다양한 유형의 예외를 발생시키며, 여러 catch 블록은 여러 오류를 캡처합니다.

여러 예외 처리 코드 블록 순서 문제: 먼저 하위 클래스, 그 다음 상위 클래스(순서가 올바르지 않으면 컴파일러에서 오류 메시지 표시), finally 문 블록이 최종적으로 실행될 코드를 처리합니다.

다음에는 예제를 사용하여 try-catch 문을 통합해 보겠습니다~

먼저 예제를 살펴보세요:

package com.hysum.test;

public class TryCatchTest {
    /**
     * divider:除数
     * result:结果
     * try-catch捕获while循环
     * 每次循环，divider减一，result=result+100/divider
     * 如果：捕获异常，打印输出“异常抛出了”，返回-1
     * 否则：返回result
     * @return
     */
    public int test1(){
        int divider=10;
        int result=100;
        try{
            while(divider>-1){
                divider--;
                result=result+100/divider;
            }
            return result;
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("异常抛出了！！");
            return -1;
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TryCatchTest t1=new TryCatchTest();
        System.out.println("test1方法执行完毕！result的值为："+t1.test1());
    }
    
}

실행 결과:

결과 분석: 결과에서 빨간색 단어가 던진 예외 정보는 e입니다. 이는 printStackTrace()에 의해 출력됩니다. 여기서 발생하는 예외 유형은 산술 예외이고 그 뒤에 이유가 0으로 발생함을 보여줍니다(0으로 인한 산술 예외). 이 예외를 발생시킨 코드입니다.

final 문의 실행 상태를 테스트하려면 위 예제에 test2() 메서드를 추가하세요.

/**
     * divider:除数
     * result:结果
     * try-catch捕获while循环
     * 每次循环，divider减一，result=result+100/divider
     * 如果：捕获异常，打印输出“异常抛出了”，返回result=999
     * 否则：返回result
     * finally：打印输出“这是finally，哈哈哈！！”同时打印输出result
     * @return
     */
    public int test2(){
        int divider=10;
        int result=100;
        try{
            while(divider>-1){
                divider--;
                result=result+100/divider;
            }
            return result;
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("异常抛出了！！");
            return result=999;
        }finally{
            System.out.println("这是finally，哈哈哈！！");
            System.out.println("result的值为："+result);
        }        
    }         
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        TryCatchTest t1=new TryCatchTest();
        //System.out.println("test1方法执行完毕！result的值为："+t1.test1());
        t1.test2();
        System.out.println("test2方法执行完毕！");
    }

실행 결과:

결과 분석: finally 문의 블록이 try 블록과 catch 블록 문이 실행된 후 마지막으로 실행된 블록입니다. finally 는 return 뒤의 표현식을 계산한 후 실행됩니다(이때 계산된 값은 반환되지 않고 반환될 값이 먼저 저장됩니다. finally 안의 코드가 무엇이든 반환값은 변하지 않습니다. 는 여전히 그렇습니다. 이전에 저장된 값)이므로 최종 실행 전에 함수 반환 값이 결정됩니다.

这里有个有趣的问题，如果把上述中的test2方法中的finally语句块中加上return，编译器就会提示警告：finally block does not complete normally

public int test2(){
        int divider=10;
        int result=100;
        try{
            while(divider>-1){
                divider--;
                result=result+100/divider;
            }
            return result;
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("异常抛出了！！");
            return result=999;
        }finally{
            System.out.println("这是finally，哈哈哈！！");
            System.out.println("result的值为："+result);
            return result;//编译器警告
        }
        
    }

分析问题: finally块中的return语句可能会覆盖try块、catch块中的return语句;如果finally块中包含了return语句，即使前面的catch块重新抛出了异常，则调用该方法的语句也不会获得catch块重新抛出的异常，而是会得到finally块的返回值，并且不会捕获异常。

解决问题：面对上述情况，其实更合理的做法是，既不在try block内部中使用return语句，也不在finally内部使用 return语句，而应该在 finally 语句之后使用return来表示函数的结束和返回。如：

总结：

1、不管有木有出现异常或者try和catch中有返回值return，finally块中代码都会执行；

2、finally中最好不要包含return，否则程序会提前退出，返回会覆盖try或catch中保存的返回值。

3、 e.printStackTrace()可以输出异常信息。

4、 return值为-1为抛出异常的习惯写法。

5、 如果方法中try,catch,finally中没有返回语句，则会调用这三个语句块之外的return结果。

6、 finally 在try中的return之后 在返回主调函数之前执行。

三、throw和throws关键字

java中的异常抛出通常使用throw和throws关键字来实现。

throw ----将产生的异常抛出，是抛出异常的一个动作。

一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。如：

语法：throw (异常对象)，如：

public static void main(String[] args) { 
    String s = "abc"; 
    if(s.equals("abc")) { 
      throw new NumberFormatException(); 
    } else { 
      System.out.println(s); 
    } 
    //function(); 
}

运行结果：

Exception in thread "main" java.lang.NumberFormatException
at test.ExceptionTest.main(ExceptionTest.java:67)

throws----声明将要抛出何种类型的异常（声明）。

语法格式：

 public void 方法名（参数列表）
    throws 异常列表{
 //调用会抛出异常的方法或者：
 throw new Exception（）；
 }

当某个方法可能会抛出某种异常时用于throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理。如：

public static void function() throws NumberFormatException{ 
    String s = "abc"; 
    System.out.println(Double.parseDouble(s)); 
  } 
    
  public static void main(String[] args) { 
    try { 
      function(); 
    } catch (NumberFormatException e) { 
      System.err.println("非数据类型不能转换。"); 
      //e.printStackTrace(); 
    } 
}

throw与throws的比较

1、throws出现在方法函数头；而throw出现在函数体。

2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。

3、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

来看个例子：

throws e1,e2,e3只是告诉程序这个方法可能会抛出这些异常，方法的调用者可能要处理这些异常，而这些异常e1，e2，e3可能是该函数体产生的。

throw则是明确了这个地方要抛出这个异常。如：

void doA(int a) throws (Exception1,Exception2,Exception3){
      try{
         ......
 
      }catch(Exception1 e){
       throw e;
      }catch(Exception2 e){
       System.out.println("出错了！");
      }
      if(a!=b)
       throw new Exception3("自定义异常");
}

分析:

1、代码块中可能会产生3个异常，(Exception1,Exception2,Exception3)。

2、如果产生Exception1异常，则捕获之后再抛出，由该方法的调用者去处理。

3、如果产生Exception2异常，则该方法自己处理了（即System.out.println("出错了！");）。所以该方法就不会再向外抛出Exception2异常了，void doA() throws Exception1,Exception3 里面的Exception2也就不用写了。因为已经用try-catch语句捕获并处理了。

4、Exception3异常是该方法的某段逻辑出错，程序员自己做了处理，在该段逻辑错误的情况下抛出异常Exception3，则该方法的调用者也要处理此异常。这里用到了自定义异常，该异常下面会由解释。

使用throw和throws关键字需要注意以下几点：

1.throws的异常列表可以是抛出一条异常，也可以是抛出多条异常，每个类型的异常中间用逗号隔开

2.方法体中调用会抛出异常的方法或者是先抛出一个异常：用throw new Exception（） throw写在方法体里，表示“抛出异常”这个动作。

3.如果某个方法调用了抛出异常的方法，那么必须添加try catch语句去尝试捕获这种异常， 或者添加声明，将异常抛出给更上一层的调用者进行处理

自定义异常

为什么要使用自定义异常，有什么好处？

1、我们在工作的时候，项目是分模块或者分功能开发的 ,基本不会你一个人开发一整个项目，使用自定义异常类就统一了对外异常展示的方式。

2、有时候我们遇到某些校验或者问题时，需要直接结束掉当前的请求，这时便可以通过抛出自定义异常来结束，如果你项目中使用了SpringMVC比较新的版本的话有控制器增强，可以通过@ControllerAdvice注解写一个控制器增强类来拦截自定义的异常并响应给前端相应的信息。

3、自定义异常可以在我们项目中某些特殊的业务逻辑时抛出异常，比如"中性".equals(sex)，性别等于中性时我们要抛出异常，而Java是不会有这种异常的。系统中有些错误是符合Java语法的，但不符合我们项目的业务逻辑。

4、使用自定义异常继承相关的异常来抛出处理后的异常信息可以隐藏底层的异常，这样更安全，异常信息也更加的直观。自定义异常可以抛出我们自己想要抛出的信息，可以通过抛出的信息区分异常发生的位置，根据异常名我们就可以知道哪里有异常，根据异常提示信息进行程序修改。比如空指针异常NullPointException，我们可以抛出信息为“xxx为空”定位异常位置，而不用输出堆栈信息。

说完了为什么要使用自定义异常，有什么好处，我们再来看看自定义异常的毛病：

我们不可能期待JVM（Java虚拟机）自动抛出一个自定义异常，也不能够期待JVM会自动处理一个自定义异常。发现异常、抛出异常以及处理异常的工作必须靠编程人员在代码中利用异常处理机制自己完成。这样就相应的增加了一些开发成本和工作量，所以项目没必要的话，也不一定非得要用上自定义异常，要能够自己去权衡。

最后，我们来看看怎么使用自定义异常：

在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

所有异常都必须是 Throwable 的子类。

如果希望写一个检查性异常类，则需要继承 Exception 类。

如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

可以像下面这样定义自己的异常类：

class MyException extends Exception{ }

我们来看一个实例：

package com.hysum.test;
public class MyException extends Exception {
     /**
     * 错误编码
     */
    private String errorCode;   
    public MyException(){}
    
    /**
     * 构造一个基本异常.
     *
     * @param message
     *        信息描述
     */
    public MyException(String message)
    {
        super(message);
    }
    public String getErrorCode() {
        return errorCode;
    }
    public void setErrorCode(String errorCode) {
        this.errorCode = errorCode;
    }   
}

使用自定义异常抛出异常信息：

package com.hysum.test;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] sexs = {"男性","女性","中性"};
                  for(int i = 0; i < sexs.length; i++){
                      if("中性".equals(sexs[i])){
                          try {
                            throw new MyException("不存在中性的人！");
                        } catch (MyException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                     }else{
                         System.out.println(sexs[i]);
                     }
                } 
    }

}

运行结果：

四、java中的异常链

异常需要封装，但是仅仅封装还是不够的，还需要传递异常。

异常链是一种面向对象编程技术，指将捕获的异常包装进一个新的异常中并重新抛出的异常处理方式。原异常被保存为新异常的一个属性（比如cause）。这样做的意义是一个方法应该抛出定义在相同的抽象层次上的异常，但不会丢弃更低层次的信息。

我可以这样理解异常链：

把捕获的异常包装成新的异常，在新异常里添加原始的异常，并将新异常抛出，它们就像是链式反应一样，一个导致（cause）另一个。这样在最后的顶层抛出的异常信息就包括了最底层的异常信息。

》场景

比如我们的JEE项目一般都又三层：持久层、逻辑层、展现层，持久层负责与数据库交互，逻辑层负责业务逻辑的实现，展现层负责UI数据的处理。

有这样一个模块：用户第一次访问的时候，需要持久层从user.xml中读取数据，如果该文件不存在则提示用户创建之。

那问题就来了：如果我们直接把持久层的异常FileNotFoundException抛弃掉，逻辑层根本无从得知发生任何事情，也就不能为展现层提供一个友好的处理结果，最终倒霉的就是展现层：没有办法提供异常信息，只能告诉用户“出错了，我也不知道出了什么错了”—毫无友好性而言。

正确的做法是先封装，然后传递，过程如下：

1、把FileNotFoundException封装为MyException。

2、抛出到逻辑层，逻辑层根据异常代码（或者自定义的异常类型）确定后续处理逻辑，然后抛出到展现层。

3、展现层自行确定展现什么，如果管理员则可以展现低层级的异常，如果是普通用户则展示封装后的异常。

示例

package com.hysum.test;

public class Main {
    public void test1() throws RuntimeException{
        String[] sexs = {"男性","女性","中性"};
        for(int i = 0; i < sexs.length; i++){
            if("中性".equals(sexs[i])){
                try {
                    throw new MyException("不存在中性的人！");
                } catch (MyException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                    RuntimeException rte=new RuntimeException(e);//包装成RuntimeException异常
                    //rte.initCause(e);
                    throw rte;//抛出包装后的新的异常
                }
           }else{
               System.out.println(sexs[i]);
           }
      } 
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Main m =new Main();
        
        try{
        m.test1();
        }catch (Exception e){
            e.printStackTrace();
            e.getCause();//获得原始异常
        }
        
    }

}

运行结果：

결과 분석: 콘솔이 먼저 e.getCause()에 의해 출력된 원래 예외를 출력한 다음 e.printStackTrace()를 출력하는 것을 볼 수 있습니다. 여기서 Caused by: 원래 예외 및 e.getCause( ) 출력은 일관됩니다. 이것은 비정상적인 사슬을 형성합니다.

initCause()의 기능은 원래 예외를 래핑하는 것입니다. 하위 레이어에서 어떤 예외가 발생했는지 알고 싶을 때 getCause()를 호출하면 원래 예외를 얻을 수 있습니다.

Recommendations

예외는 캡슐화되어 전달되어야 합니다. 시스템을 개발할 때 예외를 "삼키거나" 예외를 "알몸"으로 던져서는 안 됩니다. 예외 체인은 목적에 맞게 더 강력하고 친숙합니다.

5. 결론

Java의 예외 처리에 대한 지식은 복잡하고 이해하기 다소 어렵습니다. Java 예외 처리를 사용할 때 다음과 같은 좋은 코딩 습관을 요약했습니다.

1. 런타임을 처리할 때 예외, try-catch 처리를 합리적으로 방지하고 지원하기 위한 논리 사용

2. 여러 개의 catch 블록 뒤에 catch(Exception)를 추가하여 놓칠 수 있는 예외를 처리할 수 있습니다

3. 잠재적인 예외를 처리하기 위해 try-catch를 사용하여 코드를 추가할 수도 있습니다. 4. 예외를 최대한 처리하도록 노력하세요. printStackTrace()를 호출하여 print

5를 호출하는 것만 기억하세요. 유형을 결정합니다

6. 점유된 리소스를 해제하기 위해 finally 문 블록을 추가해 보세요.

더 많은 Java 지식을 보려면

java 기본 튜토리얼

칼럼을 주목하세요.

위 내용은 JAVA 예외 및 예외 처리에 대한 자세한 설명의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!