java异常处理

异常处理

 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  多异常处理

 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 的区别    
自定义 异常类

 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

  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

 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 }

 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 }