简体中文（ZH-CN）English（EN）繁体中文（ZH-TW）日本語（JA）한국어（KO）Melayu（MS）Français（FR）Deutsch（DE）
首頁
文章
問答
課程
專題
下載
遊戲
詞典
最近更新

首頁  >  文章  >  Java  >  全面理解java中的異常處理機制

全面理解java中的異常處理機制

高洛峰
高洛峰原創
2017-01-05 14:55:241220瀏覽

一、java異常總結：

異常就是程式運作時出現不正常運作情況

1.異常由來：

透過java的類別的形式對現實事物中問題的描述，並封住成了物件

透過java的類別的形式對現實事物中問題的描述，並封住成了物件

其實就是java對不正常情況描述後的對象體現

2.對於問題的劃分有兩種：一種是嚴重的問題，一種是非嚴重的問題

對於嚴重的，java透過Error類來描述

對於Error一般不編寫針對性的程式碼對其進行處理

對於非嚴重的，java透過Exception類來描述

對於Exception可以使用針對性的處理方式進行處理

3.角標越界異常，空指標異常…

4.無論Error或Exception都有一些共通點的內容。

例如：不正常狀況的消息，引發原因等。

Throwable //父類別（下面兩個類別相同的共性抽取出來的）

|--Error

|--Excption //兩個子類別（裡面定義了許多問題（異常出現）） /*父親類別名稱作為子類別後綴名稱*/

實例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");
  }
}

運作結果：

Exception in thread "main" java.lang.ArithmeticException: / by zero

at Demo.div( :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];
  }
}

運作結果：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

at ExceptionDemo.OutOfMemoryError: Java heap space

at ExceptionDemo.

java.lang.OutOfMemoryError：代表記憶體溢位異常

二、異常的處理：

對於異常的處理，java提供了特有的語句進行處理

格式

try需要偵測到的字㟎;　

}

catch

{

　　處理異常的程式碼；（處理方式）

}

㟎fin

實例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的處理語句後，問題就被處理完了，結束語句，輸出over

實例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 zerocom Demo.div(ExceptionDemo.java:5)

at ExceptionDemo.main(ExceptionDemo.java:17)

over

從執行結果分析，其實jprint異常處理機制就是在呼叫預設值異常處理機制就是在呼叫方式。


實例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");    
  }
}

運行結果：
未報告的異常錯誤Exception; 必須對其進行捕獲或聲明以

便拋出

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

建議：

建立在catch ().

也不要簡單就書寫一條輸出語句

因為使用者看不懂，最好保存到文件中，定時發給我們開發者去查看。

實例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中異步多執行緒超時導致的服務異常

相關文章

看更多