1。はじめに
試してみてください...キャッチ…ついに誰もがよく知っている文であり、使いやすいと感じているので、論理的に理解しやすいようです。しかし、私が経験した「学習」は、私が想像したほど単純で従順ではないと個人的に言った。信じられない？次に、以下のコードを見てください、それが実行された後の結果はどうなりますか？回答を後方に見ないでください。また、実際の答えを見るためにコードを実行しても許可しません。あなたの答えが正しい場合は、この記事を読む時間を無駄にする必要はありません。
パッケージテスト; public class testexception {public testexception（）{} boolean testex（）throws exception {boolean ret = true; try {ret = testex1（）; } catch（Exception e）{System.out.println（ "testex、catch Exception"）; ret = false; eを投げる; }最後に{system.out.println（ "testex、finally; return value =" + ret）; Retを返します。 }} boolean testex1（）スロー例外{boolean ret = true; try {ret = testex2（）; if（！ret）{return false; } system.out.println（ "testex1、try of try"）; Retを返します。 } catch（Exception e）{System.out.println（ "testex1、catch Exception"）; ret = false; eを投げる; }最後に{system.out.println（ "testex1、finally; return value =" + ret）; Retを返します。 }} boolean testex2（）スロー例外{boolean ret = true; {int b = 12; int c; for（int i = 2; i> = -2; i--）{c = b / i; system.out.println（ "i =" + i）; } trueを返します。 } catch（Exception E）{System.out.println（ "testex2、catch Exception"）; ret = false; eを投げる; }最後に{system.out.println（ "testex2、finally; return value =" + ret）; Retを返します。 }} public static void main（string [] args）{testexception testexception1 = new testexception（）; try {testexception1.testex（）; } catch（Exception e）{e.printstacktrace（）; }}}あなたの答えは何ですか？以下の答えですか？
i = 2
i = 1
testex2、キャッチ例外
testex2、最後に; return値= false
testex1、キャッチ例外
testex1、最後に; return値= false
TESTEX、例外をキャッチします
最終的にtestex; return値= false
あなたの答えが本当に上記のとおりであるなら、あなたは間違っています。 ^_^、この記事を注意深く読むか、上記のコードを使用して、さまざまな状況に従って変更、実行、テストすることをお勧めします。最初に想像していたほど単純ではないものがたくさんあることがわかります。正解を公開します：
i = 2
i = 1
testex2、キャッチ例外
testex2、最後に; return値= false
testex1、最後に; return値= false
最終的にtestex; return値= false
注記：
最後に、ステートメントブロックが表示されないはずです。戻り値が表示されます。上記のRetRETは、関連するロジックを処理するための別のステートメントです。
2。Java例外
例外：ファイルが見つかっていない、ネットワーク接続の障害、違法パラメーターなど、予期せずに発生するさまざまな状況を指します。例外は、プログラムの実行中に発生し、通常の命令フローを妨げるイベントです。 Javaは、APIのスロー可能なクラスの多くのサブクラスを通じてさまざまな例外を説明しています。したがって、Javaの例外は、オブジェクト、スロー可能なサブクラスのインスタンスであり、エンコードに表示されるエラー条件を説明します。条件が生成されると、エラーが例外がスローされます。
Java例外クラスの階層図：
図1 Java例外クラス階層図
Javaでは、すべての例外には共通の祖先があり、投げ可能（投げ可能）があります。 Throwableは、例外伝播メカニズムによってコード内のJavaアプリケーションを介して送信できる問題の共通性を指定します。
スロー可能： 2つの重要なサブクラスがあります。例外とエラーです。どちらもJava例外処理のための重要なサブクラスであり、それぞれに多数のサブクラスが含まれています。
エラー：プログラムが処理できないエラーは、アプリケーションの実行に深刻な問題を示しています。ほとんどのエラーは、コードライターが実行するアクションに関連していませんが、コードの実行時のJVM（Java仮想マシン）の問題を表します。たとえば、Java仮想マシンはエラー（Virtual MachineError）を実行し、JVMが操作を継続するために必要なメモリリソースがなくなったときにOutOfMemoryErrorが表示されます。これらの例外が発生すると、Java仮想マシン（JVM）は通常、スレッドを終了することを選択します。
これらのエラーは、仮想マシン自体のときに障害が発生し、仮想マシンがアプリケーションを実行しようとするときに発生することを示しています。適切に設計されたアプリケーションの場合、エラーが発生したとしても、それが引き起こす例外に基本的に対処しようとするべきではありません。 Javaでは、エラーはエラーのサブクラスによって説明されます。
例外：プログラム自体が処理できる例外。
例外クラスには、重要なサブクラス、RuntimeExceptionがあります。 RuntimeExceptionクラスとそのサブクラスは、「一般的なJVM操作」によって提起されたエラーを表します。たとえば、nullオブジェクト参照、ゼロ除数、または境界のない配列を使用しようとする場合、ランタイム例外（nullpointerexception、arithmeticexception）およびarrayindexoutofboundexceptionがそれぞれ上昇します。
注：例外とエラーの違い：例外はプログラム自体で処理できますが、エラーは処理できません。
一般に、Javaの例外（例外とエラーを含む）は、チェックされた例外と未確認の例外に分割されます。
例外を確認できます（コンパイラが処理する必要がある例外）：正しいプログラムが実行されているときに、発生するのは簡単で、妥当な耐性の例外です。チェック可能な例外は異常な状態ですが、その発生はある程度予測可能であり、そのような異常な状態が発生したら、何らかの方法で処理する必要があります。
RuntimeExceptionとそのサブクラスを除き、他の例外クラスとそのサブクラスはすべてチェック可能な例外です。この例外の特徴は、Javaコンパイラがそれをチェックすることです。つまり、プログラムでそのような例外が発生した場合、Try-Catchステートメントでキャッチするか、スロー条項でそれを投げること、そうしないとコンパイルが通過しません。
チェック不可の例外（コンパイラが強制処分を必要としない例外）：ランタイムの例外（RuntimeExceptionとそのサブクラス）およびエラー（エラー）を含む。
例外この例外は、ランタイムの例外と非runtime例外（コンピレーション例外）の2つのカテゴリに分けられます。これらの例外は、プログラムで可能な限り処理する必要があります。
ランタイムの例外：これらはすべて、nullpointerexception（null pointer例外）、indexoutofofboundsexception（サブスクリプトアウトバウンドの例外）など、すべてruntimeexceptionクラスとそのサブクラスの例外です。これらの例外は例外を確認しません。プログラムでそれらをキャプチャして処理することを選択できます。これらの例外は一般にプログラムロジックエラーによって引き起こされ、プログラムは論理的な観点からできる限りそのような例外を回避する必要があります。
ランタイム例外の特徴は、Javaコンパイラがそれをチェックしないことです。つまり、このような例外がプログラムで発生する可能性がある場合、たとえそれがTry-Catchステートメントでキャプチャされていなくても、スロー条項でスローされたとしても、コンパイルされて渡されます。
非runtime例外（コンピレーション例外）： runtimeexception以外の例外であり、タイプの観点から例外クラスとそのサブクラスに属します。プログラム構文の観点から見ると、それは処理する必要がある例外です。処理されていない場合、プログラムをコンパイルして合格することはできません。 IOException、sqlexceptionなど、ユーザー定義の例外など、一般に、カスタムチェックの例外はチェックされません。
3。例外処理メカニズム
Javaアプリケーションでは、例外処理メカニズムは次のとおりです。例外をスローし、例外をキャッチします。
例外をスローする：メソッドでエラーが発生し、例外が発生すると、メソッドは例外オブジェクトを作成し、ランタイムシステムに配信します。例外オブジェクトには、例外が発生したときの例外タイプやプログラムステータスなどの例外情報が含まれます。ランタイムシステムは、例外を処理するコードを見つけて実行する責任があります。
キャッチ例外：メソッドが例外をスローした後、ランタイムシステムは適切な例外ハンドラーを探すようになります。潜在的な例外ハンドラーは、例外が発生したときに順番にコールスタックに残るメソッドのコレクションです。例外プロセッサが処理できる例外タイプが、メソッドによってスローされる例外タイプと一致する場合、適切な例外プロセッサです。ランタイムシステムは、例外が発生するメソッドから始まり、適切な例外ハンドラーを含むメソッドを見つけて実行するまで、コールスタックのメソッドを順番に振り返ります。ランタイムシステムがコールスタックを横断し、適切な例外ハンドラーを見つけられない場合、ランタイムシステムは終了します。同時に、Javaプログラムの終了を意味します。
ランタイムの例外、エラー、または検出可能な例外の場合、Javaテクノロジーで必要な例外処理方法は異なります。
検出不可能なランタイムの例外により、アプリケーションをより合理的かつ簡単に実装するために、Javaはランタイムの例外がJavaランタイムシステムによって自動的にスローされることを規定しており、アプリケーションはランタイムの例外を無視できるようにします。
メソッド操作中に発生する可能性のあるエラーの場合、Javaは、メソッドをキャプチャしないときにメソッドを宣言しないようにします。ほとんどのエラーの例外は、決して許可されない状況であり、合理的なアプリケーションがキャッチしてはならないという例外でもあるためです。
すべてのチェック可能な例外のために、Javaは、方法をキャッチするか、スロー方法の外で宣言する必要があることを規定しています。つまり、メソッドがチェック可能な例外をキャッチしないことを選択した場合、例外がスローされることを宣言する必要があります。
例外をキャッチできる方法では、対応するタイプの例外ハンドラーを提供する必要があります。キャッチされた例外は、独自の声明によって提起およびスローされた例外、または呼び出されたメソッドまたはJavaランタイムシステムなどによってスローされる例外によって引き起こされる場合があります。言い換えれば、メソッドがキャッチできる例外は、JavaコードによってどこかでJavaコードによってスローされる例外でなければなりません。簡単に言えば、例外は常に最初にスローされ、次にキャッチされます。
Javaコードは、自分で作成されたコード、Java開発環境パッケージのコード、またはJavaランタイムシステムなどの例外をスローできます。誰であろうと、Java Throwステートメントを通じて例外をスローできます。
メソッドからスローされた例外は、スロー条項で使用する必要があります。
キャッチ例外は、トライキャッチステートメントまたはトライキャッチ式のステートメントを通じて達成されます。
一般的に言えば、Javaは、チェック可能な例外を捕まえたり宣言したりする必要があると規定しています。未チェックのruntimeexceptionとエラーを無視できます。
3.1例外をキャッチ：試して、キャッチし、最後に
1.try-catchステートメント
Javaでは、例外はトライキャッチステートメントによってキャッチされます。その一般的な構文フォームは次のとおりです。
try {//例外が発生する可能性のあるプログラムコード} catch（type1 id1）{// try type1} catch（type2 id2）{// try type2}でスローされた例外タイプをキャッチして取引する例外タイプをキャッチして取引}キーワードの後のブレースのペアは、監視領域と呼ばれる例外がある可能性のあるコードをラップします。実行中にJavaメソッド中に例外が発生した場合、例外オブジェクトが作成されます。監視エリアの外側に例外を投げます。Javaランタイムシステムは、例外をキャッチするために一致するキャッチ条項を見つけようとします。一致するキャッチ条項がある場合は、例外処理コードを実行し、Try-Catchステートメントが終了します。
マッチングの原則は次のとおりです。スローされた例外オブジェクトがCATCH句の例外クラスに属しているか、例外クラスのサブクラスに属している場合、生成された例外オブジェクトは、キャッチブロックによってキャッチされた例外タイプと一致すると見なされます。
例1キャッチ「Dividter is 0」例外をスローステートメントでスローします。
public class testexception {public static void main（string [] args）{int a = 6; int b = 0; {//監視領域を試してみてください//スローステートメントSystem.out.println（ "a/ bの値は：" + a/ b）を介して例外をスローします。 } catch（arithmeticexception e）{// catch catch exception system.out.out.println（ "プログラムには例外があり、変数bは0になりません。"）; } system.out.println（ "プログラムは正常に終了します。"）; }}実行結果：プログラムには例外があり、変数Bは0になりません。
プログラムは正常に終了します。
例1 Try Monitoringエリアで、IFステートメントを使用して判断します。 「仕切りIS 0」のエラー条件が確立されると、arithmeticexception例外が作成され、スローステートメントがJavaランタイムシステムの例外をスローします。システムは、一致する例外ハンドラーキャッチを見つけ、対応する例外処理コードを実行します。 「プログラムには例外があり、変数Bは0になりません。」 Try-Catchステートメントは終了し、プログラムフローを継続します。
実際、「ディバイダーIS 0」などの算術Xceptionは、runtimexceptionのサブクラスです。ランタイムの例外は、ランタイムシステムによって自動的にスローされ、スローステートメントを使用する必要はありません。
例2：ランタイムシステム中に「ディバイダーIS 0」によって引き起こされるarithmeticexception例外をキャッチします。
public static void main（string [] args）{int a = 6; int b = 0; try {System.out.println（ "a / bの値は：" + a / b）; } catch（arithmeticexception e）{system.out.println（ "プログラムには例外があり、変数bは0になりません。"）; } system.out.println（ "プログラムは正常に終了します。"）; }}実行結果：プログラムには例外があり、変数Bは0になりません。
プログラムは正常に終了します。
例2の声明：
system.out.println（ "a/bの値は：" + a/b）;
「分割イダーIS 0」のエラーが実行時に生成され、Arithmeticexception例外が発生しました。ランタイムシステムは、例外オブジェクトを作成し、監視領域をスローし、代わりに適切な例外ハンドラーキャッチと一致し、対応する例外処理コードを実行します。
ランタイムの例外をチェックするコストは、例外をキャッチすることの利点よりもはるかに大きいため、ランタイムの例外は検出できません。 Javaコンパイラは、ランタイムの例外を無視することができ、メソッドはランタイムの例外をキャッチも宣言も宣言できません。
例3：ランタイム例外がスローされていることをキャッチまたは宣言しません。
public class testexception {public static void main（string [] args）{int a、b; a = 6; b = 0; //除数bの値は0 system.out.println（a / b）です。 }}実行結果：
スレッド「Main」Java.lang.ArithMeticexception： / zeroによる例外
at test.testexception.main（testexception.java:8）
例4プログラムには、除数0の例外があり、アレイサブスクリプト外の範囲を例外としている場合があります。
public class testexception {public static void main（string [] args）{int [] intarray = new int [3]; try {for（int i = 0; i <= intarray.length; i ++）{intarray [i] = i; System.out.println（ "intarray [" + i + "] =" + intarray [i]）; System.out.println（ "intarray [" + i + "] module" +（i -2） + "values：" + intarray [i]％（i -2））; }} catch（arrayindexOutofboundsexception e）{system.out.println（ "intarray array subscript out ofbounds例外。"）; } catch（arithmeticexception e）{system.out.println（ "divisor 0の例外0）; } system.out.println（ "プログラムは正常に終了します。"）; }}実行結果：
intarray [0] = 0
intarray [0]モジュール2値：0
intarray [1] = 1
intarrayの値[1] modulo-1：0
intarray [2] = 2
除数の例外0。
プログラムは正常に終了します。
例5プログラムは、除数0の例外が発生する可能性があり、アレイサブスクリプの例外も発生する可能性があります。実行中のプログラム中、arithmeticexception例外タイプが最初に一致するため、一致するキャッチステートメントが実行されます。
catch（arithmeticexception e）{system.out.println（ "divisor 0の例外0）; }Catch Catchが一致する例外タイプをキャッチすると、例外処理コードを入力することに注意してください。処理が終了すると、Try-Catchステートメント全体が終了することを意味します。他のキャッチ条項には、例外タイプに合わせてキャッチする機会がなくなりました。
Javaは例外クラスを通じて例外タイプを説明し、例外クラスの階層を図1に示します。複数のCACT条項を持つ例外プログラムの場合、基礎となる例外クラスを最初にキャッチするCACT節を配置し、後で比較的高いレベルのクラスをキャッチするCACT句を置くようにしてください。それ以外の場合、基礎となる例外クラスをキャッチするCACT条項がブロックされる可能性があります。
runtimeexception例外クラスには、実行時にさまざまな一般的な例外が含まれ、arithmeticexceptionクラスとarrayindexofboundsexceptionクラスはどちらもサブクラスです。したがって、runtimeexception例外クラスのキャッチ句は最後に配置する必要があります。そうしないと、後続の例外処理をブロックするか、コンパイルエラーを引き起こす可能性があります。
2。統一されたステートメントを試してください
Try-Catchステートメントには、最終的な節である3番目の部分も含めることができます。例外が発生するかどうかに関係なく、何を実行する必要があるかを示します。 Try-Catch-Finally Statementの一般的な構文形式は次のとおりです。
{//例外を発生する可能性のあるプログラムコード} catch（type1 id1）{// try type1} catch（type2 id2）でスローされた例外タイプをキャッチして処理する（// try type2}によってスローされた例外タイプをキャッチして処理します}最終的に{//例外が発生するかどうかに関係なく実行されるステートメントのブロック}}例6最終的な句を持つ例外ハンドラー。
public class testexception {public static void main（string args []）{int i = 0;弦の挨拶[] = {"Hello World！"、 "Hello World !!"、 "Hello World !!!" }; while（i <4）{try {//ループ制御変数Iの設計に特に注意してください。 } catch（arrayindexOutofboundsexception e）{system.out.println（ "Arraysubscript Out-bounds Exception"）; }最後に{system.out.println（ "------------------------"）; }}}}実行結果：
こんにちは世界！
-------------------------------------------
こんにちは世界 ！！
-------------------------------------------
こんにちは世界！！！
-------------------------------------------
Bounds Exceptionのアレイサブスクリプト
-------------------------------------------
例6では、Try句のステートメントブロックの設計に特に注意してください。設計が次のとおりの場合、デッドループが発生します。として設計されている場合：
try {System.out.println（Greetings [i]）; i ++; }まとめ：
ブロックを試してください：例外をキャッチするために使用されます。その後、ゼロ以上のキャッチブロックを接続できます。キャッチブロックがない場合は、最終的にブロックが続く必要があります。
キャッチブロック：Tryによってキャッチされた例外を処理するために使用されます。
最終的にブロック：最終的なブロックのステートメントは、例外がキャッチされているか処理されているかに関係なく実行されます。トライブロックまたはキャッチブロックで戻りステートメントが発生した場合、最終的なステートメントブロックは
メソッドが返す前に実行します。次の4つの特別なケースでは、最終的なブロックは実行されません。
1）最終的なステートメントブロックで例外が発生しました。
2）前のコードでSystem.Exit（）を使用してプログラムを終了します。
3）プログラムが配置されているスレッドは死にます。
4）CPUをオフにします。
3.対応のルールを試してください（例外処理ステートメントの文法ルール）：
1）試してからキャッチまたは最終的にブロックを追加する必要があります。トライブロックの後、キャッチと最終的にブロックを同時に接続できますが、少なくとも1つのブロックがあります。
2）ブロックの順序に従う必要があります。コードがキャッチと最終的にブロックの両方を使用する場合、Tryブロックの後にキャッチブロックを配置する必要があります。
3）キャッチブロックは、対応する例外クラスのタイプに関連しています。
4）トライブロックには複数のキャッチブロックがある場合があります。その場合、最初のマッチングブロックが実行されます。つまり、Java仮想マシンは、実際のスローされた例外オブジェクトと一致し、各CACTコードブロックによって宣言された例外タイプが順番に一致します。例外オブジェクトが例外タイプまたはサブクラスのインスタンスである場合、Catchコードブロックが実行され、他のCACTコードブロックは実行されません。
5）ネストされたTry-Catch-Finally Structure。
6）Try-Catch-Finally Structureでは、例外を再スローすることができます。
7）次の状況に加えて、最終的に終了します。最終的なブロックに未処理の例外をスローします。コンピューターは、ウイルスによって電源が切れたり、解雇されたり、攻撃されたりします。
4.試行、キャッチ、そして最後にステートメントの実行順序：
1）TRYが例外をキャッチしない場合：TRYステートメントブロックのステートメントが1つずつ実行され、プログラムはCACTステートメントブロックをスキップし、最終的なステートメントブロックとその後のステートメントを実行します。
2）TRYが例外をキャッチする場合、CATCHステートメントブロックはこの例外を処理しません。TRYステートメントブロックのステートメントとこの例外を処理しないCACTステートメントブロックで例外が発生した場合、例外は処理のためにJVMにスローされ、最終的なステートメントブロックのステートメントはまだ実行されますが、最終的なステートメントブロックの後のステートメントは実行されません。
3）TRYが例外をキャッチすると、Catchステートメントブロックがこの例外を処理します。TRYステートメントブロックで実行されます。特定のステートメントで例外が発生したときに例外が発生した場合、プログラムはCatchステートメントブロックにジャンプし、1つずつ一致させます。対応するハンドラーを見つけます。他のキャッチステートメントブロックは実行されません。 TRYステートメントブロックでは、例外が発生した後のステートメントは実行されません。 Catchステートメントブロックが実行された後、最終的なステートメントブロックのステートメントが実行され、最終的にステートメントブロックが実行された後のステートメントが実行されます。
Try、Catch、および最後にステートメントの実行の実行のイラスト：
図2は、Try、Catch、および最後にステートメントブロックの実行を示しています
3.2例外を投げます
Javaコードは、自分で作成されたコード、Java開発環境パッケージのコード、またはJavaランタイムシステムなどの例外をスローできます。誰であろうと、Java Throwステートメントを通じて例外をスローできます。メソッドからスローされた例外は、スロー条項で使用する必要があります。
1.スロー例外をスローします
メソッドに例外があるかもしれませんが、そのような例外を処理する能力がない場合は、Throws句を使用して、メソッド宣言でスロー例外を宣言できます。たとえば、走るときに車が故障する可能性があり、車自体がこの障害を処理できないため、ドライバーに対処してください。
THROWSステートメントは、メソッドが定義されたときにスローする例外のタイプを宣言するために使用されます。例外タイプがスローされている場合、メソッドはすべての例外をスローするように宣言されています。コンマを使用して複数の例外を分割できます。スローステートメントの構文形式は次のとおりです。
MethodNameスローException1、Exception2、..、Exceptionn {}メソッド名の例外1、例外2、...、例外の後にスローすることは、スローされる例外のリストです。メソッドが例外の例外リストをスローすると、メソッドはこれらのタイプとそのサブクラスタイプの例外を処理しませんが、メソッドを呼び出してそれによって処理されるメソッドにスローされます。例えば：
Java.lang.exceptionをインポートします。 public class testexception {static void pop（）はnegativearraysizeexceptionをスローします{//メソッドを定義し、negativearraysizeexcecececetecection int [] arr = new int [-3]; //配列を作成} public static void main（string [] args）{// main method try {//ステートメントハンドル例外情報pop（）; // pop（）メソッドを呼び出す} catch（negativearraysizeexception e）{system.out.println（ "pop（）メソッドによってスローされた例外"）; //出力例外情報}}}スローキーワードを使用して発信者に例外をスローした後、発信者が例外を処理したくない場合は、引き続き投げ続けることができますが、最終的には例外を処理できる発信者がいる必要があります。
POPメソッドは、例外NegativeArraySizeexceptionを処理しませんが、メイン関数によって処理されます。
例外をスローするためのスローのルール：
1）それが未確認の例外、つまりエラー、runtimeexception、またはそのサブクラスである場合、スローキーワードを使用せずに例外をスローするように宣言できますが、コンパイルはまだスムーズに渡されますが、実行時にシステムによってスローされます。
2）メソッドによってスローされる可能性のあるチェックされた例外を宣言する必要があります。つまり、メソッドにチェック可能な例外がある場合は、トライキャッチステートメントでキャッチされるか、スロー条項宣言でスローします。そうしないと、コンパイルエラーが発生します。
3）例外がスローされた場合にのみ、メソッドの発信者は例外を処理または再スローする必要があります。メソッド発信者が例外を処理できない場合、それを全体として飲み込むのではなく、それを投げ続ける必要があります。
4）呼び出し方法は、チェック可能な例外処理および宣言規則に従う必要があります。メソッドが上書きされている場合、上書きメソッドとは異なる例外を宣言することはできません。宣言された例外は、オーバーライドされた方法で宣言された例外の類似またはサブクラスでなければなりません。
例えば：
void method1（）throws ioException {} // legal //コンピレーションエラー、ioExceptionはvoid method2（）{method1（）; } // legal、ioException void method3（）をスローすることを宣言します3（）throws ioexception {method1（）; } //法的、例外をスローする宣言、ioExceptionは例外のサブクラスですvoid method4（）throws exception {method1（）; } // legal、capture ioException void method5（）{try {method1（）; } catch（ioexception e）{…}} //コンピレーションエラー、スローされた例外void method6（）{try {method1（）; } catch（ioException e）{throw new Exception（）;}} // legal、宣言例例外を宣言void method7（）throws exception {try {method1（）; } catch（ioException e）{新しい例外（）;}}方法で例外が発生する可能性があると判断するための基礎は、次のとおりです。
1）メソッドにはスローステートメントがあります。たとえば、上記のmethod7（）メソッドのキャッチコードブロックにはスローステートメントがあります。
2）他の方法が呼び出され、他の方法はスロー句を使用して、スローする例外を宣言します。たとえば、method3（）メソッドはmethod1（）メソッドを呼び出し、method1（）メソッドはioexceptionがスローされることを宣言しているため、ioExceptionがmethod3（）メソッドで発生する可能性があります。
2。スローを使用して例外をスローします
スローは常に関数本体に表示され、タイプスロー可能なタイプの例外をスローするために使用されます。このプログラムは、スローステートメントの直後、実行できない直後に終了し、その後、それを含むすべてのトライブロック（おそらく上位レベルの呼び出し関数）で、内側からそれを一致させるキャッチ句を含むトライブロックを探します。
例外は例外クラスのインスタンスオブジェクトであることがわかっており、スローステートメントでスローされる例外クラスのインスタンスオブジェクトを作成できます。このステートメントの構文形式は次のとおりです。
新しい例外をスローします。
たとえば、iOExceptionクラスの例外オブジェクトをスローします。
新しいioExceptionを投げます。
クラススロー可能またはサブクラスをスローできるインスタンスオブジェクトのみをスローすることに注意する必要があります。次の操作が正しくありません。
新しい文字列（ "例外"）;
これは、Stringがスロー可能なクラスのサブクラスではないためです。
チェックの例外がスローされている場合は、メソッドがメソッドヘッダーを投入する可能性のある例外のタイプを宣言する必要があります。このメソッドの発信者は、スローされた例外を処理することもチェックする必要があります。
すべてのメソッドが取得した例外レイヤーをレイヤーごとに投げると、JVMは最終的に処理され、処理も非常に簡単です。これは、例外メッセージとスタック情報を印刷するためです。エラーまたはruntimeexceptionがスローされている場合、メソッドの発信者には例外を処理するオプションがあります。
パッケージテスト; Java.lang.exceptionをインポートします。パブリッククラスのtestexception {static int quotient（int x、int y）はmyexceptionをスローします{//例外をスローするメソッドを定義します（y <0）{//パラメーターが0未満かどうかを決定します（ "除数は負の数字になりません"）; //例外情報} x/yを返します。 // return値} public static void main（string args []）{// main method int a = 3; int b = 0; try {// tryステートメントには例外がある可能性のあるステートメントが含まれていますint result = quotient（a、b）; // method quoteent（）} catch（myexception e）{//カスタム例外system.out.println（e.getmessage（））; //出力例外情報} catch（arithmeticexception e）{// arithmeticexception例外system.out.println（ "divorceipt can can couns be"）; //プロンプト情報の出力} catch（例外e）{//他の例外system.out.println（ "他の例外がプログラムで発生した"）; //出力プロンプト情報}}} class myExceptionは例外を拡張します{//カスタム例外クラス文字列メッセージを作成します。 //文字列タイプ変数public myException（string errormessagr）{//親クラスメソッドメッセージ= errormessagr; } public string getMessage（）{// override getMessage（）メソッド返信メッセージ; }}3.3例外チェーン
1）商（3、-1）が呼び出された場合、MyException例外が発生し、プログラムがCACT（MyException E）コードブロックに転送されます。
2）商（5,0）と呼ばれる場合、「仕切りは0」エラーのために算術Xception例外が発生します。ランタイム例外クラスに属し、Javaランタイムシステムによって自動的にスローされます。 quotient（）メソッドは、arithmeticexception例外をキャッチしません。 Javaランタイムシステムは、メソッドコールスタックに沿ってメインメソッドを検索し、Quotient（）メソッドの呼び出し者にスローされた例外をアップロードします。
int result = quotient（a、b）; //メソッドquotient（）を呼び出す
このステートメントはTry Monitoringエリアにあるため、「Divider Is 0」を搭載したArithmeticexceptionが渡されます。
catch（arithmeticexception e）{// arithmeticexception system.out.println（ "visorは0" ""）; //出力プロンプト情報}処理の結果は、出力「仕切りは0ではない」ということです。例外情報を上方に渡す処理メカニズムであるJavaは、例外チェーンを形成します。
Javaメソッドによってスローされたチェック可能な例外は、コールスタックに基づいてメソッドコールの階層に沿って処理機能を使用して呼び出しメソッドに渡され、最高レベルはメインメソッドまでになります。例外がメインメソッドに渡されますが、メインにはそれを処理する能力がなく、スロー宣言を通して例外をスローしない場合、編集エラーが発生する場合があります。
3）他の例外が発生した場合、キャッチ（例外E）を使用してキャッチします。 Since Exception is the parent class of all exception classes, if the catch (Exception e) code block is placed in front of the other two code blocks, the subsequent code blocks will never be executed, which makes no sense, so the order of catch statements cannot be replaced.
3.4 Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
getCause()：返回抛出异常的原因。如果cause 不存在或未知，则返回null。
getMeage()：返回异常的消息信息。
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段System.err 的值。
有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。
5.Java常见异常
在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:
1. runtimeException子类:
1、 java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2、java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。
3、java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
4、java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
5、java.lang.NegativeArraySizeException 数组长度为负异常
6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
7、java.lang.SecurityException 安全性异常
8、java.lang.IllegalArgumentException 非法参数异常
2.IOException
IOException：操作输入流和输出流时可能出现的异常。
EOFException 文件已结束异常
FileNotFoundException 文件未找到异常
3. 其他
ClassCastException 类型转换异常类
ArrayStoreException 数组中包含不兼容的值抛出的异常
SQLException 操作数据库异常类
NoSuchFieldException 字段未找到异常
NoSuchMethodException 方法未找到抛出的异常
NumberFormatException 字符串转换为数字抛出的异常
StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
IllegalAccessException 不允许访问某类异常
InstantiationException 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
6.自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常。
在上面的“使用throw抛出异常”例子已经提到了。
上記はこの記事のすべての内容です。みんなの学習に役立つことを願っています。誰もがwulin.comをもっとサポートすることを願っています。