异常处理

异常处理：

1. /** 
2.  *异常: 就是程序在运行时出现不正常情况 
3.  *异常由来: 问题也是现实生活中的事物,也可以通过java类的形式进行描述,并进行封装.  
4.  * 
5.  *对于问题的划分:   
6.  *   1: 严重的问题 (Error) :   java通过Error类进行描述,一般不编写针对性的代码进行处理 
7.  *   2: 非严重的问题 (Exception): java通过Exception类进行描述,一般使用针对性的处理方式进行处理 
8.  *    
9.  *无论 Error 或者 Exception 都具有一些共性的内容 
10.  *比如: 不正常的情况信息,引发原因等   
11.  *  所以就出现了 "Throwable" 这个父类 
12.  *   
13.  * Throwable 
14.  *    |--Error 
15.  *    |--Exception  
16.  *   
17.  * 
18.  *2.异常的处理 
19.  *  java 提供了特有的语句进行处理 
20.  *   
21.  * try{ 
22.  *     需要被检测 
23.  * }catch(异常类 变量){ 
24.  *    出来异常的代码:(处理方式) 
25.  * }finally{ 
26.  *   一定会执行的语句 
27.  * } 
28.  *  
29.  * 3.对捕获到的异常信息进行处理 
30.  *   1. String getMessage();        //打印  异常信息 
31.  *   2. String toString();          //打印  异常名称 : 异常信息 
32.  *   3. void printStackTrace();   //打印最全名:  异常 名称 : 异常信息  : 异常位置  ; 是 JVM 默认异常处理机制,就是调用这个方法 
33.  *  
34.  * 4.问题: 发现下面的程序有时候能正常运行,有时候不能, 因为不是所以认得知道这个方法会抛出异常 ,也不是所有人都会处理 这个异常. 怎么办 ? 
35.  *   所以就出现  throws  抛出异常 
36.  */  
37. class Demo{  
38.     static int div(int a,int b){  
39.         return a/b;  
40.     }  
41. }  
42.   
43.   
44. public class ExceptionDemo {  
45.     public static void main(String[] args) {  
46.         //exception  
47.         try{  
48.             int x=Demo.div(4, 0); //除数不能为0 ,抛出 new ArithmeticException(); 程序会终止   
49.             System.out.println("x="+x);  //出现异常后  这句话就不会被执行  直接进入 catch 语句块中去了  
50.         }catch(Exception e){  // Exceptioin e= new ArithmeticException();  
51.             System.out.println("除数为0啦!");  
52.             System.out.println(e.getMessage()); // "/ by zero"  
53.             System.out.println(e.toString());//toString() 可以省略   打印   异常名称 : 异常信息  
54.             e.printStackTrace();   //打印最全名:  异常 名称 : 异常信息  : 异常位置.  
55.               
56.         }  
57.         System.out.println("run over"); //运行 完  catch语句块后 , 接着运行 这句  
58.           
59.         //error  
60.         byte[] arr=new byte[1024*1024*6000];  
61.         //超出虚拟据总内存大小  不管在怎么样 也不能超过物理内存大小 ,这程序也没戏了.  
62.     }  
63. }  

throws  多异常处理  

Java代码  

