วิธีสร้างข้อยกเว้นแบบกำหนดเองใน Java [ปิด]

เราจะสร้างข้อยกเว้นที่กำหนดเองใน Java ได้อย่างไร

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

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); }
}

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

public void calculate(int i) throws FooException, IOException;

... และโค้ดที่เรียกใช้เมธอดนี้ต้องจัดการหรือเผยแพร่ข้อยกเว้นนี้ (หรือทั้งสองอย่าง):

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);
}

คุณจะสังเกตเห็นในตัวอย่างข้างต้นที่IOExceptionถูกจับได้และ rethrown FooExceptionเป็น นี่เป็นเทคนิคทั่วไปที่ใช้ในการสรุปแค็ปซูล (โดยทั่วไปเมื่อใช้งาน API)

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

public class FooRuntimeException extends RuntimeException {
  ...
}

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

public void calculate(int i) {
  if (i < 0) {
    throw new FooRuntimeException("i < 0: " + i);
  }
}

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

java.lang.Throwableระดับเป็นรากของข้อผิดพลาดและข้อยกเว้นทั้งหมดที่สามารถโยนภายใน Java java.lang.Exceptionและมีทั้งคลาสย่อยjava.lang.Error Throwableสิ่งใดก็ตามที่คลาสย่อยThrowableนั้นอาจถูกโยนหรือถูกจับได้ อย่างไรก็ตามโดยทั่วไปแล้วมันเป็นวิธีปฏิบัติที่ไม่ดีในการจับหรือโยนErrorเนื่องจากสิ่งนี้ใช้เพื่อแสดงถึงข้อผิดพลาดภายใน JVM ที่ไม่สามารถ "จัดการ" โดยโปรแกรมเมอร์ (เช่นOutOfMemoryError) ในทำนองเดียวกันคุณควรหลีกเลี่ยงการจับThrowableซึ่งอาจส่งผลให้คุณจับErrorนอกเหนือจากExceptions

public class MyException extends Exception {
        // special exception code goes here
}

โยนมันเป็น:

 throw new MyException ("Something happened")

จับเป็น:

catch (MyException e)
{
   // something
}

สำหรับข้อยกเว้นที่ตรวจสอบ:

public class MyCustomException extends Exception { }

ในทางเทคนิคสิ่งใดก็ตามที่ขยายออกไปThrowableอาจเป็นตัวโยน แต่โดยทั่วไปแล้วข้อยกเว้นจะเป็นส่วนขยายของExceptionคลาสเพื่อให้พวกเขากำลังตรวจสอบข้อยกเว้น (ยกเว้น RuntimeException หรือคลาสที่ยึดตามซึ่งไม่ได้ตรวจสอบ) ซึ่งตรงข้ามกับประเภททั่วไปErrors ซึ่งมักจะไม่ใช่สิ่งที่ออกแบบมาให้จัดการอย่างงดงามเกินกว่า JVM ภายใน

คุณสามารถสร้างข้อยกเว้นที่ไม่เป็นสาธารณะได้ แต่จากนั้นคุณสามารถใช้ได้เฉพาะในแพ็คเกจที่กำหนดไว้เท่านั้น

เท่าที่มีการขว้าง / รับข้อยกเว้นแบบกำหนดเองมันทำงานเหมือนกับที่มีในตัว - ส่งผ่าน

throw new MyCustomException()

และจับผ่าน

catch (MyCustomException e) { }