Java の例外処理メカニズムについての包括的な理解
- 高洛峰オリジナル
- 2017-01-05 14:55:241234ブラウズ
1. Java 例外の概要:
例外は、プログラム実行時の異常な動作条件です。
現実の問題を Java クラスの形式で記述し、オブジェクトに封入します。実際、これは Java によって記述された異常な状況のオブジェクト表現です
2 問題には 2 つのタイプがあります。1 つは深刻な問題、もう 1 つは深刻でない問題です
深刻な問題の場合、Java は Error クラスを使用して、説明します
一般に、エラーを処理するためにターゲットを絞ったコードは作成されません
重大でないエラーについては、Java は Exception クラスを使用してエラーを記述します
例外はターゲットを絞った処理メソッドを使用して処理できます
一般的な例外は次のとおりです: array Index out- of-bounds 例外、null ポインタ例外...
4. Error と Exception には共通する内容がいくつかあります。
例: 異常事態、原因などに関するニュース。
Throwable //親クラス（次の2つのクラスの同じ共通機能から抽出）
|--Error
|--Exception //2つのサブクラス（多くの問題（例外）が定義されています） /*Parentクラス名はサブクラスのサフィックスとして使用されます */
例 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(ExceptionDemo. java :5)
at ExceptionDemo.main(ExceptionDemo.java:15)例 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
{
例外を処理するコード (処理メソッド)
}
finally
{
必ず実行されるコード (処理メソッド)
}
例 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];*/
}
}動作結果:
Incorrect divisor
/ by zerojava.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zero
at Demo.div (ExceptionDemo.java:5)
実行結果の分析から、実際、jvm のデフォルトの例外処理メカニズムは printStackTrace を呼び出すことです。方法。
例 3: スローされた例外を処理する 2 つの方法
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: エラー: 未報告例外エラー 例外をキャッチするか、スローされるように宣言する必要があります
^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ブロックが下に配置されます。
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提案:
キャッチ処理を確立する場合、具体的な処理メソッドをキャッチ内に定義する必要があります
単純に定義しないでください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
オーバー从上面的结果，可以看出
在本程序中，对于除数是-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中文网！