찾다

집  >  기사  >  Java  >  Java의 예외 처리 메커니즘에 대한 포괄적인 이해

Java의 예외 처리 메커니즘에 대한 포괄적인 이해

高洛峰
高洛峰원래의
2017-01-05 14:55:241240검색

1. 자바 예외 개요:

예외는 프로그램 실행 시 비정상적인 동작 조건입니다.

1. 예외의 발생 원인:

형태에 따른 현실 반영 Java 클래스의 문제에 대한 설명과 객체

는 실제로 Java

에서 설명하는 비정상적인 상황의 객체 표현입니다. 2. 문제를 분류하는 방법에는 두 가지가 있습니다. 하나는 심각합니다. 문제는 심각하지 않은 문제입니다

심각한 문제의 경우 Java는 Error 클래스를 사용하여 이를 설명합니다.

오류의 경우 일반적으로 이를 처리하기 위한 대상 코드가 작성되지 않습니다

심각하지 않은 경우, Java는 Exception 클래스를 사용하여 설명합니다.

예외는 지정된 방식으로 처리될 수 있습니다.

3. 일반적인 예외에는 배열 인덱스 범위를 벗어난 예외, 널 포인터 예외가 포함됩니다. ...

4. Error와 Exception에는 공통된 내용이 있습니다.

예: 비정상적인 상황, 원인 등에 대한 뉴스

Throwable //상위 클래스(다음 두 클래스의 동일한 공통성에서 추출)

|--Error

|--Excption //두 개의 하위 클래스(Many 내부) 문제가 정의됨(예외 발생)) /*상위 클래스 이름은 하위 클래스의 접미사 이름으로 사용됩니다*/

인스턴스 1: 예외 예 

class Demo 
{
  public int div(int x,int y)
  {
    return x/y;
  }
}
 
 
class ExceptionDemo
{
  public static void main(String args[])
  {
    Demo d=new Demo();
    int x=d.div(4,0);  //0作为除数
    System.out.println("x="+x);
    System.out.println("over");
  }
}

실행 결과:

스레드 "main"의 예외 java.lang.ArithmeticException: / by zero

at Demo.div(ExceptionDemo.java:5)

at ExceptionDemo.main( ExceptionDemo.java :15)

위의 결과를 보면 5행과 15행에서 ​​예외가 발생한 것을 알 수 있습니다. 이는 나누기 메커니즘 때문에 제수는 0이 될 수 없습니다. , 실행 시 예외가 발생합니다.

예 2: 예외 발생 예 2, 메모리 오버플로

class Demo
{
  public int div(int x,int y)
  {
    return x/y;
  }
}
 
 
class ExceptionDemo
{
  public static void main(String args[])
  {
    /*Demo d=new Demo();
    int x=d.div(4,0);
    System.out.println("x="+x);
    System.out.println("over");
    */
    byte[] arr=new byte[1024*1024*1000];
  }
}

실행 결과:

스레드 "main" java.lang에서 예외가 발생했습니다. OutOfMemoryError: Java 힙 공간
at ExceptionDemo.main(ExceptionDemo.java:19)

java.lang.OutOfMemoryError: 메모리 오버플로 예외를 나타냅니다

2. 예외 처리:

예외 처리를 위해 Java는

Format

try

{

감지해야 하는 코드

}

catch

{

　 예외 처리 코드(처리 방법)

}

드디어

{

반드시 실행될 코드(처리 방법)

}

예시 1: try catch 문 시연

class Demo
{
  public int div(int x,int y)
  {
    return x/y;
  }
}
 
 
class ExceptionDemo
{
  public static void main(String args[])
  {
    Demo d=new Demo();
    try
    {
      int x=d.div(4,0);
      System.out.println("x="+x);
    }
    catch(Exception e)
    {
      System.out.println("除数有误");
    }
     
    System.out.println("over");
     
    /*byte[] arr=new byte[1024*1024*1000];*/
  }
}
실행 중 결과:

제수가 틀렸다

over

결과 분석: 프로그램 실행 시 나누기 문: return x/y를 실행하면 생성된다. 예외 개체 new AritchmeticException(), try 문은 catch 문의 매개 변수로 이 개체를 캡처합니다.

Exception e =new AritchmeticException()

catch 처리 문을 실행한 후 문제는 다음과 같습니다. 처리 후 명령문을 종료하고

예제 2: 캡처된 예외 객체에 대해 일반적인 메서드 작업 수행(상위 클래스 Throwable의 메서드)

String getMessage(); 예외 정보

toString() //예외 이름 반환: 예외 정보

printStackTrace() //예외 이름, 예외 정보, 예외 위치 출력 