1. /** 
2.  * throws 
3.  * 1. throws: 在功能上通过throws的关键字声明该功能有可能出现问题. 
4.  *  
5.  * 2.被声明后  我们必须告诉程序的处理方式 
6.  *    1.采用 try catch 进行处理 
7.  *    2.继续抛出 异常 ,由jVM 虚拟机 进行异常处理  不过这样 程序 就会终止. 
8.  *     
9.  *     
10.  * 多异常的处理 
11.  *   1.声明异常时,建议声明更为具体的异常,这样 处理的可以更具体  
12.  *     比如: 下面 throws ArithmeticException 而不写成 throws Exception 
13.  *      
14.  *   2.对于声明多个异常,在调用的时候就应该有几个 catch块.不要定义多余的catch块 ,比如下面注释的 catch块 
15.  *      如果多个catch中的异常出现了继承关系,父类异常catch块 放在最下面 . 
16.  *       
17.  *   建议:在进行catch处理时,catch一定要定义具体的处理方式 
18.  *       不要简单的一句. e.printStackTrace(); 
19.  *       也不要简单的就书写一条输出语句 ,一般采用log日志文件 进行 异常信息记录 
20.  * 
21.  */  
22.   
23. class Demo{  
24.     static int div(int a,int b) throws ArithmeticException{  
25.           
26.         return a/b;  
27.     }  
28. }  
29.   
30. class Demo1{  
31.     static int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException{  
32.         int [] arr=new int[a];  
33.         System.out.println(arr[a+1]);  //出现越界  
34.         return a/b;  
35.     }  
36. }  
37.   
38. public class ExceptionDemo1 {  
39.   
40.     /** 
41.      * thrwos 
42.      */  
43.     public static void main(String[] args) {  
44.         // 使用第一种方法处理  
45.         try {  
46.             Demo.div(4, 0);  
47.         } catch (Exception e) {  
48.             System.out.println(e.toString());  
49.         }  
50.     }  
51.       
52.     // 使用第二种方法处理  继续往上抛出异常 让 JVM 帮我处理    
53.     public static void otherMethod() throws ArithmeticException{  
54.         Demo.div(4, 0);  
55.     }  
56.   
57.     /** 
58.      * 多异常处理 
59.      */  
60.     public static void otherMethod1() throws ArithmeticException,ArrayIndexOutOfBoundsException{  
61.         Demo1.div(4, 0);  
62.     }  
63.       
64.     public static void otherMethod2() {  
65.         try {  
66.             Demo1.div(4, 0);  
67.         } catch (ArithmeticException e) {  
68.             System.out.println(e.toString());  
69.             System.out.println("被0除了");  
70.         }catch(ArrayIndexOutOfBoundsException e){  
71.             System.out.println(e.toString());  
72.             System.out.println("角标越界");  
73.         }/*catch(Exception e){  //这样做只会隐藏 异常 ,这样做是不对的 
74.             System.out.println(e.toString()); 
75.         }*/  
76.            
77.     }  
78.       
79. }  

throws 和throw 的区别    
自定义 异常类  

Java代码  

