비정상적인 영어 단어는 예외이며 문자 번역은 "사고, 예외"를 의미하며, 이는 비정상적인 상황을 의미합니다. 실제로, 예외는 프로그램 로직 오류 및 시스템 오류를 포함한 본질적으로 프로그램 오류입니다.
서문
모든 사람은 Java Exception Handling에 익숙하며 일반적으로 두 가지 요점이 있습니다.
1. 던지기 예외 : 던지기 예외
Class SimpleException {public void a ()는 예외를 던집니다. };}2. 배치 예외 :
public class myException {public static void main (String [] args) {myException e = new myException (); simplexception se = new simplexception (); try {se.a (); } catch (예외 e1) {e1.printstacktrace (); }}} class simplexception {public void a () throws exception {strash new exception (); };}이 기사에서는이 자세한 내용에 대한 몇 가지 세부 사항에 대해 논의 할 것입니다.
두 개의 사용자 정의 예외 클래스
Java Language는 많은 예외 클래스를 제공하지만 때로는 코드 작성의 편의를 위해 예외 클래스를 사용자 정의해야합니다.
Class SimpleException 확장 예외 {};
창조 후, 우리는 시도 Catch를 사용하여 그것을 캡처 할 수 있습니다.
public class myException {public static void main (String [] args) {myException e = new myException (); {ea (); } catch (simplexception e1) {e1.printstacktrace (); }} public void a ()는 simplexception을 던지는 것입니다. }} class simplexception 확장 예외 {};MyException에서 메소드 a ()를 정의하고 SimpleException 예외를 던지게 한 다음 Main () 에서이 메소드를 호출하고 시도 Catch를 사용 하여이 예외를 포착합니다.
myException.a (myException.java:15)에서 simplexception.main.main (myException.java:8)에서 sun.reflect.nativeMethodaccessorimpl.invoke0 (기본 메소드)에서 sun.reflect.nativeMethodaccessorimpl.invoke (nativemethodcessorimplpl.jecsorimpl.) sun.reflect.delegatingMethodaccessorimpl.invoke (java.lang.reflect.method.invoke (method.java:606)에서 java.rt.application.appmain.main (appmmain.java) 0
컴파일 및 실행 후 결과는 주로 처음 3 줄을 기반으로합니다. 다음은 설명 할 몇 가지 요점입니다.
1. 예외 유형 지정 : (예외 사양)
메소드에서 예외를 던져야 할 때, 우리는 던지기를 사용하고 예외 클래스의 인스턴스를 추가합니다. 이 프로그램은 클라이언트 프로그램 (이 코드를 호출하는 프로그램)에 해당하는 예외를 던지고 여기에서 종료합니다 (반품에 해당). 또한이 메소드를 정의 할 때 예외 유형을 지정해야합니다. 예를 들어 다음 코드는 Simple Oxception 예외를 던집니다.
공개 void a ()는 Simplexception을 던집니다
2. 여러 예외를 던지기 :
public void a ()는 Simplexception, axception, bexception {throw new simplexception (); }다른 예외 클래스는 쉼표로 분리 할 수 있습니다. 이 경우 각 예외 클래스 인스턴스를 던질 필요는 없지만 클라이언트 코드는 각 예외 클래스를 포착해야합니다.
public class myException {public static void main (String [] args) {myException e = new myException (); {ea (); } catch (simplexception e1) {e1.printstacktrace (); } catch (bexception e1) {e1.printstacktrace (); } catch (axception e1) {e1.printstacktrace (); }} public void a ()는 simplexception, axception, bexception {wash new simplexception (); }} class simplexception 확장 예외 {}; class axception 확장 예외 {} class bexception exceptens exception {} 세 개의 스택 추적
예외를 던지거나 잡기 및 취급 예외에 관계없이, 우리의 목적은보다 강력한 프로그램을 작성하는 것입니다.이 프로그램은 Java 예외 메커니즘이 제공하는 예외 정보에 크게 의존하며 캐리어는 스택 트레이스입니다.
이전 코드에서는 PrintStackTrace ()를 직접 사용하여 예외 정보를 인쇄합니다. 실제로 GetStackTrace () 메소드를 사용하여 StackTraceElement 모음을 얻을 수도 있습니다. 손에 아이디어가있는 경우 먼저 StackTraceElement 클래스를 검색 할 수 있으며 인터페이스 직렬화가 가능하다는 것을 찾은 다음 클래스 설명을 살펴보십시오.
/** * {@link * Throwable#getStacktrace ()}에 의해 반환 된 스택 추적의 요소. 각 요소는 단일 스택 프레임을 나타냅니다. * 스택의 상단에있는 프레임을 제외한 모든 스택 프레임을 제외한 모든 스택 프레임은 * 메소드 호출을 나타냅니다. 스택 상단의 프레임은 스택 추적이 생성 된 * 실행 지점을 나타냅니다. 일반적으로 * 이것은 스택 트레이스 *에 해당하는 던지기 가능한 지점입니다. * * @Since 1.4 * @Author Josh Bloch */이 클래스의 각 인스턴스는 스택 프레임을 나타내는 스택 트레이스의 요소이며 스택 추적은 getStacktrace () 메소드에 의해 반환됩니다. 다음을 여러 번 번역하려고했지만 좋지 않다고 느꼈으므로 코드를 직접 작성하여 설명 할 수있었습니다.
public class myException {public static void main (String [] args) {myException e = new myException (); ea (); public void a () {try {throw new exception (); } catch (예외 e) {stackTraceElement [] ste = e.getStackTrace (); System.out.println (Ste.length); }}}메소드 A를 정의하고 캡처하는 동안 예외 예외를 던지고 GetStackTrace () 메소드를 통해 StackTraceElement 배열을 가져 와서 배열의 길이를 인쇄합니다.
7
Exit 코드 0으로 프로세스가 완료되었습니다
우리는 코드를 조금 변경하고 예외를 포착하는 것을 중지했습니다. 우리는 a를 호출하는 동안 예외를 포착 할 수 있도록 메소드 B를 재정의합니다.
public class myException {public static void main (String [] args) {myException e = new myException (); eb (); } public void b () {try {a (); } catch (예외 e) {stackTraceElement [] ste = e.getStackTrace (); System.out.println (Ste.length); }} public void a () throws exception {throw new exception (); }}결과는 다음과 같습니다.
8
Exit 코드 0으로 프로세스가 완료되었습니다
걱정하지 마세요. 흥미로운 것을 살펴 보겠습니다.
public class myException {public static void main (String [] args) {myException Exception = new MyException (); try {Exception.c (); } catch (예외 e) {stackTraceElement [] ste = e.getStackTrace (); System.out.println (Ste.length); System.out.println("---------------------------------------------------------------"); for (stackTraceElement s : e.getStackTrace ()) {System.out.println (s.getClassName ()+": 메소드"+s.getMethodName ()+"at"+s.getLineNumber ()); } System.out.println("---------------------------------------------------------------"); }} public void c ()는 예외를 던져 {try {a (); } catch (예외 e) {Throw e; }} public void a () throws exception {throw new exception (); }}결과는 다음과 같습니다.
8 ------------------------------------------------------------------------------------------------------------------------------------ Line43MyException의 메소드 A : Line39MyException의 메소드 C : Line9sun.reflect.nativeMeThodAccessorImpl의 메소드 메소드 : Line-2Sun.reflect.nativeMethododaccessorimpl의 메소드 invoke0 : Method Invoke at line57sun.reflect.DelegatingMethodAccessorImpl:method invoke at line43java.lang.reflect.Method:method invoke at line606com.intellij.rt.execution.application.AppMain:method main at line144---------------------------------------------------------------Process finished with exit code 0
즉, getStacktrace ()는 스택을 반환합니다. 여기에는 발신자 (main ())에서 초기 던지기 예외 (a ())까지 기본 정보가 포함되어 있습니다. 위의 코드에서는 C 메소드에서 A 메소드를 호출 할 때 예외를 포착하고 던지기를 통해 다시 던지십시오. C 메소드를 호출하는 방법은 예외를 포착하고 처리 할 수 있거나, 더 높은 수준의 발신자 (스택 하단 근처)를 처리 할 수 있도록 계속 던질 수 있습니다. Rethrow는 매우 편리하지만 몇 가지 문제가 있습니다. 다음 코드를 살펴 보겠습니다.
public class myException {public static void main (String [] args) {myException Exception = new MyException (); try {Exception.c (); } catch (예외 e) {e.printstacktrace (System.out); }} public void c ()는 예외를 던져 {try {a (); } catch (예외 e) {Throw e; }} public void a ()는 예외를 던지려고 {new Exception ( "예외"); }} java.lang.exception : myException.c (myException.java:30)에서 myException.a (myException.java:40)의 a ()에서 예외 (myException.java:21).우리는 c에서 e를 다시 줄이고 main에서 e.printstacktrace ()를 사용하여 인쇄합니다. 인쇄 된 스택 트레이스는 여전히 a에 속한다는 것을 알 수 있습니다. 스택 추적을 C로 전환하려면 다음과 같이 쓸 수 있습니다.
public class myException {public static void main (String [] args) {myException Exception = new MyException (); try {Exception.c (); } catch (예외 e) {e.printstacktrace (System.out); }} public void c ()는 예외를 던져 {try {a (); } catch (예외 e) {// e; 던지기 (예외) e.fillinstacktrace (); }} public void a ()는 예외를 던지려고 {new Exception ( "예외"); }} java.lang.exception : myException.c (myException.java:22)의 a ()에서 예외 myException.Main (myException.java:10). 4 개의 예외 체인
시나리오를 살펴 보겠습니다.
public class testException {public static void main (String [] args) {testException testException = new TestException (); try {testException.c (); } catch (cexception e) {e.printstacktrace (); }} public void a ()는 axception {axception aexception = new aexception ( "이것은 예외"); exception을 던지십시오. } public void b ()는 bexception {try {a (); } catch (exception e) {새 bexception 던지기 ( "이것은 b 예외"); }} public void c ()는 cexception {try {b (); } catch (bexception e) {Throw new Cexception ( "이것은 C 예외"); }}} class aexception 확장 예외 {public aexception (string msg) {super (msg); }} class bexception 확장 예외 {public bexception (string msg) {super (msg); }} class cexception 확장 예외 {public cexception (string msg) {super (msg); }}세 가지 예외 클래스 Aexception, Bexception 및 Cexception이 생성 된 다음 A ()에 Aexception이 발생하고 Aexception이 B ()에 포착되어 Bexception이 던져지고 마지막으로 Bexception이 C ()에 잡히고 Cexception이 던져지고 결과는 다음과 같이 인쇄됩니다.
cexception : testException.main (testException.java:8)에서 testException.c (testException.java:31)의 C 예외입니다.
좋아, 우리는 Cexception, Axception 및 Bexception의 정보 만 손실되었으며 예외 체인의 기능이 나오면 코드를 참조하십시오.
public class testException {public static void main (String [] args) {testException testException = new TestException (); try {testException.c (); } catch (cexception e) {e.printstacktrace (); }} public void a ()는 axception {axception aexception = new aexception ( "이것은 예외"); exception을 던지십시오. } public void b ()는 bexception {try {a (); } catch (exception e) {// 새 bexception 던지기 ( "이것은 b 예외입니다"); bexception bexception = 새로운 bexception ( "이것은 b 예외"); bexception.initcause (e); Bexception을 던지십시오. }} public void c ()는 cexception {try {b (); } catch (bexception e) {// 새 cexception 던지기 ( "이것은 c 예외"); cexception cexception = 새로운 cexception ( "이것은 c 예외"); cexception.initcause (e); Cexception을 던지십시오. }}} class aexception 확장 예외 {public aexception (string msg) {super (msg); }} class bexception 확장 예외 {public bexception (string msg) {super (msg); }} class cexception 확장 예외 {public cexception (string msg) {super (msg); }}initCause () 메소드를 사용하여 예외 정보를 연결하고 결과는 다음과 같습니다.
cexception : 이것은 testexception.c (testexception.java:35)에서 c 예외입니다. testexception.main (testexception.java:8)에서 sun.reflect.nativemethodaccessorimpl.invoke0 (native method)에서 sun.reflect.nativemedaccessorimpl.invoke (natovemethodoccesorimpl.). sun.reflect.delegatingMethodaccessorimpl.invoke (java.lang.reflect.method.invoke (method.java:606)에서 java.lang.reflect.invoke (method.java:606)의 appmain (appmmain.java:144)에서 : Bexception : TestException.c (TestException.java:32)에서 testException.b (testException.java:24)의 B 예외입니다.
5 개의 PostScript
사실, Java 예외 처리에 대해 논의 할 것이 여전히 많지만 경험이 제한되어 있기 때문에 너무 깊이 이해할 수 없으며 가장 일반적으로 사용되는 것은 다음과 같습니다.
시도 {...} catch (예외 e) {... ...} 마지막으로 {// 예외가 잡히거나 처리 될지 여부에 관계없이 IO 운영 폐쇄}}}}그러나 무엇이든, 우리는 여전히 예외 메커니즘을 제공해 주신 Java에게 감사해야합니다. 그것은 때때로 우리를 안내하고 인코딩 할 때 우리를 덜 지루하게 만드는 장로와 같습니다. :)