1. 소개
시도해보십시오… 캐치… 마침내 모든 사람이 익숙한 문장 일 것입니다. 사용하기가 매우 간단하며 논리적으로 이해하기 쉬운 것 같습니다. 그러나, 나는 개인적으로 경험 한 "학습"은 내가 상상했던 것만 큼 단순하고 순종적이지 않다고 나에게 말했다. 믿지 않습니까? 그런 다음 아래 코드를 살펴보면 실행 후 결과는 무엇입니까? 답을 뒤로 보지 말고 코드를 실행하여 실제 답변을 볼 수 없습니다. 대답이 정확하다면이 기사를 읽는 데 시간을 낭비하지 않아도됩니다.
패키지 테스트; public class testException {public testException () {} boolean testex ()는 예외 {boolean ret = true; {ret = testex1 (); } catch (예외 e) {system.out.println ( "testex, catch exception"); ret = false; e 던지기; } 마침내 {system.out.println ( "testex, 마지막으로; return value =" + ret); Ret Ret; }} boolean testex1 ()는 예외를 던지려고 {boolean ret = true; try {ret = testex2 (); if (! ret) {return false; } system.out.println ( "시험 종료시 testex1"); Ret Ret; } catch (예외 e) {system.out.println ( "testex1, catch exception"); ret = false; e 던지기; } 마침내 {system.out.println ( "testex1, 마지막으로; return value =" + ret); 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 (예외 e) {system.out.println ( "testex2, catch exception"); ret = false; e 던지기; } 마침내 {system.out.println ( "testex2, 마지막으로; return value =" + ret); Ret Ret; }} public static void main (String [] args) {testException testException1 = new TestException (); try {testException1.testex (); } catch (예외 e) {e.printstacktrace (); }}} 당신의 대답은 무엇입니까? 아래 답변입니까?
i = 2
i = 1
testex2, 예외를 잡습니다
testex2, 마지막으로; 반환 값 = false
testex1, 예외를 잡습니다
testex1, 마지막으로; 반환 값 = false
testex, 예외를 잡습니다
Testex, 마지막으로; 반환 값 = false
당신의 대답이 실제로 위에서 언급 한 것처럼, 당신은 틀 렸습니다. ^_^, 그런 다음이 기사를주의 깊게 읽거나 위의 코드를 사용하여 다양한 상황에 따라 수정, 실행 및 테스트하는 것이 좋습니다. 당신은 원래 상상했던 것만 큼 단순하지 않은 많은 것들이 있다는 것을 알게 될 것입니다. 이제 정답을 게시하십시오.
i = 2
i = 1
testex2, 예외를 잡습니다
testex2, 마지막으로; 반환 값 = false
testex1, 마지막으로; 반환 값 = false
Testex, 마지막으로; 반환 값 = false
메모:
마지막으로 문장 블록이 나타나지 않아야합니다. 반환이 나타나야합니다. 위의 반환 RET는 바람직하게는 관련 논리를 처리하는 또 다른 진술입니다.
2. 자바 예외
예외는 다음과 같이 예기치 않게 발생하는 다양한 상황을 나타냅니다. 파일 찾기, 네트워크 연결 고장, 불법 매개 변수 등. 프로그램 실행 중에 발생하는 이벤트는 일반 명령 흐름을 방해합니다. Java는 API에서 Throwable 클래스의 많은 서브 클래스를 통해 다양한 예외를 설명합니다. 따라서 Java 예외는 인코딩에 나타나는 오류 조건을 설명하는 객체, 던질 가능한 서브 클래스 인스턴스입니다. 조건이 생성되면 오류가 예외가 발생합니다.
Java Exception Class 계층 다이어그램 :
그림 1 Java Exception Class 계층 다이어그램
Java에서는 모든 예외에는 공통 조상이 있습니다. Throwable은 예외 전파 메커니즘을 통해 코드의 Java 응용 프로그램을 통해 전송할 수있는 모든 문제의 공통성을 지정합니다.
던질 수있는 : 예외와 오류의 두 가지 중요한 서브 클래스가 있습니다. 둘 다 Java 예외 처리에 중요한 서브 클래스이며 각각에는 많은 수의 서브 클래스가 포함되어 있습니다.
오류 : 프로그램이 처리 할 수없는 오류로 응용 프로그램 실행에 심각한 문제가 있음을 나타냅니다. 대부분의 오류는 코드 작성자가 수행 한 작업과 관련이 없지만 코드가 실행될 때 JVM (Java Virtual Machine)의 문제를 나타냅니다. 예를 들어, Java Virtual Machine은 오류 (Virtual MachineError)를 실행하고 JVM에 더 이상 작동을 계속하는 데 필요한 메모리 리소스가 없으면 OutofMemoryError가 나타납니다. 이러한 예외가 발생하면 JVM (Java Virtual Machine)은 일반적으로 스레드를 종료하기로 선택합니다.
이러한 오류는 가상 머신 자체 또는 가상 머신이 Java Virtual Machine Running Error (Virtual MachineError), 클래스 정의 오류 (NoclassDeffounderRor) 등과 같은 응용 프로그램을 실행하려고 할 때 발생할 때 발생합니다. 이러한 오류는 응용 프로그램의 제어 및 처리 기능을 벗어나기 때문에 대부분의 프로그램이 진행되지 않기 때문에 검출 할 수 없습니다. 잘 설계된 응용 프로그램의 경우 오류가 발생하더라도 본질적으로 발생하는 예외를 처리하지 않아야합니다. Java에서 오류는 오류의 서브 클래스로 설명됩니다.
예외 : 프로그램 자체가 처리 할 수있는 예외.
예외 클래스에는 중요한 서브 클래스, runtimeexception이 있습니다. runtimeexception 클래스 및 하위 클래스는 "공통 JVM 작업"에 의해 제기 된 오류를 나타냅니다. 예를 들어, Null Object Reference, Zero Divisor 또는 Array of Bounds를 사용하려고하면 런타임 예외 (NullPointerException, ArithMeticeXception) 및 ArrayIndexOutoFBoundException이 각각 제기됩니다.
참고 : 예외와 오류의 차이 : 예외는 프로그램 자체에서 처리 할 수 있지만 오류를 처리 할 수는 없습니다.
일반적으로 Java 예외 (예외 및 오류 포함)는 점검 된 예외와 확인되지 않은 예외로 나뉩니다.
예외를 확인할 수 있습니다 (컴파일러가 처리 해야하는 예외) : 올바른 프로그램이 실행될 때 쉽게 발생하고 합리적이며 관용적으로 예외입니다. 점검 가능한 예외는 비정상적인 상태이지만, 그 발생은 어느 정도 예측 가능하며, 그러한 비정상적인 상태가 발생하면 어떤 식 으로든 처리해야합니다.
runtimeexception 및 하위 클래스를 제외하고 다른 예외 클래스 및 하위 클래스는 모두 검사 가능한 예외입니다. 이 예외의 특징은 Java 컴파일러가이를 확인한다는 것입니다. 즉, 프로그램에서 이러한 예외가 발생할 수있는 경우 Try-Catch 문으로 포착하거나 Throws 조항으로 던질 수 있습니다. 그렇지 않으면 컴파일이 전달되지 않습니다.
확인할 수없는 예외 (컴파일러가 강제 처리가 필요하지 않은 예외) : 런타임 예외 (runtimeexception 및 하위 클래스) 및 오류 (오류)를 포함합니다.
예외이 예외는 런타임 예외와 비 런타임 예외 (컴파일 예외)의 두 가지 범주로 나뉩니다. 이러한 예외는 프로그램에서 가능한 한 많이 처리해야합니다.
런타임 예외 : nullpointerexception (null pointer exception), indexoutofboundsexception (밑면 이외의 예외) 등과 같은 모든 runtimeexception 클래스 및 서브 클래스 예외입니다. 이러한 예외는 예외를 확인하지 않으며 프로그램에서 캡처하고 처리 할 수 없습니다. 이러한 예외는 일반적으로 프로그램 논리 오류로 인해 발생하며 프로그램은 논리적 관점에서 가능한 한 많은 예외를 피해야합니다.
런타임 예외의 특징은 Java 컴파일러가 확인하지 않는다는 것입니다. 즉, 그러한 예외가 프로그램에서 발생할 수있을 때, 시도-캐치 문으로 캡처되지 않더라도 Throws 조항과 함께 던져지면 편집 및 통과됩니다.
비 런타임 예외 (컴파일 예외) : runtimeexception 이외의 예외이며, 예외 클래스 및 유형 측면에서 하위 클래스에 속합니다. 프로그램 구문의 관점에서 볼 때 처리 해야하는 예외입니다. 처리되지 않으면 프로그램을 편집하고 통과 할 수 없습니다. IOException, Sqlexception 등 및 사용자 정의 예외 예외와 같은 일반적으로 사용자 정의 검사 예외는 확인되지 않습니다.
3. 예외 처리 메커니즘
Java 응용 프로그램에서 예외 처리 메커니즘은 다음과 같습니다.
예외를 던지기 : 메소드에서 오류가 발생하고 예외가 발생하면이 메소드는 예외 객체를 생성하여 런타임 시스템으로 전달합니다. 예외 객체에는 예외가 발생할 때 예외 유형 및 프로그램 상태와 같은 예외 정보가 포함되어 있습니다. 런타임 시스템은 예외를 처리하기위한 코드를 찾고 실행하는 책임이 있습니다.
예외 예외 : 메소드가 예외를 던지면 런타임 시스템이 적절한 예외 처리기를 찾는 것으로 전환됩니다. 잠재적 예외 처리기는 예외가 발생할 때 콜 스택에 남아있는 메소드 모음입니다. 예외 프로세서가 처리 할 수있는 예외 유형이 메소드에서 던지는 예외 유형과 일치하면 적절한 예외 프로세서입니다. 런타임 시스템은 예외가 발생하는 메소드로 시작한 다음 적절한 예외 핸들러가 포함 된 메소드를 찾아 실행할 때까지 콜 스택의 메소드를 차례로 되돌아 봅니다. 런타임 시스템이 통화 스택을 통과하고 적절한 예외 핸들러를 찾지 못하면 런타임 시스템이 종료됩니다. 동시에, 그것은 Java 프로그램의 종료를 의미합니다.
런타임 예외, 오류 또는 감지 가능한 예외의 경우 Java 기술에 필요한 예외 처리 방법이 다릅니다.
감지 할 수없는 런타임 예외로 인해 애플리케이션을보다 합리적이고 쉽게 구현하기 위해 Java는 Java 런타임 시스템에 의해 런타임 예외가 자동으로 던져 지므로 응용 프로그램이 런타임 예외를 무시할 수 있습니다.
메소드 작동 중에 발생할 수있는 오류의 경우 Java를 사용하면 메소드를 캡처하지 않아도 메소드가 선언을 던질 수 있습니다. 대부분의 오류 예외는 결코 발생할 수없는 상황이며, 합리적인 응용 프로그램이 포착해서는 안되는 예외이기 때문입니다.
모든 점검 가능한 예외에 대해 Java는 방법이 잡히거나 던지기 방법 외부에서 선언해야한다고 규정합니다. 즉, 방법이 점검 가능한 예외를 포착하지 않기로 선택하면 예외가 발생한다고 선언해야합니다.
예외를 포착 할 수있는 메소드는 해당 유형의 예외 처리기를 제공해야합니다. 잡힌 예외는 자체 진술에 의해 제기되고 던져진 예외 또는 호출 된 메소드 또는 Java 런타임 시스템에 의해 발생 된 예외로 인해 발생할 수 있습니다. 즉, 메소드가 포착 할 수 있다는 예외는 Java 코드가 어딘가에 발생하는 예외 여야합니다. 간단히 말해서, 예외는 항상 먼저 던져지고 잡혔습니다.
모든 Java 코드는 다음과 같은 예외를 제외 할 수 있습니다. 그것이 누구라도 Java 던지기 진술을 통해 예외를 던질 수 있습니다.
방법에서 던져진 예외는 Throws 절과 함께 사용해야합니다.
캐치 예외는 시도-캐치 문 또는 try-catch-finally 진술을 통해 달성됩니다.
일반적으로, Java는 검사 가능한 예외가 잡히거나 선포되어야한다고 규정합니다. 확인되지 않은 runtimeexception 및 오류를 무시할 수 있습니다.
3.1 캐치 예외 : 시도, 잡기 및 마지막으로
1. 트리 캐치 성명서
Java에서는 예외가 Try-Catch 문에 의해 잡혔습니다. 일반적인 구문 양식은 다음과 같습니다.
시도 {// 예외가 발생할 수있는 프로그램 코드} catch (type1 id1) {// type1} catch (type2 id2)에 의해 던져진 예외 유형을 포괄하고 처리합니다. {// type2에 의해 제외 된 예외 유형을 처리하고 처리합니다.키워드 시도 후 한 쌍의 버팀대는 예외가있을 수있는 코드를 모니터링 영역이라고합니다. 실행 중에 Java 메소드 중에 예외가 발생하면 예외 객체가 생성됩니다. 모니터링 영역 밖에서 예외를 던지고 Java 런타임 시스템은 예외를 잡기 위해 일치하는 캐치 조항을 찾으려고 시도합니다. 캐치 조항이 일치하는 경우 예외 처리 코드를 실행하고 Try-Catch 문은 종료됩니다.
일치하는 원칙은 다음과 같습니다. 제외 예외 객체가 Catch Clause의 예외 클래스에 속하거나 예외 클래스의 서브 클래스에 속하는 경우 생성 된 예외 객체가 캐치 블록에서 잡힌 예외 유형과 일치하는 것으로 간주됩니다.
예 1 포획 "Dividter는 0"예외가 Throw 문에 의해 발생합니다.
공개 클래스 testException {public static void main (String [] args) {int a = 6; int b = 0; {// (b == 0) 새로운 arithmeticexception ()을 던지면 모니터링 영역을 시도해보십시오. // Throw Statement.out.println을 통한 Throw Exception.out.println ( "a/ b의 값은 :" + a/ b); } catch (arithmeticexception e) {// CATCH CATCH EXCERNE SYSTEM.OUT.PRINTLN ( "프로그램에는 예외가 있고 변수 b는 0이 될 수 없습니다"); } system.out.println ( "프로그램은 정상적으로 끝납니다."); }}실행 결과 : 프로그램은 예외가 있으며 변수 B는 0이 될 수 없습니다.
프로그램은 정상적으로 끝납니다.
예 1 시도 모니터링 영역에서 IF 문을 사용하여 판단하십시오. "divider is 0"의 오차 조건이 설정되면 Arithmeticexception 예외가 생성되고 Throw 문은 Java 런타임 시스템에 예외를 던집니다. 이 시스템은 일치하는 예외 처리기를 찾아서 해당 예외 처리 코드를 실행합니다. 인쇄 "프로그램은 예외가 있고 변수 b는 0이 될 수 없습니다." Try-Catch 문은 끝나고 프로그램 흐름을 계속합니다.
실제로 "분배기는 0"과 같은 Arithmeticexception은 runtimexception의 서브 클래스입니다. 런타임 예외는 런타임 시스템에 의해 자동으로 던져지며 던지기 문을 사용할 필요가 없습니다.
예제 2 : 런타임 시스템 중에 "분배기는 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);
런타임 동안 "분배기는 0"의 오류가 생성되었으며 ArithMeticexception 예외가 제기되었습니다. 런타임 시스템은 예외 객체를 생성하고 모니터링 영역을 던지고 대신 적절한 예외 처리기 캐치와 일치하고 해당 예외 처리 코드를 실행합니다.
런타임 예외를 확인하는 비용은 예외를 포착하는 이점보다 훨씬 크기 때문에 런타임 예외를 감지 할 수 없습니다. Java 컴파일러는 런타임 예외를 무시할 수 있으며 방법은 런타임 예외를 던지거나 선언 할 수 없습니다.
예 3 : 런타임 예외가 발생했다고 캐치 나 선언하지 않습니다.
공개 클래스 testException {public static void main (String [] args) {int a, b; a = 6; b = 0; // divisor b의 값은 0 System.out.println (a / b)입니다. }}실행 결과 :
스레드의 예외 "main"java.lang.arithmeticexception : / by 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 + "] 모듈" + (i -2) + "값 :" + intarray [i] % (i -2)); }} catch (arrayindexoutofboundsexception e) {system.out.println ( "intarray array artip-out-of-bounds exception."); } catch (arithmeticexception e) {system.out.println ( "divisor 0의 예외"); } system.out.println ( "프로그램은 정상적으로 종료됩니다."); }}실행 결과 :
intarray [0] = 0
intarray [0] 모듈 -2 값 : 0
intarray [1] = 1
intarray의 값 [1] modulo-1 : 0
intarray [2] = 2
제외 0.
프로그램은 정상적으로 끝납니다.
예 5 프로그램은 Divisor 0을 제외하고 배열 위트를 제외하고도 발생할 수 있습니다. 프로그램 실행 중에 ArithMeticeXception 예외 유형이 먼저 일치하므로 일치하는 캐치 문이 실행됩니다.
catch (arithmeticexception e) {system.out.println ( "divisor 0의 예외"); }캐치 캐치가 일치하는 예외 유형을 잡으면 예외 처리 코드가 입력됩니다. 처리가 완료되면 전체 Try-Catch 문이 종료됨을 의미합니다. 다른 캐치 조항은 더 이상 예외 유형을 일치시키고 잡을 기회가 없습니다.
Java는 예외 클래스를 통한 예외 유형을 설명하고 예외 클래스의 계층 구조는 그림 1에 나와 있습니다. 여러 가지 캐치 조항이있는 예외 프로그램의 경우 기본 예외 클래스를 먼저 잡는 Catch Clause를 넣고 비교적 높은 수준의 예외 클래스를 잡는 Catch Clause를 넣어야합니다. 그렇지 않으면, 기본 예외 클래스를 잡는 캐치 조항이 차단 될 것입니다.
runtimeexception Exception 클래스에는 런타임시 다양한 공통 예외가 포함되어 있으며 Arithmeticexception 클래스와 ArrayindExoutOfBoundSexception 클래스는 모두 하위 클래스입니다. 따라서 runtimeexception Exception 클래스의 캐치 절은 끝에 배치되어야합니다. 그렇지 않으면 후속 예외 처리를 차단하거나 컴파일 오류를 일으킬 수 있습니다.
2. Try-Catch-Finally 진술
Try-Catch 문에는 세 번째 부분도 포함될 수 있으며, 이는 최종 조항입니다. 예외가 발생하는지 여부에 관계없이 실행해야 할 사항을 나타냅니다. Try-Catch-Finally 진술의 일반적인 구문 형태는 다음과 같습니다.
{// 예외적 인 프로그램 코드} catch (type1 id1) {// catch and procation type type1} catch (type2 id2) {// catch and process and process and process type type type2} {// 예외가 발생하는지 여부에 관계없이 실행되는 문의 블록}예제 6 마지막 절을 가진 예외 처리기.
공개 클래스 testException {public static void main (String args []) {int i = 0; 문자열 인사 [] = { "Hello World!", "Hello World !!", "Hello World !!!" }; while (i <4) {try {// 루프 제어 변수 설계에 특별한주의를 기울여 INFINITE LOOPS SYSTEM.out.println (Greetings [i ++]); } catch (arrayIndexOutOfBoundSexception e) {System.out.println ( "arraysubscript 외부 예외"); } 마침내 {system.out.println ( "------------------------------------------- }}}}실행 결과 :
안녕하세요 세상!
----------------------------------
안녕하세요 세계 !!
----------------------------------
안녕하세요 세계 !!!
----------------------------------
배열 위시는 바운드 예외입니다
----------------------------------
예 6에서는 Try Clause에서 명세서 블록의 설계에 특별한주의를 기울이십시오. 디자인이 다음과 같으면 죽은 루프가 발생합니다. 설계된 경우 :
try {system.out.println (인사 [i]); i ++; }요약:
시도 블록 : 예외를 포착하는 데 사용됩니다. 그 후, 0 개 이상의 캐치 블록을 연결할 수 있습니다. 캐치 블록이 없으면 마침내 블록을 따라야합니다.
캐치 블록 : 시도가 잡힌 예외를 처리하는 데 사용됩니다.
마지막으로 블록 : 마침내 블록의 진술은 예외가 잡히거나 처리되는지 여부에 관계없이 실행됩니다. 시도 블록 또는 캐치 블록에서 반환 명령문이 발생하면 최종 문자 블록이
메소드가 반환되기 전에 실행됩니다. 다음 4 개의 특별한 경우에는 최종 블록이 실행되지 않습니다.
1) 마지막 명세서 블록에서 예외가 발생했습니다.
2) 이전 코드에서 System.exit ()를 사용하여 프로그램을 종료하십시오.
3) 프로그램이 위치한 스레드가 죽습니다.
4) CPU를 끕니다.
3. Try-Catch-Finally Rule (예외 처리 명령문을위한 문법 규칙) :
1) 시도 후 캐치 또는 마지막으로 블록을 추가해야합니다. 시도 블록 후, 캐치와 마지막으로 블록은 동시에 연결할 수 있지만 적어도 하나의 블록이 있습니다.
2) 블록 순서를 준수해야합니다. 코드가 캐치와 마지막으로 블록을 모두 사용하는 경우 시도 블록 후에 캐치 블록을 배치해야합니다.
3) 캐치 블록은 해당 예외 클래스의 유형과 관련이 있습니다.
4) 시도 블록에는 여러 개의 캐치 블록이있을 수 있습니다. 그렇다면 첫 번째 일치 블록이 실행됩니다. 즉, Java Virtual Machine은 실제 던져진 예외 객체와 일치하여 각 캐치 코드 블록에서 순서대로 선언 한 예외 유형과 일치합니다. 예외 객체가 예외 유형이거나 서브 클래스 인스턴스 인 경우 캐치 코드 블록이 실행되고 다른 캐치 코드 블록이 실행되지 않습니다.
5) 중첩 트리 캐치-패치 구조.
6) Try-Catch-Finally 구조에서 예외를 다시 던질 수 있습니다.
7) 다음 상황 외에도 최종적으로 종료 된 실행 : JVM은 조기에 종료됩니다 (System.Exit (int)라고 함). 마침내 블록에서 처리되지 않은 예외를 던집니다. 컴퓨터는 전원 끄기, 발사 또는 바이러스에 의해 공격됩니다.
4. 시도, 캐치 및 마지막으로 진술의 실행 순서가 차단됩니다.
1) 시도가 예외를 포착하지 않을 때 : Try Statement 블록의 명세서는 하나씩 실행되며 프로그램은 Catch Statement 블록을 건너 뛰고 마지막 명령문 블록 및 후속 문을 실행합니다.
2) 시도가 예외가 발생하면 Catch Statement 블록은이 예외를 처리하지 않습니다.이 예외를 처리하지 않는 Try Statement Block의 명령문에서 예외가 발생하면 예외는 처리를 위해 JVM에 던져지고 마지막 명령문의 명세서는 여전히 실행되지만 마지막 명령문 블록이 실행되지는 않습니다.
3) Try가 예외를 잡을 때 Catch Statement Block 은이 예외를 처리합니다. Try Statement 블록에서 순서대로 실행됩니다. 특정 명세서에서 예외가 발생할 때 예외가 발생하면 프로그램은 Catch 문으로 점프하여 하나씩 일치시킵니다. 해당 핸들러를 찾으십시오. 다른 Catch 문장 블록은 실행되지 않습니다. Try Statement 블록에서 예외가 발생한 후 명령문은 실행되지 않습니다. Catch Statement 블록이 실행되면 최종 명령문 블록의 명세서가 실행되며 마지막으로 마지막 명령문 블록이 실행 된 후 명세서가 실행됩니다.
Try, Catch 및 마지막으로 진술 블록의 실행에 대한 그림 :
그림 2는 시도, 캐치 및 마침내 문을 실행하는 것을 보여줍니다.
3.2 예외를 던집니다
모든 Java 코드는 다음과 같은 예외를 제외 할 수 있습니다. 그것이 누구라도 Java 던지기 진술을 통해 예외를 던질 수 있습니다. 방법에서 던져진 예외는 Throws 절과 함께 사용해야합니다.
1. 던지기 예외를 던집니다
메소드에 예외가있을 수 있지만 그러한 예외를 처리 할 수있는 기능이없는 경우, THROWS 절을 사용하여 메소드 선언에서 THROWN 예외를 선언 할 수 있습니다. 예를 들어, 달리면 자동차가 실패 할 수 있으며 자동차 자체 가이 실패를 처리 할 수 없으므로 운전자가 처리 할 수 없습니다.
던지기 진술은 메소드가 정의 될 때 던질 예외 유형을 선언하는 데 사용됩니다. 예외 예외 유형이 던지면 메소드는 모든 예외를 던지라고 선언됩니다. 쉼표를 사용하여 여러 예외를 분할 할 수 있습니다. Throws 문의 구문 형식은 다음과 같습니다.
MethodName은 Exception1, Exception2, .., Exceptionn {} 던지기 메소드 이름 Exception1, Exception2, ..., Exception이 발생하는 예외 목록 이후에 던질 예외입니다. 메소드가 예외 예외 목록을 던지면 메소드는 이러한 유형 및 하위 클래스 유형의 예외를 처리하지 않지만 메소드를 호출하는 메소드에 던져지고 처리됩니다. 예를 들어:
Java.Lang.Exception 가져 오기; 공개 클래스 testException {static void pop ()는 Negativearraysizeexception {// 메소드를 정의하고 Negativearraysizeexception 예외를 던지고 int [] arr = new int [-3]; // 배열 생성} public static void main (string [] args) {// main method try {// stret 핸들 예외 정보 pop (); // pop () 메소드} catch (negativearraysizeexception e) {system.out.println ( "pop () 메소드에 의해 던져진 예외"); // 출력 예외 정보}}}Throws 키워드를 사용하여 발신자에게 예외를 던지면 발신자가 예외를 처리하지 않으려면 계속해서 던질 수 있지만 결국 예외를 처리 할 수있는 발신자가 있어야합니다.
POP 메소드는 예외는 NegativeArraysizeexception을 처리하지 않지만 기본 기능에 의해 처리됩니다.
예외를 던지기위한 던지기 규칙 :
1) 확인되지 않은 예외, 즉 오류, runtimeexception 또는 하위 클래스 인 경우, Throws 키워드를 사용하지 않고 제외 할 예외를 선언 할 수 있으며 컴파일은 여전히 원활하게 전달되지만 런타임에 시스템에 의해 던져집니다.
2) 방법으로 던질 수있는 확인 된 예외는 선언되어야합니다. 즉, 메소드에 점검 가능한 예외가있을 수있는 경우, 트리 캐치 문으로 잡히거나 던질 조항 선언으로 던질 수 있습니다. 그렇지 않으면 컴파일 오류가 발생합니다.
3) 예외가 발생하는 경우에만 방법의 발신자는 예외를 처리하거나 다시 던져야합니다. 메소드 발신자가 예외를 처리 할 수 없으면 전체를 삼키지 않고 계속 던져야합니다.
4) 호출 방법은 확인 가능한 예외 처리 및 선언 규칙을 따라야합니다. 메소드를 덮어 쓰기하면 덮어 쓰기 메소드와 다른 예외를 선언 할 수 없습니다. 선언 된 예외는 재정의 메소드에 의해 선언 된 예외의 유사하거나 서브 클래스 여야합니다.
예를 들어:
void method1 ()는 ioexception {} // 법적 // 컴파일 오류를 던지고, void method2 () {method1 (); } // legal, ioexception void method3 ()를 던지라고 선언합니다. } // 법적, 예외를 던지라고 선언하고, IoException은 예외 void method4 ()의 서브 클래스입니다. 예외 {method1 (); } // legal, 캡처 ioException void method5 () {try {method1 (); } catch (ioException e) {…}} // 컴파일 오류에 대해서는 예외를 포착하거나 선언해야합니다. } catch (ioexception e) {wrach new exception ();}} // 법적, 선언 예외 void method7 () throws exception {try {method1 (); } catch (ioException e) {throw new Exception ();}} 방법에서 예외가 발생할 수 있다고 결정하는 기초는 다음과 같습니다.
1)이 방법에는 던지기 진술이 있습니다. 예를 들어, 위 메소드 7 () 메소드의 캐치 코드 블록에는 던지는 문이 있습니다.
2) 다른 방법은 호출되고 다른 방법은 Throws 절을 사용하여 예외를 선언합니다. 예를 들어, Method3 () 메소드는 Method1 () 메소드를 호출하고 Method1 () 메소드는 IOException이 재투를 겪으므로 Method3 () 메소드에서 IOException이 발생할 수 있습니다.
2. 던지기를 사용하여 예외를 제외하십시오
던지기는 항상 기능 본문에 나타나고 Throwable 유형을 제외하고 사용됩니다. 이 프로그램은 던지기 직후에 종료됩니다. 진술은 실행 될 수 없으며,이를 포함하는 모든 시도 블록 (아마도 상위 수준의 호출 함수)에서 내부에서 일치하는 Catch 절을 포함하는 시도 블록을 찾습니다.
예외는 예외 클래스의 인스턴스 객체라는 것을 알고 있으며, Throw 문을 통해 던질 예외 클래스의 인스턴스 객체를 만들 수 있습니다. 이 진술의 구문 형식은 다음과 같습니다.
새로운 예외 이름을 던지십시오.
예를 들어, ioException 클래스의 예외 객체를 던지십시오.
새로운 ioexception을 던지십시오.
클래스 던지기 가능 또는 서브 클래스를 던질 수있는 인스턴스 객체 만 던지는 경우에 주목해야합니다. 다음 작업이 잘못되었습니다.
새 문자열을 던지십시오 ( "예외");
문자열은 던질 수있는 클래스의 서브 클래스가 아니기 때문입니다.
확인 예외가 발생하면 메소드가 메소드 헤더에 던져 질 수있는 예외 유형을 선언해야합니다. 이 방법의 발신자는 또한 던진 예외를 처리하는지 확인해야합니다.
모든 메소드가 획득 한 예외 계층을 레이어별로 던지면 JVM은 결국 처리하고 처리는 매우 간단하여 예외 메시지 및 스택 정보를 인쇄하는 것입니다. 오류 또는 runtimeexception이 발생하면 메소드의 발신자는 예외를 처리 할 수있는 옵션이 있습니다.
패키지 테스트; Java.Lang.Exception 가져 오기; 공개 클래스 testException {static int quotient (int x, int y)는 myexception을 던지려고 {// (y <0) {// 매개 변수가 0 미만인지 결정하는 경우 예외를 던지기 위해 메소드를 정의합니다. // 예외 정보} return x/y; // return value} public static void main (String args []) {// 메인 메소드 int a = 3; int b = 0; try {// try statement는 예외가있을 수있는 진술이 포함되어 int result = quotient (a, b); // call method QUOTENTENT ()} catch (myException e) {// 사용자 지정 예외 시스템 핸들. out.println (e.getMessage ()); // 출력 예외 정보} catch (arithmeticexception e) {// arithmeticexception exception system.out.println ( "divorceipt가 0"); // 출력 프롬프트 정보} catch (예외 e) {// 기타 예외 처리 System.out.println ( "프로그램에서 다른 예외가 발생 함"); // 출력 프롬프트 정보}}} class myException 확장 예외 {// 사용자 정의 예외 클래스 문자열 메시지 작성; // 문자열 유형 정의 변수 public myException (String errormessagr) {// 부모 클래스 메소드 메시지 = errormessagr; } public String getMessage () {// getMessage () 메소드 리턴 메시지를 재정의합니다. }}3.3 예외 체인
1) Quotient (3, -1)이 호출되면 MyException 예외가 발생하고 프로그램이 Catch (MyException e) 코드 블록으로 전송됩니다.
2) Quotient (5,0)이 호출되면 "분배기는 0"오류로 인해 ArithMeticexception 예외가 제기됩니다. 런타임 예외 클래스에 속하며 Java 런타임 시스템에 의해 자동으로 던져집니다. Quotient () 메소드는 ArithMeticeXception 예외를 포착하지 않습니다. Java 런타임 시스템은 메소드 호출 스택을 따라 기본 메소드를 검색하고 Quotient () 메소드의 발신자에게 버린 예외를 업로드합니다.
int result = quotient (a, b); // 호출 메소드 Quotient ()
이 명령문은 시도 모니터링 영역에 있기 때문에 "Divider is 0"이있는 Arithmeticexception은 Java 런타임 시스템에 의해 뒤로 던져져 Catch 절과 일치합니다.
catch (arithmeticexception e) {// artermeticexception exception system.out.println ( "divisor는 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을 더 지원하기를 바랍니다.