建设本身的违例

并不必然非要利用Java违例。这一点必需把握，因为常常都需要建设本身的违例，以便指出本身的库大概生成的一个非凡错误——但建设Java分级布局的时候，这个错误是无法预知的。
为建设本身的违例类，必需从一个现有的违例范例担任——最亏得寄义上与新违例近似。担任一个违例相当简朴：
 

//: Inheriting.java
// Inheriting your own exceptions

class MyException extends Exception {
  public MyException() {}
  public MyException(String msg) {
    super(msg);
  }
}

public class Inheriting {
  public static void f() throws MyException {
    System.out.println(
      "Throwing MyException from f()");
    throw new MyException();
  }
  public static void g() throws MyException {
    System.out.println(
      "Throwing MyException from g()");
    throw new MyException("Originated in g()");
  }
  public static void main(String[] args) {
    try {
      f();
    } catch(MyException e) {
      e.printStackTrace();
    }
    try {
      g();
    } catch(MyException e) {
      e.printStackTrace();
    }
  }
} ///:~

担任在建设新类时产生：
 

class MyException extends Exception {
  public MyException() {}
  public MyException(String msg) {
    super(msg);
  }
}

这里的要害是“extends Exception”，它的意思是：除包罗一个Exception的全部寄义以外，尚有更多的寄义。增加的代码数量很是少——实际只添加了两个构建器，对MyException的建设方法举办了界说。请记着，如果我们不明晰挪用一个基本类构建器，编译器会自动挪用基本类默认构建器。在第二个构建器中，通过利用super要害字，明晰挪用了带有一个String参数的基本类构建器。
该措施输出功效如下：
 

Throwing MyException from f()
MyException
        at Inheriting.f(Inheriting.java:16)
        at Inheriting.main(Inheriting.java:24)
Throwing MyException from g()
MyException: Originated in g()
        at Inheriting.g(Inheriting.java:20)
        at Inheriting.main(Inheriting.java:29)

可以看到，在从f()“掷”出的MyException违例中，缺乏具体的动静。
建设本身的违例时，还可以采纳更多的操纵。我们可添加特另外构建器及成员：
 

//: Inheriting2.java
// Inheriting your own exceptions

class MyException2 extends Exception {
  public MyException2() {}
  public MyException2(String msg) {
    super(msg);
  }
  public MyException2(String msg, int x) {
    super(msg);
    i = x;
  }
  public int val() { return i; }
  private int i;
}

public class Inheriting2 {
  public static void f() throws MyException2 {
    System.out.println(
      "Throwing MyException2 from f()");
    throw new MyException2();
  }
  public static void g() throws MyException2 {
    System.out.println(
      "Throwing MyException2 from g()");
    throw new MyException2("Originated in g()");
  }
  public static void h() throws MyException2 {
    System.out.println(
      "Throwing MyException2 from h()");
    throw new MyException2(
      "Originated in h()", 47);
  }
  public static void main(String[] args) {
    try {
      f();
    } catch(MyException2 e) {
      e.printStackTrace();
    }
    try {
      g();
    } catch(MyException2 e) {
      e.printStackTrace();
    }
    try {
      h();
    } catch(MyException2 e) {
      e.printStackTrace();
      System.out.println("e.val() = " + e.val());
    }
  }
} ///:~

此时添加了一个数据成员i；同时添加了一个非凡的要领，用它读取谁人值；也添加了一个特另外构建器，用它配置谁人值。输出功效如下：
 

Throwing MyException2 from f()
MyException2
        at Inheriting2.f(Inheriting2.java:22)
        at Inheriting2.main(Inheriting2.java:34)
Throwing MyException2 from g()
MyException2: Originated in g()
        at Inheriting2.g(Inheriting2.java:26)
        at Inheriting2.main(Inheriting2.java:39)
Throwing MyException2 from h()
MyException2: Originated in h()
        at Inheriting2.h(Inheriting2.java:30)
        at Inheriting2.main(Inheriting2.java:44)
e.val() = 47

由于违例不外是另一种形式的工具，所以可以继承这个历程，进一步加强违例类的本领。但要留意，对利用本身这个包的客户措施员来说，他们大概错过所有这些加强。因为他们大概只是简朴地寻找筹备生成的违例，除此以外不做任何工作——这是大大都Java库违例的尺度用法。若呈现这种环境，有大概建设一个新违例范例，个中险些不包括任何代码：
//: SimpleException.java
class SimpleException extends Exception {
} ///:~
它要依赖编译器来建设默认构建器（会自动挪用基本类的默认构建器）。虽然，在这种环境下，我们不会获得一个SimpleException(String)构建器，但它实际上也不会常常用到。