1 /*****************
2 ***第09章 异常
3 *******知识点:
4 **************1.异常的基础知识
5 **************2.异常类类图
6 **************3.异常关键字
7 **************4.异常处理机制
8 **************5.异常继承
9 **************6.异常小结
10 */
11
12 /*
13 *演示用的自定义异常类
14 */
15 class MyException extends Exception{
16 private String msg;
17 public MyException(String msg){
18 super();
19 this.msg = msg;
20 }
21 public String toString(){
22 return ("异常信息：" + msg);
23 }
24 }
25
26 public class test9{
27 public static void main(String[] args){
28 showDemo("1.异常的基础知识");
29 demoExceptionBasicKnowledge();//演示1.异常的基础知识
30
31 showDemo("2.异常类类图");
32 demoExceptionClassView();//演示2.异常类类图
33
34 showDemo("3.异常关键字");
35 demoExceptionKeyWord();//演示3.异常关键字
36
37 showDemo("4.异常处理机制");
38 demoExceptionHandle();//演示4.异常处理机制
39
40 showDemo("5.异常继承");
41 demoExceptionExtend();//演示5.异常继承
42
43 showDemo("6.异常小结");
44 demoExceptionNote();//演示6.异常小结
45 }
46
47 /*
48 *1.异常的基础知识
49 */
50 public static void demoExceptionBasicKnowledge(){
51 //异常————非正常情况，出现这样错误其实是程序上的错误。其中包括逻辑错误和系统错误
52 //比如：数组下标越界、除数为0、内存溢出等
53 }
54
55 /*
56 *2.异常类类图
57 */
58 public static void demoExceptionClassView(){
59 //异常类的根类————java.lang.Throwable 其中有两个子类分别为：Error、Exception
60 // 1.Error类：无法处理的异常，也成为错误。如：操作系统错误、内存硬件损坏等(编程时无需关心这类异常)
61 // 2.Exception类:可处理的异常。其中有两个子类分别为：RuntimeException和非RuntimeException
62 // (有时也称为unchecked exception——非检查异常(RuntimeException) 和checked exception——检查异常)
63 // 2.1RuntimeException：运行时异常或非检查异常。对于运行时异常，不要求必须捕获处理或抛出异常，由程序员自行决定
64 // 2.2非RuntimeException：非运行时异常或检查异常。对于非运行时异常，要求必须捕获处理或抛出异常，如不捕获或抛出则编译不通过
65 }
66
67 /*
68 *3.异常关键字
69 */
70 public static void demoExceptionKeyWord(){
71 //关键字有：try catch finally throw throws
72 //1.try catch finally关键字
73 // 1.1 try关键字 包围可能出现异常的逻辑代码，不能单独使用。必须配合catch/finally一同使用
74 //如： try..catch..; try..catch..finally..; try..finally; 只能有一个try 可以有多个catch finally可选
75 // 1.2 catch关键字 用于捕获可能出现的异常 建议不要使用空catch块
76 // 1.3 finally关键字 不管有没捕获到异常，finally代码均会执行，常用于释放资源操作
77 // 三者的执行顺序为：try—>catch—>finally 但如果存在多个catch,一旦捕获到异常，后面的catch则不会执行，
78 // 且finally在return前执行 建议不要在finally中使用return 不然返回值会被覆盖掉
79 showDemo("演示try..catch");
80 testTryCatch();
81
82 showDemo("演示try..catch..finally");
83 testTryCatchFinaly();
84
85
86 //2.throw throws
87 // 2.1 throw关键字 抛出一个异常对象 只会出现在方法体内
88 // 2.2 throws关键字 出现在方法的声明中，表示可能会抛出的异常，可允许后面跟着多个异常类型
89 showDemo("演示throws");
90 try{
91 testThrows();//演示throws
92 }catch(ArithmeticException e){
93 System.out.println("除数都能为0?哥笑了！");
94 }
95
96 showDemo("演示throw");
97 try{
98 testThrow();//演示throw
99 }catch(ArithmeticException e){
100 System.out.println("除数都能为0?大哥我笑了！");
101 }
102 }
103
104 /*
105 *4.异常处理机制
106 */
107 public static void demoExceptionHandle(){
108 //1.对于可能出现异常的代码，处理方式有两种
109 // 1.1处理异常————使用try..catch语句对异常进行处理
110 // 如： try{ ...} catch(异常类型1){} catch(异常类型2){} catch(异常类型3){} finally{}
111 // 1.2不处理异常————对于处理不了的异常或者需要转型的异常在方法声明处使用throws语句进行异常的抛出
112 // 如：public void testException() throws Exception{ if(...) { throw new Exception();}}
113
114 //2.使用异常类的方式有两种：
115 // 2.1使用java提供的已有异常类————如：IOException、SQLException
116 // 2.2使用自定义的异常————创建一个继承Exception/RuntimeException的子类
117
118 //3.异常的转译
119 // 3.1异常链————把原始的异常包装为新的异常类,并在新的异常类中封装原始异常类
120 /* 如:
121 public void test(){
122 try{
123 .....
124 }catch(ArithmeticException ex){
125 System.out.println("Arithmetic exception occoured: "+ex);
126 try {
127 throw new NumberFormatException();
128 }catch(NumberFormatException ex1) {
129 System.out.println("Chained exception thrown manually : "+ex1);
130 }
131 }
132 }
133
134 */
135 // 3.2异常转型————相当于在捕获到异常后，将异常以新类型的异常抛出，使异常的信息更加直观
136 /* 如：
137 public void test() throws MyException{
138
139 try{
140 ...
141 } catch(IOException e){
142 throw new MyException();
143 }
144 finally{
145 ...
146 }
147 }
148 */
149 try{
150 testDefinedException();//演示自定义异常类和异常转译
151 }catch(MyException e){
152 System.out.println("演示自定义异常类：" + e.toString());
153 }
154 }
155
156 /*
157 *5.异常继承
158 */
159 public static void demoExceptionExtend(){
160 //1.父类的方法没有声明异常，子类在重写该方法时不能声明异常
161 //2.如果父类方法声明一个异常A，则子类在重写该方法时声明的异常不能是A的父类
162 //3.如果父类的方法声明的异常类型只有非运行时异常(运行时异常)，则子类在重写该方法时声明的异常也只能是非运行时异常(运行时异常)
163 /*
164 总结就是：父类方法声明了什么异常，那么子类在重写该方法时只能是一样声明该异常或者该异常的子类
165 */
166 }
167
168 /*
169 *6.异常小结
170 */
171 public static void demoExceptionNote(){
172 //根据度娘和工作经验得出异常的小结：
173 /*
174 1.只有在必要的时候才使用异常，因为捕获异常的代价是非常非常非常高的(没错，重要的词语要说三次)
175 2.不要用异常去控制程序的流程
176 3.不要使用空catch块
177 4.try块尽可能过小。保持一个try块对应一个或者多个异常
178 5.尽可能细化异常，别动不动就来个catch(Exception e)
179 6.catch块要保持一个块对应一类异常
180 7.不要把自己能处理的异常抛出
181 8.尽可能将检查异常转为非检查异常，然后交给上层处理
182 */
183 }
184
185 /**演示TryCatch关键字**/
186 public static void testTryCatch(){
187 int a[] ={1,2,3};
188 try{
189 for(int i = 0;;i++){
190 System.out.println("获取数组值：" + a[i]);
191 }
192 }catch(ArrayIndexOutOfBoundsException e){
193 System.out.println("Catch语句：" + "数组访问越界了");
194 }
195 }
196
197 /**演示TryCatchFinaly关键字**/
198 public static void testTryCatchFinaly(){
199 int i = 0;
200 try{
201 int k = 1/i;
202 }catch(ArithmeticException e){
203 System.out.println("Catch语句：" + "除数为0");
204 }finally{
205 System.out.println("Finally语句："+"除数都能为0?呵呵！");
206 }
207 }
208
209 /**演示Throws关键字**/
210 public static void testThrows() throws ArithmeticException{
211 int i = 0;
212 int k = 1/i;
213 }
214
215 /**演示Throw关键字**/
216 public static void testThrow(){
217 int i = 0;
218 int k = 1/i;
219 if( i==0){
220 throw new ArithmeticException();
221 }
222 }
223
224 /**演示自定义异常类**/
225 public static void testDefinedException() throws MyException{
226 int i = 0;
227 try{
228 int k = 1/i;
229 }catch(ArithmeticException e){
230 throw new MyException("除数为0");
231 }
232 }
233
234
235 /*
236 * 抽取打印演示函数 用于打印演示功能提示
237 */
238 public static void showDemo(String demoStr){
239 System.out.println("演示:" + demoStr);
240 }
241 }
