To define a checked exception you c

To define a checked exception you create a subclass (or hierarchy of subclasses) of java.lang.Exception. For example:

public class FooException extends Exception {
public FooException() { super(); }
public FooException(String message) { super(message); }
public FooException(String message, Throwable cause) { super(message, cause); }
public FooException(Throwable cause) { super(cause); }
}
Methods that can potentially throw or propagate this exception must declare it:

public void calculate(int i) throws FooException, IOException;
... and code calling this method must either handle or propagate this exception (or both):

try {
int i = 5;
myObject.calculate(5);
} catch(FooException ex) {
// Print error and terminate application.
ex.printStackTrace();
System.exit(1);
} catch(IOException ex) {
// Rethrow as FooException.
throw new FooException(ex);
}
You'll notice in the above example that IOException is caught and rethrown as FooException. This is a common technique used to encapsulate exceptions (typically when implementing an API).

Sometimes there will be situations where you don't want to force every method to declare your exception implementation in its throws clause. In this case you can create an unchecked exception. An unchecked exception is any exception that extends java.lang.RuntimeException (which itself is a subclass of java.lang.Exception):

public class FooRuntimeException extends RuntimeException {
...
}
Methods can throw or propagate FooRuntimeException exception without declaring it; e.g.

public void calculate(int i) {
if (i < 0) {
throw new FooRuntimeException("i < 0: " + i);
}
}
Unchecked exceptions are typically used to denote a programmer error, for example passing an invalid argument to a method or attempting to breach an array index bounds.

The java.lang.Throwable class is the root of all errors and exceptions that can be thrown within Java. java.lang.Exception and java.lang.Error are both subclasses of Throwable. Anything that subclasses Throwable may be thrown or caught. However, it is typically bad practice to catch or throw Error as this is used to denote errors internal to the JVM that cannot usually be "handled" by the programmer (e.g. OutOfMemoryError). Likewise you should avoid catching Throwable, which could result in you catching Errors in addition to Exceptions.

ผลลัพธ์ (ไทย) 1:

การกำหนดข้อยกเว้นการตรวจสอบ คุณสร้างย่อย (หรือลำดับชั้นของระดับชั้นย่อย) ของ java.lang.Exception ตัวอย่าง:คลาสาธารณะ FooException ขยาย{ข้อยกเว้น FooException() สาธารณะ {super (); } FooException(String message) สาธารณะ {super(message); } FooException สาธารณะ (สายอักขระข้อความ สาเหตุ Throwable) {ซูเปอร์ (ข้อความ สาเหตุ); } FooException(Throwable cause) สาธารณะ {super(cause); }}วิธีการที่สามารถอาจโยน หรือแพร่กระจายข้อยกเว้นนี้ต้องประกาศเรื่อง:ยกเลิก calculate(int i) สาธารณะพ่น FooException, IOException... และรหัสที่เรียกวิธีการนี้ต้องจัดการ หรือแพร่กระจายข้อยกเว้นนี้ (หรือทั้งสอง):ลอง{ int ฉัน = 5 myObject.calculate(5)} {(FooException ex) จับ พิมพ์ข้อผิดพลาด และจบการทำงานของโปรแกรมประยุกต์ ex.printStackTrace() System.exit(1)} {(IOException อดีต) จับ Rethrow เป็น FooException โยน FooException(ex) ใหม่}คุณจะเห็นในตัวอย่างข้างบนว่า IOException จับ และ rethrown เป็น FooException นี้เป็นเทคนิคทั่วไปที่ใช้ในการซ่อนข้อยกเว้น (โดยปกติเมื่อใช้ API การ)บางครั้งจะมีสถานการณ์ที่คุณไม่ต้องการบังคับให้ทุกวิธีประกาศยกเว้นการนำไปใช้ในส่วนคำสั่ง throws ของ ในกรณีนี้ คุณสามารถสร้างข้อยกเว้นยก ข้อยกเว้นยกเป็นข้อยกเว้นใด ๆ ที่ขยาย java.lang.RuntimeException (ที่ตัวเองเป็นย่อยของ java.lang.Exception):RuntimeException {ขยายคลาสาธารณะ FooRuntimeException ...}วิธีสามารถโยน หรือแพร่กระจายข้อยกเว้น FooRuntimeException ไม่ประกาศนั้น เช่น{ยกเลิก calculate(int i) สาธารณะ ถ้า (ผม < 0) { โยนใหม่ FooRuntimeException (" i < 0: " + i); }}โดยทั่วไปใช้ยกเว้นการแสดงพลาดโปรแกรมเมอร์ ผ่านอาร์กิวเมนต์ไม่ถูกต้องเช่น วิธีการ หรือการพยายามละเมิดขอบเขตของดัชนีอาร์เรย์การคลาส java.lang.Throwable เป็นรากของข้อผิดพลาดและข้อยกเว้นที่สามารถโยนในจาวาทั้งหมด java.lang.Exception และ java.lang.Error ได้ทั้งสองชั้น Throwable อะไรที่ชั้น Throwable อาจถูกโยน หรือจับ อย่างไรก็ตาม จะปฏิบัติโดยทั่วไปจะไม่จับ หรือโยนข้อผิดพลาดนี้จะใช้เพื่อแสดงข้อผิดพลาดภายใน JVM ที่ไม่มักจะถูก "จัดการ" โดยนักเขียนโปรแกรม (เช่น OutOfMemoryError) ในทำนองเดียวกัน คุณควรหลีกเลี่ยงการจับ Throwable ซึ่งอาจทำให้คุณจับผิดนอกจากข้อยกเว้น