class Demo
{
  public int div(int x,int y)
  {
    return x/y;
  }
}
 
 
class ExceptionDemo
{
  public static void main(String args[])
  {
    Demo d=new Demo();
    try
    {
      int x=d.div(4,0);
      System.out.println("x="+x);
    }
    catch(Exception e)
    {
      System.out.println("除数有误");
      //获得异常信息
      System.out.println(e.getMessage());
      //获得异常信息，异常名称
      System.out.println(e.toString());
      //输出异常名称，异常信息，异常出现的位置
      e.printStackTrace();         
    }
     
    System.out.println("over");
     
    /*byte[] arr=new byte[1024*1024*1000];*/
  }
}
실행 결과 :

잘못된 제수


/ by zero

java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero

Demo.div(ExceptionDemo.java:5)


at ExceptionDemo.main(ExceptionDemo.java:17)


이상

실행 결과를 분석할 때 실제로 jvm의 기본 예외 처리 메커니즘은 printStackTrace 메서드를 호출하는 것입니다.

예제 3: 발생한 예외를 처리하는 두 가지 방법

1. 처리를 위해 jvm 가상 머신에 던집니다.

2. 발생한 예외를 직접 처리합니다

class Demo
{
  public int div(int x,int y)throws Exception    /*有可能出现异常的地方抛出异常*/
  {
    return x/y;
  }
}
 
 
class ExceptionDemo
{
  public static void main(String args[])
  {
    Demo d=new Demo();  
    int x=d.div(4,0);
    System.out.println("x="+x);    
    System.out.println("over");    
  }
}
실행 결과:

ExceptionDemo.java:15: 오류: 보고되지 않은 예외 오류 예외;

throw
int x=d .div(4,0)를 포착하거나 선언해야 합니다. );
^

오류 1개

결과 분석: 발생 가능한 예외 처리가 없기 때문입니다

처리 방법 1: 계속 예외 발생 및 jvm 가상 머신이 스스로 처리하도록 합니다 

class Demo
{
  public int div(int x,int y)throws Exception    /*有可能出现异常的地方抛出异常*/
  {
    return x/y;
  }
}
 
 
class ExceptionDemo
{
  public static void main(String args[])   throws Exception  /*继续抛出异常，给虚拟机*/
  {
    Demo d=new Demo();  
    int x=d.div(4,0);
    System.out.println("x="+x);    
    System.out.println("over");    
  }
}
처리 방법 2: 예외를 직접 처리합니다 

class Demo
{
  public int div(int x,int y)throws Exception    /*有可能出现异常的地方抛出异常*/
  {
    return x/y;
  }
}
 
 
class ExceptionDemo
{
  public static void main(String args[])   
  {
    Demo d=new Demo();
    try                   //自己处理异常
    {
      int x=d.div(4,0);
      System.out.println("x="+x);
    }
    catch(Exception e)
    {
      System.out.println("除数有误");
      //获得异常信息，异常名称
      System.out.println(e.toString());  
      System.out.println("over");  
    }
  }
}
요약: 함수의

위에서 선언한 예외 . 보안을 강화하려면 콜아웃이 처리를 처리하도록 하고 컴파일 실패는 처리하지 않도록 하십시오.

예시 4: 다중 예외 처리

1. 예외를 선언할 때 처리가 더 구체적일 수 있도록 좀 더 구체적인 예외를 선언하는 것이 좋습니다

2 . 여러 catch 블록에 해당하는 여러 예외를 선언합니다. 중복된 catch 블록을 정의하지 마세요.

여러 catch 블록의 예외 간에 상속 관계가 있는 경우 상위 클래스 예외 catch 블록이 아래에 배치됩니다. 

class Demo
{
  public int div(int x,int y)throws ArithmeticException,ArrayIndexOutOfBoundsException    
  {
    int arr[]=new int [x];
    System.out.println(arr[4]);
    return x/y;
  }
}
 
 
class ExceptionDemo
{
  public static void main(String args[])   
  {
    Demo d=new Demo();
    try                  
    {
      int x=d.div(4,0);
      System.out.println("x="+x);
    }
    catch(ArithmeticException e)          /*除法法则异常对象接收，第一个执行*/
    {
      System.out.println("除数有误");
      //获得异常信息，异常名称
      System.out.println(e.toString());  
      System.out.println("over");  
    }
    catch(ArrayIndexOutOfBoundsException e)    /*数据越界的对象接收，第二个执行*/
    {
      System.out.println("数组越界了");
      //输出异常信息
      System.out.println(e.toString());
    }
    catch(Exception e)               /*父类Exception接收，最后执行，建议不要写这个，让程序终止*/ /*用到了多态*/
    {
      System.out.println(e.toString());
    }
  }
}
실행 결과:

배열이 범위를 벗어났습니다

