/*
* java不可能对所有的情况都考虑到，所以，在实际的开发中，我们可能需要自定义异常类。
* 而我们自己随意的写一个类，是不能作为自定义异常类来看待的，要想你的类能是一个自定义的异常类，就必须继承自Exception类或者RuntimeException类。
*
* 两种方式：
* A:自定义异常类继承自Exception类 需要检查编译期异常和运行期异常
* B:自定义异常类继承自RuntimeException类 只需要检查运行期异常
*/
示例代码如下：
![]()
![]()
1 package cn.itcast_08;
2
3 /*
4 * java不可能对所有的情况都考虑到，所以，在实际的开发中，我们可能需要自定义异常类。
5 * 而我们自己随意的写一个类，是不能作为自定义异常类来看待的，要想你的类能是一个自定义的异常类，就必须继承自Exception类或者RuntimeException类。
6 *
7 * 两种方式：
8 * A:自定义异常类继承自Exception类 需要检查编译期异常和运行期异常
9 * B:自定义异常类继承自RuntimeException类 只需要检查运行期异常
10 */
11
12 // 自定义异常类继承自Exception类
13 //public class MyException extends Exception {
14 // public MyException() {
15 // super();
16 // }
17 //
18 // public MyException(String message) {
19 // super(message);
20 // }
21 //}
22
23 // 自定义异常类继承自RuntimeException类
24 public class MyException extends RuntimeException {
25 public MyException() {
26 super();
27 }
28
29 public MyException(String message) {
30 super(message);
31 }
32 }
自定义异常类
![]()
![]()
1 package cn.itcast_08;
2
3 public class Teacher {
4 // 针对MyException继承自Exception类
5 // public void check(int score) throws MyException {
6 // if (score > 100 || score < 0) {
7 // throw new MyException("分数必须在0-100之间"); // 编译期异常
8 // } else {
9 // System.out.println("分数没有问题");
10 // }
11 // }
12
13 // 针对MyException继承自RuntimeException类
14 public void check(int score) {
15 if (score > 100 || score < 0) {
16 throw new MyException("分数必须在0-100之间"); // 运行期异常
17 } else {
18 System.out.println("分数没有问题");
19 }
20 }
21
22 }
Teacher.java
![]()
![]()
1 package cn.itcast_08;
2
3 import java.util.Scanner;
4
5 /*
6 * 自定义异常的测试类
7 */
8 public class StudentDemo {
9 public static void main(String[] args) {
10 Scanner sc = new Scanner(System.in);
11 System.out.println("请输入学生成绩：");
12 int score = sc.nextInt();
13
14 Teacher t = new Teacher();
15
16 // 编译期异常测试
17 // try {
18 // t.check(score);
19 // } catch (MyException e) {
20 // e.printStackTrace();
21 // }
22
23 // 运行期异常测试
24 t.check(score);
25 }
26 }
自定义异常的测试类
/*
* 异常的注意事项:
* A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了，儿子不能比父亲更坏)
* B:如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是父类异常的子集，子类不能抛出父类没有的异常。
* C:如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try，不能throws。
*/
示例代码如下：
1 package cn.itcast_09;
2
3 import java.text.ParseException;
4 import java.text.SimpleDateFormat;
5 import java.util.Date;
6
7 /*
8 * 异常的注意事项:
9 * A:子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了，儿子不能比父亲更坏)
10 * B:如果父类抛出了多个异常，子类重写父类时，只能抛出相同的异常或者是父类异常的子集，子类不能抛出父类没有的异常。
11 * C:如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法内有异常发生，那么子类只能try，不能throws。
12 */
13 public class ExceptionDemo {
14
15 }
16
17 class Fu {
18 public void show() throws Exception {
19 }
20
21 public void method() {
22 }
23 }
24
25 class Zi extends Fu {
26 @Override
27 public void show() throws ArithmeticException {
28
29 }
30
31 @Override
32 public void method() {
33 String s = "2014-11-20";
34 SimpleDateFormat sdf = new SimpleDateFormat();
35 Date d = null; // 局部变量，引用数据类型，需要初始化为null。为什么呢？按理说 d = sdf.parse(s); 这一句就可以初始化了啊？
36 try {
37 d = sdf.parse(s); // 编译期异常，因为编译的时候，我不知道try里面有什么语句(编译只检查语法)，只有运行的时候才知道try里面有什么，如果这句前面有一句抛出异常，则就不会执行到这一句了。d就不能初始化了。
38 } catch (ParseException e) {
39 e.printStackTrace();
40 }
41
42 System.out.println(d);
43 }
44 }
我的GitHub地址：
https://github.com/heizemingjun
我的博客园地址：
http://www.cnblogs.com/chenmingjun
我的蚂蚁笔记博客地址：
http://blog.leanote.com/chenmingjun
Copyright ©2018 黑泽明军
【转载文章务必保留出处和署名，谢谢！】