ผลลัพธ์ (ไทย) 2:

เพื่อกำหนดข้อยกเว้นการตรวจสอบคุณสร้างคลาส (หรือลำดับชั้นของ subclasses) ของ java.lang.Exception ตัวอย่างเช่นFooException ระดับสาธารณะขยายข้อยกเว้น { FooException สาธารณะ () {ซุปเปอร์ (); } FooException สาธารณะ (ข้อความ String) {ซุปเปอร์ (ข้อความ); } FooException สาธารณะ (ข้อความ String สาเหตุ Throwable) {ซุปเปอร์ (ข้อความสาเหตุ); } FooException สาธารณะ (สาเหตุ Throwable) {ซุปเปอร์ (สาเหตุ); } } วิธีการที่อาจจะโยนหรือเผยแพร่ข้อยกเว้นนี้ต้องประกาศมันคำนวณโมฆะสาธารณะ (int i) พ่น FooException, IOException; ... และรหัสเรียกวิธีการนี้จะต้องจัดการหรือเผยแพร่ข้อยกเว้นนี้ (หรือทั้งสอง): try { int i = 5; myObject.calculate (5); } catch (FooException อดีต) { // ข้อผิดพลาดพิมพ์และยุติการประยุกต์ใช้. ex.printStackTrace (); System.exit (1); } catch (IOException อดีต) { // rethrow เป็น . FooException โยน FooException ใหม่ (อดีต); } คุณจะสังเกตเห็นในตัวอย่างข้างต้นที่ IOException ถูกจับได้และเป็น rethrown FooException นี้เป็นเทคนิคที่ใช้ในการห่อหุ้มข้อยกเว้น (โดยปกติเมื่อใช้ API). บางครั้งจะมีสถานการณ์ที่คุณไม่ต้องการที่จะบังคับให้ทุกวิธีที่จะประกาศการดำเนินการตามข้อยกเว้นของคุณในข้อที่พ่น ในกรณีนี้คุณสามารถสร้างข้อยกเว้นไม่ถูกตรวจสอบ ยกเว้นไม่ถูกตรวจสอบเป็นข้อยกเว้นใด ๆ ที่ขยาย java.lang.RuntimeException (ซึ่งตัวเองเป็น subclass ของ java.lang.Exception): FooRuntimeException ระดับสาธารณะขยาย RuntimeException { ... } วิธีสามารถโยนหรือเผยแพร่ยกเว้น FooRuntimeException โดยไม่ต้องประกาศว่า; เช่นการคำนวณโมฆะสาธารณะ (int i) { if (i <0) { โยน FooRuntimeException ใหม่ ("i <0:" + i); } } ข้อยกเว้นไม่ได้ตรวจสอบมักจะใช้เพื่อแสดงถึงข้อผิดพลาดโปรแกรมเมอร์เช่นผ่านอาร์กิวเมนต์ที่ไม่ถูกต้อง วิธีการหรือความพยายามที่จะละเมิดขอบเขตดัชนีอาร์เรย์. ระดับ java.lang.Throwable เป็นรากของข้อผิดพลาดและข้อยกเว้นที่จะถูกโยนภายใน Java java.lang.Exception และ java.lang.Error มีทั้ง subclasses ของ Throwable อะไรที่คลาสย่อย Throwable อาจจะโยนหรือจับ แต่ก็เป็นปกติการปฏิบัติที่ดีที่จะจับหรือโยนความผิดพลาดเช่นนี้ถูกนำมาใช้เพื่อแสดงถึงความผิดพลาดภายใน JVM ที่มักจะไม่สามารถ "จัดการ" โดยโปรแกรมเมอร์ (เช่น OutOfMemoryError) ในทำนองเดียวกันคุณควรหลีกเลี่ยงการจับ Throwable ซึ่งอาจส่งผลให้คุณจับข้อผิดพลาดที่นอกเหนือไปจากข้อยกเว้น

ผลลัพธ์ (ไทย) 3:

การกำหนดตรวจสอบข้อยกเว้น คุณสร้าง คลาสย่อย ( หรือลำดับชั้นของคลาส ) ของ java.lang.exception . ตัวอย่าง :

ชื่อคลาส fooexception ขยายข้อยกเว้น {

} { super() สาธารณะ fooexception() ; fooexception สาธารณะ ( String ข้อความ ) { ซุปเปอร์ ( ข้อความ ) ; }
สาธารณะ fooexception ( สตริงข้อความ throwable เหตุ ) { สุด ( เพราะข้อความ ) ; }
สาธารณะ fooexception ( เพราะ throwable ) { ซุปเปอร์ ( สาเหตุ ) } }

วิธีการที่สามารถโยน หรือเผยแพร่ ข้อยกเว้นนี้จะต้องแจ้ง :

ถือเป็นโมฆะสาธารณะ ( int ) พ่น fooexception คำนวณ ioexception , ;
. . . . . . . และรหัสเรียกวิธีการนี้ต้องจัดการกับข้อยกเว้นนี้หรือป่าว ( หรือทั้งสองอย่าง ) :

ลอง {
1 = 5 ;
myobject คํานวณ ( 5 ) ;
} {
จับอดีต fooexception ) / / พิมพ์ข้อผิดพลาดและยุติการประยุกต์ใช้ เช่น printstacktrace()

; ระบบ ออก ( 1 )
จับ } ( ioexception อดีต ) {
/ / rethrow เป็น fooexception .
โยนใหม่ fooexception ( อดีต ) ;
}
คุณจะสังเกตได้ว่าในตัวอย่างข้างต้นที่ ioexception ถูกจับและ rethrown เป็น fooexception . นี้เป็นเทคนิคทั่วไปที่ใช้เพื่อสรุปข้อยกเว้น ( โดยทั่วไปแล้ว เมื่อมีการใช้ API ) .