java.lang.ArrayIndexOutOfBoundsException: 4

제안:

Build in catch를 처리할 때 catch에 구체적인 처리 방법을 정의해야 합니다

단순히 e.printStackTrace()를 정의하지 마세요.

단순히 출력문을 작성하지 마세요

왜냐하면 사용자가 이해하기 어려울 경우에는 파일로 저장한 후 정기적으로 개발자에게 보내 검토를 받는 것이 가장 좋습니다.

예제 5: 사용자 정의 예외

우리가 사용하는 예외가 모두 Java에 캡슐화되어 있다는 사실을 알고 계셨나요?

그러나 실제 개발에서는 우리 프로그램이 Java에 나타나는 예외입니다.

이때 직접 정의해야 합니다

위 코드를 토대로 제수는 음수가 될 수 없다고 정의했습니다.

class Demo
{
  public int div(int x,int y)throws FuShuException  /*抛出异常*/  
  {
    if(y<0)
    {
      throw new FuShuException("分母出现负数了------/bu FuShu",y);  /*自己手动抛出异常的对象*/
    }
    return x/y;
  }
}
class FuShuException extends Exception
{
  private int value;
  FuShuException(String m,int value)
  {
    super(m);                  /*给父类Exception的getMessage方法传递参数*/
    this.value=value;
  }  
  public int getValue()              /*自定义的方法，返回负数*/
  {
    return value;
  }
}
 
class ExceptionDemo
{
  public static void main(String args[])   
  {
    Demo d=new Demo();
    try                              
    {
      int x=d.div(4,-3);
      System.out.println("x="+x);
    }
    catch(FuShuException e)          /*捕获异常对象*/
    {
      System.out.println(e.getMessage()+e.getValue());
    }
    System.out.println("over");
  }
}
실행 결과:

분모가 음수입니다 ------/bu FuShu-3

over

从上面的结果，可以看出

在本程序中，对于除数是-3，也视为是错误的是无法进行运算的。

那么就需要对这个问题进行自定义的描述。

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。

要么在内部try catch处理。

要么在函数上声明让调用者处理。

一般情况在，函数内出现异常，函数上需要声明。

发现打印的结果中只有异常的名称，却没有异常的信息。

因为自定义的异常并未定义信息。

如何定义异常信息呢？

因为父类中已经把异常信息的操作都完成了。
所以子类只要在构造时，将异常信息传递给父类通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息。

自定义异常必须是自定义类继承Exception。

继承Exception原因：

异常体系有一个特点：因为异常类和异常对象都被抛出。

他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

只有这个体系中的类和对象才可以被throws和throw操作。

throws和throw的区别

throws使用在函数上。

throw使用在函数内。

throws后面跟的异常类。可以跟多个。用逗号隔开。

throw后跟的是异常对象。

实例6：Exception中有一个特殊的子类异常RuntimeException 运行时异常

如果在函数内容抛出该异常，函数上可以不声明，编译一样通过。

如果函数上声明了该异常，调用者可以不进行处理，编译一样通过

之所以不用在函数声明，是因为不需要让调用者处理

当该异常发生，希望程序停止，因为在运行时，出现了无法运行的情况，希望程序停止后

程序员对该代码进行修改。

class Demo
{
  public int div(int x,int y)throws FuShuException   /*抛不抛结果都一样*/
  {
    if(y<0)
    {
      throw new FuShuException("分母出现负数了------/bu FuShu",y);  
    }
    return x/y;
  }
}
class FuShuException extends RuntimeException     /*继承RuntimeException*/
{
  FuShuException(String m,int value)
  {
    super(m);                  
     
  }  
}
 
class ExceptionDemo
{
  public static void main(String args[])   
  {
    Demo d=new Demo();
    int x=d.div(4,-3);              /*运行到这会出现异常，编译没有问题*/
    System.out.println("x="+x);
    System.out.println("over");
  }
}

运行结果：

Exception in thread "main" FuShuException: 分母出现负数了------/bu FuShu
at Demo.div(ExceptionDemo.java:7)
at ExceptionDemo.main(ExceptionDemo.java:26)

从上面的结果可以看出：

自定义异常时：如果该异常的发生，无法在继续进行运算，
就让自定义异常继承RuntimeException。

对于异常分两种：

1，编译时被检测的异常。

2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)

以上这篇全面理解java中的异常处理机制就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持PHP中文网。

更多全面理解java中的异常处理机制相关文章请关注PHP中文网！

성명：
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
이전 기사：Java의 비동기 다중 스레드 시간 초과로 인해 발생하는 서비스 예외에 대한 간략한 설명다음 기사：Java의 비동기 다중 스레드 시간 초과로 인해 발생하는 서비스 예외에 대한 간략한 설명

관련 기사

더보기