1. /** 
2.  * 因为项目中会出现特有的问他你. 
3.  * 而这些问题并未被java所描述和封装成对象 
4.  * 所以对于一些特有的问题可以安装java的对问题封装的思想. 
5.  * 将特有的问题,进行自定义的异常封装 
6.  *  
7.  *  
8.  * 自定义异常 
9.  *  
10.  * 需求: 在本程序中,对于除数 是-1 也视为错误的,是无法进行运算. 
11.  * 那么就需要对这个问题进行自定义的描述. 
12.  * 
13.  *当函数内部初相了throw抛出异常对象,那么就必须要给对应的处理动作. 
14.  *要么在内部 try catch 处理 
15.  *要么子啊函数上声明让调用者处理. 
16.  * 
17.  *一般情况下, 函数内部出现异常,函数上需要声明. 
18.  * 
19.  *发现 打印的结果中只有异常的名称,却没有异常的信息 
20.  *因为自定义的异常并未定义信息 
21.  * 
22.  *如何定义异常信息呢? 
23.  *  因为父类中已经把异常信息的操作都做完了 
24.  *  所以子类只要在构造时,将异常信息传递给父类通过super语句 
25.  *  就可以直接通过getMessage获取自定义的异常信息 
26.  * 
27.  *自定义异常:必须是自定义类继承 Exception 
28.  * 
29.  *继承Exception原因: 
30.  *  异常体系有一个特点,因为异常类和异常对象都被抛出 
31.  *  因为他们都具备可抛性,这个可抛性是Trowable这个体系中独有的特点. 
32.  * 
33.  *  只有这个体系中的类和对象才可以被throw 和 throw 操作 
34.  *   
35.  *throws 和throw 的区别 
36.  *throws:使用在函数上 
37.  *throw:使用在函数内 
38.  * 
39.  *throws:后面跟的异常类,可以跟多个,用逗号分开 
40.  *throw:后跟的是异常对象. 
41.  */  
42. class FuShuException extends Exception{  
43.       
44.     /* 
45.     private String msg; 
46.     FuShuException(String msg){ 
47.         this.msg=msg; 
48.     } 
49.     public String getMessage(){ 
50.         return this.msg; 
51.     } 
52.     */  
53.     FuShuException(String msg,int num){  
54.         super(msg);  
55.         this.value=num;  
56.     }  
57.     private int value;  
58.       
59.     public int getValue(){  
60.         return value;  
61.     }  
62.       
63. }  
64.   
65. //自定义 异常类  
66. class Demo{  
67.       
68.     static int div(int a,int b) throws FuShuException{  
69.         if(b<0)  
70.             throw new FuShuException("出现了除数为零的情况  / by fushu",b);  //手动通过throw 关键字抛出一个自定义异常对象.  
71.         return a/b;  
72.     }  
73. }  
74.   
75.   
76. public class ExceptionDemo2 {  
77.   
78.     public static void main(String[] args) {  
79.         // TODO Auto-generated method stub  
80.         try {  
81.             Demo.div(4, -1);  
82.         } catch (FuShuException e) {  
83.             System.out.println(e.toString());  
84.             System.out.println("除数出现负数了!");  
85.             System.out.println("负数是:"+e.getValue());  
86.         }  
87.         System.out.println("over");  
88.     }  
89.   
90. }  

RuntimeException  

Java代码  