บางครั้งอาจจะมีสถานการณ์ที่คุณไม่ต้องการที่จะบังคับให้ทุกวิธีที่จะประกาศข้อยกเว้นในการโยนของข้อ ในกรณีนี้คุณสามารถสร้างข้อยกเว้นโดยไม่ตรวจสอบ ข้อยกเว้นใด ๆไม่ได้เป็นข้อยกเว้นสำหรับ java.lang.runtimeexception ( ซึ่งตัวเองเป็น subclass ของจาวา lang.exception ) :

ชื่อคลาส fooruntimeexception ขยาย runtimeexception {

}
. . . . . . .วิธีการโยน หรือเผยแพร่ fooruntimeexception ข้อยกเว้นโดยไม่ต้องประกาศมัน เช่น

ประชาชนเป็นโมฆะคำนวณ ( int ) {
ถ้า ( < 0 ) {
fooruntimeexception โยนใหม่ ( " ฉัน < 0 : " ) ; } }


ไม่ได้มักจะมีข้อยกเว้นที่ใช้แสดงโปรแกรมเกิดข้อผิดพลาด ตัวอย่างเช่นผ่านอาร์กิวเมนต์ ที่ไม่ถูกต้องกับวิธีการหรือพยายามที่จะละเมิดดัชนี array ขอบเขต .

java.lang .throwable คลาสคือรากของข้อผิดพลาดและข้อยกเว้นที่สามารถโยนใน Java และ java.lang.exception java.lang.error ทั้งคลาสของ throwable . อะไรที่ย่อย throwable อาจถูกโยนหรือจับ อย่างไรก็ตามมันมักจะไม่ดีฝึกจับหรือโยนข้อผิดพลาดนี้ถูกใช้เพื่อแสดงข้อผิดพลาดภายในใน JVM ที่ไม่สามารถจะ " จัดการ " โดยโปรแกรม ( เช่นoutofmemoryerror ) เช่นเดียวกันคุณควรหลีกเลี่ยงการจับ throwable ซึ่งอาจส่งผลให้คุณจับข้อผิดพลาดและข้อยกเว้น