日期：2011-03-22 16:17:00 来源：本站整理

成立自己的违例[Java编程]

赞助商链接

分享到： QQ空间新浪微博腾讯微博人人网

　　本文“成立自己的违例[Java编程]”是由七道奇为您精心收集，来源于网络转载，文章版权归文章作者所有，本站不对其观点以及内容做任何评价，请读者自行判断，以下是其具体内容：
并不一定非要利用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)构建器,但它实际上也不会常常用到.
　　以上是“成立自己的违例[Java编程]”的内容，如果你对以上该文章内容感兴趣，你可以看看七道奇为您推荐以下文章：

成立自己的违例

<b>怎样成立自己的函数库</b>

<b>成立自己的ProgressBar组件</b>

本文地址：

与您的QQ/BBS好友分享!

[] [返回上一页] [打印]

好的评价　如果您觉得此文章好，就请您
0%(0)
差的评价　如果您觉得此文章差，就请您
0%(0)

文章评论评论内容只代表网友观点，与本站立场无关！

评论摘要(共 0 条，得分 0 分，平均 0 分) 查看完整评论

栏目导航

赞助商链接

免责条款 - 广告合作 - 下载声明 - 欢迎投稿 - 友情连接 -