1. /** 
2.  *RuntimeException: 
3.  *  Exception中有一个非常特殊子类异常,RuntimeException 运行时异常 
4.  *  如果在函数内部使用throw抛出异常,函数上可以不用throws声明,编译一样通过. 
5.  *  如果在函数上使用throws声明了该异常,调用者可以不用进行处理,编译一样通过; 
6.  *之所以不用在函数上使用throws声明,是因为不需要让调用者处理 
7.  *当异常发送,JVM希望程序停止,因为在运行时,出现了无法继续运算的情况,希望停止程序后,然程序员对代码进行修正 
8.  * 
9.  *自定义异常时,如果该异常的发生,无法在继续进行运算,就让自定义异常继承RuntimeException. 
10.  * 
11.  *对于异常的分类 
12.  *1.编译时被检测的异常 (必须使用 throws 或者 try catch进行处理) 
13.  * 
14.  *2.编译时不被检测的异常(运行时异常,RuntimeException以及其子类) 程序会停止掉,然后要改进代码 
15.  * 
16.  */  
17. class Demo{  
18.     static int div(int a,int b){ //发现  这里不需要 throws 怎么回事?  
19.         if(b==0)  
20.             throw new ArithmeticException("被零除了!"); //需改 java自定义异常中的提示,改成我们熟悉的  
21.         return a/b;  
22.     }  
23.       
24.     static int div1(int a,int b)throws ArithmeticException{   
25.         //if(b==0)  
26.             //throw new Exception("被零除了!"); //需改 java自定义异常中的提示  
27.         return a/b;  
28.     }  
29.       
30.     static int div2(int a,int b){ //发现  这里不需要 throws 怎么回事?  
31.         if(b<0)  
32.             throw new FuShuException("出现除数为负数了"); //需改 java自定义异常中的提示  
33.         if(b==0)  
34.             throw new ArithmeticException("被零除了!");  
35.         return a/b;  
36.     }  
37.       
38. }  
39. //自定义 运行时异常类  
40. class FuShuException extends RuntimeException{  
41.       
42.     public FuShuException(String msg) {  
43.         super(msg);  
44.     }  
45. }  
46.   
47. public class ExceptionDemo3 {  
48.   
49.     public static void main(String[] args) {  
50.         // TODO Auto-generated method stub  
51.         /*Demo.div(4, 0);   //  
52.         Demo.div1(4, 0);  //发现没有 try catch  编译也通过 
53.          
54.         Demo.div2(4, -9);*/  
55.           
56.           
57.         //讲课  
58.         Teacher t=new Teacher("张老师");  
59.         try {  
60.             t.prelect();  
61.         } catch (NoPlanException e) {  
62.             System.out.println(e.toString());  
63.             System.out.println("换老师 或者 放假!");  
64.         }  
65.     }  
66.   
67. }  
68.   
69.   
70. /* 
71.  * 老师上课 
72.  *  
73.  * 思考上课中出现的问题  
74.  *   比如问题: 电脑蓝屏 
75.  *           电脑冒烟 
76.  *            
77.  *  要对问题进行封装成对象. 
78.  *  冒烟后,出现讲课进度无法继续 
79.  *  出现了讲师的问题,课时计划无法完成. 
80.  *   
81.  *  throw 和 return 单独存在的时候,后面不能出现 其他语句  
82.  */  
83. class Teacher{  
84.     private String name;  
85.       
86.     private Computer cmpt;  
87.     Teacher(String name){  
88.         this.name=name;  
89.         this.cmpt=new Computer();  
90.     }  
91.       
92.     public void prelect()throws NoPlanException{  
93.         try {  
94.             cmpt.run();  
95.         } catch (LanPingException e) {  
96.             cmpt.reset();  
97.         } catch (MaoYanException e) {  
98.             test();  
99.             throw new NoPlanException("课时无法继续"+e.getMessage());  
100.             //test(); //不能放在这里 ,throw 和 return 单独存在的时候,后面不能出现 其他语句   
101.         }  
102.         System.out.println("讲课");  
103.     }  
104.       
105.     public void test(){  
106.         System.out.println("练习!");  
107.     }  
108.       
109.       
110. }  
111. class Computer{  
112.     private int status=3;  
113.     public void run()throws LanPingException,MaoYanException {  
114.         if(status==2)  
115.             throw new LanPingException("蓝屏了");  
116.         if(status==3)  
117.             throw new MaoYanException("冒烟了");  
118.           
119.         System.out.println("电脑运行");  
120.     }  
121.     public void reset(){  
122.         this.status=1;  
123.         System.out.println("电脑重启");  
124.     }  
125. }  
126.   
127. //封装问题  
128. class LanPingException extends Exception{  
129.     LanPingException(String message){  
130.         super(message);  
131.     }  
132. }  
133.   
134. class MaoYanException extends Exception{  
135.     MaoYanException(String message){  
136.         super(message);  
137.     }  
138. }  
139. //冒烟后的异常  
140. class NoPlanException extends Exception{  
141.     NoPlanException(String message){  
142.         super(message);  
143.     }  
144. }  

finally  

Java代码  

