Java异常处理

                                                异常

1、什么是异常？

           异常就是程序的运行过程中所发生的不正常事件，如所需文件找不到、网络连接不通或中断、算数运算出错(如被零除)、

            数组下标越界、装载了一个不存在的类、对null对象操作、类型转换异常等。异常会中断正在运行的程序。  

2、什么是异常处理？

            异常处理机制就像我们对平时可能会遇到的意外情况，预先想好了一些处理的办法。也就是说，在程序执行代码的时候

            ，万一发生了异常，程序就会按照预定的处理办法对异常进行处理，异常处理完毕之后，程序继续运行。

3、Java异常处理关键字：try、catch、finally、throw、throws    

        

4、处理异常的方式

        a、if-else语句通过判断处理异常情况

                缺点：(1)、代码臃肿，加入了大量的异常情况判断和处理代码

                           (2)、程序员把相当多的精力放在了处理异常代码上，放在了“堵漏洞”上，减少了编写业务代码的时间，

                                    必然影响开发速率

                            (3)、很难穷举所有的异常情况，程序依旧不健壮

                            (4)、异常处理代码和业务代码交织在一起，影响代码的可读性，加大日后程序的维护难度

        b、try-catch-finally

[java] view plain copy

1. import java.util.Scanner;  
2.   
3. public class Test1 {  
4.     public static void main(String[] args) {  
5.         Scanner in= new Scanner(System.in);  
6.         try {  
7.             System.out.print("请输入被除数：");  
8.             int num1 = in.nextInt();  
9.             System.out.print("请输入除数：");  
10.             int num2 = in.nextInt();  
11.             System.out.println(String.format("%d / %d = &d",num1,num2,num1/num2));  
12.               
13.         } catch (Exception e) {  
14.             // TODO: handle exception  
15.             System.out.println(e);  
16.             e.printStackTrace();  
17.             System.out.println(e.getMessage());  
18.         }finally{  
19.             System.err.println("感谢使用本程序！");  
20.         }  
21.     }  
22. }  

    把可能出现异常的代码放入try里面，如果出现异常则执行catch里的语句，finally里的语句不管 有没有异常都会执行

注：当在finally之前加上System.exit(1); finally里的语句就不会执行。

 结构图：       

异常

异常的分类：

             Throwable类：所有异常类型都是Throwable类的子类，它派生两个子类，即Error和Exception。

              Error类：表示仅靠程序本身无法恢复的严重严重错误，如内存溢出动态链接失败、虚拟机错误。应用程序不应该抛出

                              这这种类型的对象（一般由虚拟机抛出）。假如出现这种错误，除了尽力使程序安全退出外，在其他方面是

                                无能为力的。所以在程序设计时，应该更关注Exception类。

              Exception类：由Java应用程序抛出和处理的非严重错误。它的各种不同的子类分别对应不同类型的异常。  

常见的异常类型：

        Exception（异常层次结构的根类）

        ArithmeticException（算数错误情形，如以零作除数）

        ArrayIndexOutOFBoundsException（数组下标越界）

        NullPointerException（尝试访问null对象成员）

        ClassNotFoundException（不能加载所需的类）

        InputMismatchException（欲得到的数据类型与实际输入的类型不匹配）

        IllegalArgumentException（方法接收到非法参数）

        ClassCastException（对象强制类型转换错误）

        NumberFormatException（数字格式转换异常，如把“abc”转换成数字）

  多重catch块

        在使用多重catch块时，catch块的排列顺序必须时从子类到父类，最后一个一般都是Exception类。

申明异常-throws  抛出异常-throw

[java] view plain copy

print ?

1. public class Person {  
2.     private String name;  
3.     private String sex;  
4.     private int age;  
5.     public int getAge() {  
6.         return age;  
7.     }  
8.     public void setAge(int age) throws Exception {  
9.         if(age<1 || age>100){  
10.             throw new Exception("年龄必须在1~100之内！");  
11.         }else  
12.         this.age = age;  
13.     }  
14.     public String getName() {  
15.         return name;  
16.     }  
17.     public void setName(String name) {  
18.         this.name = name;  
19.     }  
20.     public String getSex() {  
21.         return sex;  
22.     }  
23.     public void setSex(String sex) throws Exception {  
24.         if("男".equals(sex) || "女".equals(sex)){  
25.             this.sex = sex;  
26.         }else{  
27.             throw new Exception("性别必须是\"男\"或者\"女\"!");  
28.         }  
29.     }  
30.     public void print(){  
31.         System.out.println(this.name+"("+this.sex+","+this.age+"岁)");  
32.     }  
33. }  

public class Person {
	private String name;
	private String sex;
	private int age;
	public int getAge() {
		return age;
	}
	public void setAge(int age) throws Exception {
		if(age<1 || age>100){
			throw new Exception("年龄必须在1~100之内！");
		}else
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) throws Exception {
		if("男".equals(sex) || "女".equals(sex)){
			this.sex = sex;
		}else{
			throw new Exception("性别必须是\"男\"或者\"女\"!");
		}
	}
	public void print(){
		System.out.println(this.name+"("+this.sex+","+this.age+"岁)");
	}
}

实现类：

[java] view plain copy

print ?

1. public class TestPerson {  
2.     public static void main(String[] args) {  
3.         Person person = new Person();  
4.         try {  
5.             person.setSex("男");  
6.             person.setAge(111);  
7.             person.print();  
8.         } catch (Exception e) {  
9.             // TODO: handle exception  
10.             e.printStackTrace();  
11.         }  
12.     }  
13. }  

Java语言中通过throws关键字申明某个方法可能抛出的各种异常。throws可以同时声明多个异常，之间用逗号隔开。

注：声明了异常必须处理，处理异常的两种方式：

        通过try-catch块捕获并处理异常

        通过throws继续声明异常。如果调用者不打算处理该异常，则可以继续通过throws声明异常，让上一级调用者

                处理异常。main()方法声明的异常将由Java虚拟机来处理

阅读全文

throw和throws的区别表现在以下三个方面。

        作用不同：throw用于在程序中抛出异常；throws用于声明在该方法内抛出了异常。

        使用位置不同：throw位于方法体内部，可以作为单独语句使用；throws必须跟在方法参数列表的后面，不能单独使用。

        内容不同：throw抛出一个异常对象，而且只能是一个；throws后面跟异常类，而且可以跟多个异常类。