JAVA的异常

1.JAVA处理异常流程

• JAVA是采用面对对象的方式来处理异常

1.抛出异常

• 在执行一个方法时，如果发生异常，则这个方法生成代表异常的一个对象，停止当前执行路径，并把异常对象提交给JRE

2.捕获异常

• JRE得到该异常后，寻找相应的代码来处理该异常，JRE在方法的调用栈中查找，从生成异常的方法开始追溯，直到找到相应的异常处理代码为止

2.对异常进行分类

• 所有异常的根类为java.lang.Throeable
• Throeable下面有两个派生子类 Error 和 Exception

2.1Exception

• Exception类时所有异常的父类，其子类对应各种可能出现的异常事件

1.RuntimeException运行时异常

1.ArithmeticException

System.out.println(3 / 0); //ArithmeticException
1

2.NullPointerException

String str = null;
System.out.println(str.charAt(0));
1
2

3.ClassCastException

Object obj = new String("测试");
Integer i = (Integer)obj;

1
2
3

4.ArrayIndexOutOfBoundsException

int[]  arr = new int[5];
System.out.println(arr[arr.lenth])
1
2

5.NumberFormatException

String str = "12345Fs";
System.out.println(Integer.parseInt(str))
1
2

2.CheckedException已检查异常

• 所有不是RuntimeException的异常，统称为CheckedException
• IOException、SQLException等以及用户自定义的Exception，这类异常在编译时就必须做出处理，否则无法通过编译

InputStream is = new FileInputStream("D:\\a.txt");
1

1.异常的处理方式

1.1使用try/catch捕获异常

• 格式

try{
	执行语句
}catch(Exception e1){

}catch(Exception e2){

}finally{

}
1
2
3
4
5
6
7
8
9

• 简单案例

    /**
     * 使用try-catch来捕获
     * @param args
     */
    public static void main(String[] args) {
        FileReader reader = null;
        try{
            reader = new FileReader("C:\\test.txt");
            char c = (char)reader.read();
            System.out.print(c);
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try{
                if(reader != null){
                    reader.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

1.2throws声明异常

  public static void main(String[] args) {

        try {
            readMyFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void readMyFile() throws IOException {
        FileReader reader = new FileReader("D:\\test.txt");
        char c = (char)reader.read();
        System.out.print(c);
        if (reader != null){
            reader.close();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.自定义异常类

   public static void main(String[] args) {
        Person person = new Person();
        person.setAge(5);
    }
}
class Person{
    private int age;
    private String name;
    public int getAge(){
        return this.age;
    }
    public void setAge(int age){
        if(age < 0){
            try{
                throw new IllegalAgeException("年龄不能为负数");
            }catch (IllegalAgeException e){
                e.printStackTrace();
            }
        }
        this.age = age;
    }
}
class IllegalAgeException extends Exception{
    public IllegalAgeException(){

    }
    public IllegalAgeException(String msg){
        super(msg);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

4.使用异常机制的建议

• 避免使用异常处理代替错误处理，这样会降低程序的清晰性，并且效率低下
• 处理异常不可以代替简单测试，只有异常情况下使用异常机制
• 不要进行小粒度的异常处理，应该将整个任务包装在try语句块中
• 异常往往在高层处理