1. /** 
2.  * finally代码快:定义一定要执行的代码 
3.  * 通常用于关闭资源 
4.  * 如果 catch中 有return 的时候  finally 代码会被执行 而其他的代码不会被执行. 
5.  */  
6. class FuShuException extends Exception{  
7.     FuShuException(String msg){  
8.         super(msg);  
9.     }  
10. }  
11.   
12. class Demo{  
13.     static int div(int a,int b)throws FuShuException{  
14.         if(b<0)  
15.             throw new FuShuException("除数为负数!");  
16.         return a/b;  
17.     }  
18. }  
19. class NoException extends Exception{  
20.       
21. }  
22. public class FinallyDemo1 {  
23.   
24.     public static void main(String[] args) {  
25.         test1();  //   除数为负数!     finally   over  
26.           
27.         test2(); //   除数为负数!      finally  
28.     }  
29.     public static void test1(){  
30.         try {  
31.             int x=Demo.div(4, -1);                       //1  
32.             System.out.println("x="+x);  
33.         } catch (FuShuException e) {  
34.             System.out.println(e.toString());            //2  
35.         }finally{  
36.             System.out.println("finally");               //3  
37.         }  
38.         System.out.println("over");                      //4  
39.     }  
40.       
41.     public static void test2(){  
42.         try {  
43.             int x=Demo.div(4, -1);                       //1  
44.             System.out.println("x="+x);   
45.         } catch (FuShuException e) {  
46.             System.out.println(e.toString());            //2    
47.             return; // 使用return后                                                                 //4  
48.         }finally{  
49.             System.out.println("finally");               //3  
50.         }  
51.         System.out.println("over");  
52.     }  
53.       
54.       
55.     /** 
56.      * 采用分层的思想来设计 一般不会抛出 SQLException 给调用者 而是给一个 调用者能看的懂的异常 
57.      */  
58.     public void method()throws /*SQLException*/NoException {  
59.         //连接数据库  
60.         //数据操作:  //throw new SQLException();  
61.         //关闭数据库  
62.           
63.         try {  
64.             //连接数据库  
65.             //数据操作:   
66.         }catch (SQLException e) {  
67.             //会对数据库进行异常操作  
68.             //throw new SQLException();  
69.             throw new NoException();  
70.         }finally{  
71.             //关闭数据库  
72.         }  
73.     }  
74.   
75. }  

Java代码  

1. /** 
2.  *  
3.  *异常的几种格式 
4.  * 
5.  *记住一点:catch是用户处理异常,如果没有catch就代表异常没有被处理过,如果该异常是检测时异常,那么使用 throws必须声明. 
6.  */  
7. class ExceptionStyle{  
8.     //异常的几种格式  
9.     public void method(){  
10.         //第一种格式  
11.         try {  
12.               
13.         } catch (Exception e) {  
14.             // TODO: handle exception  
15.         }  
16.           
17.         //第二种格式  
18.         try {  
19.               
20.         } catch (Exception e) {  
21.             // TODO: handle exception  
22.         }finally{  
23.               
24.         }  
25.         //第三格式  
26.         try{  
27.               
28.         }finally{  
29.               
30.         }  
31.           
32.         //第四种 格式  
33.         try {  
34.               
35.         }catch (ArithmeticException e) {  
36.             // TODO: handle exception  
37.         }catch (Exception e) {  
38.             // TODO: handle exception  
39.         }  
40.           
41.     }  
42.       
43.     //看看下面几种情况   
44.       
45.     //错误       没有throws  Exception  编译不通过  
46.     public void method1() /*throws  Exception*/{  
47.         throw new Exception();     
48.     }  
49.       
50.     //正确  
51.     public void method2(){  
52.         try {  
53.             throw new Exception();  
54.         } catch (Exception e) {  
55.             // TODO: handle exception  
56.         }  
57.           
58.     }  
59.       
60.     //错误           处理一个异常后  又抛出了异常  编译不通过  
61.     public void method3(){  
62.         try {  
63.             throw new Exception();  
64.         } catch (Exception e) {  
65.             throw e;  
66.         }  
67.           
68.     }  
69.       
70.     //正确         只要  e 被处理就可以了  
71.     public void method4(){  
72.         try {  
73.             throw new Exception();  
74.         } catch (Exception e) {  
75.             try {  
76.                 throw e;  
77.             } catch (Exception e2) {  
78.                 // TODO: handle exception  
79.             }   
80.         }  
81.           
82.     }  
83.       
84.     //错误      没有catch 或则 throws 就是没有处理  编译 不通过 ,  
85.     public void method5(){  
86.         try {  
87.             throw new Exception();  
88.         }finally{  
89.             //关闭资源   产生的异常 有调用者处理  
90.         }  
91.     }  
92.       
93. }