javaSE 异常处理

异常处理

(1)异常

程序运行过程中可能存在的一些错误称为异常。
异常会中断正在执行的程序的指令流
在一个程序中，可能会出现一些程序员没有预料到的情况，或者是无法控制的一些情况。比如数组溢出，用户的坏数据，试图打开一个根本不存在的文件，这些都会导致异常的发生

public class Test {
    public static void main(String[] args) {
        int x[]=new int[1];
        for(int i=0;i<10;i++) {    
            x[i] = 1;
            System.out.println(x[i]);
        }
    }
}

这时会系统会发生中断

在大于数组长度之后发生了数组溢出，这就发生了中断。
java中，异常也是作为类的实例的形式出现的。在某一方法中发生错误时，这个方法会创建一个对象，并把它传递给正在运行的系统。这个对象就是异常对象。通过异常处理机制，可以将非正常情况下的处理代码与程序的主逻辑分离，既在编写代码主流程的同时在其他地方处理异常。
为了避免终端就需要对异常进行处理，如果某个方法抛出异常，既可以在当前方法中进行捕捉，然后处理该异常，也可以将异常向上抛出，由方法调用者来处理。

public class Test {
    public static void main(String[] args) {
           System.out.println("去图书馆要坐");
           int age=Integer.parseInt("336路公交车");
           System.out.println(age);
    }
}

使用Integer类的parseint()方法时出现错误，参数不是数字字符串，但可以看出在发生中断之前的还是正常执行了的。

（2）捕捉异常

异常处理的语法如下

try{
    //程序代码块
}
catch(Exception1 e){
   //对Exception1 的处理
}
catch(Exception2 e){
//对Exception2 的处理
}
.....
finally{
   //程序块
}

try 语句块存放的是可能发生异常的java语句：catch程序块在try语句块之后，用来激发被捕捉的异常 finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码块如何退出，都将执行finally语句块

1.try-catch语句块

public class Test {
    public static void main(String[] args) {
        try {
            System.out.println("去图书馆要坐");
            int age = Integer.parseInt("336路");
            System.out.println(age);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("公交车");
    }
}

可以看出，程序仍然输出了最后一句,没有因为中间的异常而终止。
当try代码块中的语句块发生异常时，程序就会调转到catch代码块中执行，执行完catch代码块后，就会继续执行catch后的代码，而不会执行try代码块中发生异常语句后面的语句。所以,异常处理是结构化的，不会因为一个异常影响整个程序的执行。
Exception是try代码块传递给catch代码块的变量类型，e是变量名。
"e.printStackTrace();"语句用于输出异常的一些相关相关信息。
通常异常处理常用以下3个函数来获取异常的有关信息

函数	功能
getMessage()	输出错误性质
toString()	给出异常的类型与性质
printStackTrace()	指出异常的类型，性质，栈层次及程序中的位置

2.finally语句块

完整的异常处理语句一定要包含finally语句，无论程序中有无异常发生，并且无论之间的try-catch是否顺利执行完毕都会执行finally语句
以下特殊情况，finally代码块不会被执行
finally语句块中反生了异常
在前面的代码中使用了System.exit()退出程序
程序所在的线程死亡
关闭CPU

异常结构

所有类都是Throwabel的子类
Error类及其子类用来描述java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重
Exception类是非致命类错误，可以通过捕捉处理使程序继续执行
RuntimeException异常是运行产生过程中产生的异常

种类	说明
NullPointerException	空指针异常
ArrayIndexOutOfBoundsException	数组下标越界异常
ArithmeticException	算术异常
ArrayStoreException	数组中包含不兼容的值抛出的异常
IllegalArumentException	非法参数异常
SecurityException	安全性异常
NegativeArraySizeException	数组元素个数为负数抛出的异常

常见异常

java提供了一些异常用来描述经常发生的错误，其中，有的需要程序员进行捕获处理或声明抛出，有的是由java虚拟机自动进行捕获处理的

异常类	说明
ClassCastException	类型转换异常
ClassNotFoundException	未找到相应类异常
ArithmeticException	算术异常
ArrayIndexOutOfBoundsException	数组下标越界异常
ArrayStoreException	数组中包含不兼容的值抛出异常
SQLException	操作数据库异常类
NullPointerException	空指针异常
NoSuchFieldException	字段未找到异常
NoSuchMethodException	方法未找到异常
NumberFormatException	字符串转换为数字抛出的异常
NegativeArraySizeException	数组元素个数为负数抛出的异常
StringIndexOutOfBoundsException	字符串索引超出范围抛出的异常
IOException	输入输出异常
IlleAccessException	不允许访问某类异常
InstantiationException	当程序试图使用Class类的newInstance()方法创建一个类的的实例，而指定类的对象无法被实力化，抛出该异常
EOFException	文件已结束异常
FileNotFoundException	文件未找到异常

自定义异常

java内置的异常类可以在绝大多数异常情况下使用。但也可以通过继承Exception类自定义异常类
自定义异常类的步骤
1.创建自定义异常类
2.在方法中通过throw关键字抛出异常对象。
3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕捉并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常
4.在出现异常方法的调用者中捕捉并处理异常

package com.lzw;
public class MyException extends Exception {   //自定义异常，继承Exception类
    public MyException(String ErrorMessage){   //构造方法
        super(ErrorMessage);    //父类构造方法
    }
}

字符串ErrorMessage是要输出的错误信息

package com.lzw;

public class Test {
    static int avg(int x,int y) throws MyException{
       if(x<0||y<0)
            throw new MyException("不可以设为负数");
       if (x>100||y>100)
           throw new MyException("数值不能超过100");
       return (x+y)/2;
    }
    public static void main(String[] args) {
          try{
              int result=avg(150,10);
              System.out.println(result);
          }catch (MyException e){
              System.out.println(e);
          }
    }
}
输出结果：
com.lzw.MyException: 数值不能超过100

方法中抛出异常

若某个方法可能发出异常，但不想再当前方法中处理这个异常，则可以使用throws,throw关键字在方法中抛出异常
1.使用throws关键字抛出异常
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号分隔

public class Test2 {
    static void pop() throws NegativeArraySizeException{  //定义方法并抛出NegativeArraySizeException异常
        int a[]=new int[-3];
    }

    public static void main(String[] args) {
        try {
            pop();
        }catch (NegativeArraySizeException e){
            System.out.println(e);
            System.out.println("pop()方法抛出异常");
        }
    }
}
输出结果：
java.lang.NegativeArraySizeException
pop()方法抛出异常

2.使用throw关键字抛出异常
throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。
通过throw抛出异常，如果想在上一级代码中来捕捉并处理异常，则需要在抛出异常的方法中使用throws关键字在方法声明中指明要抛出的异。
如果要捕捉throw抛出异常，则必须使用try-catch语句块

public class MyException extends Exception {
    String message;
    public MyException(String ErrorMessage){   //构造方法
        message=ErrorMessage;
    }
    @Override
    public String getMessage() {   //覆盖getMessage()方法
        return message;
    }
}

public class Test {
    static int div(int x,int y) throws MyException{
       if(y<0)
          throw new MyException("除数不能为负数");    //异常信息
       return x/y;
    }
    public static void main(String[] args) {
          try{
              int result1=div(150,-1);
              System.out.println(result1);
          }catch (MyException e){    //自定义异常
              System.out.println(e.getMessage());
          }catch (ArithmeticException e){   //ArithmeticException 异常
              System.out.println("除数不能为0");
          }catch (Exception e){   //处理其他异常
              System.out.println("其他异常");
          }
        try{
            int result1=div(150,0);
            System.out.println(result1);
        }catch (MyException e){
            System.out.println(e.getMessage());
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }catch (Exception e){
            System.out.println("其他异常");
        }
        
    }
}
输出结果：
除数不能为负数
除数不能为0

Exception是所有异常类的父类，所以不能将catch(Exception e)放在前面。放在前面会报错。catch语句的顺序不可调换

注意

在当前方法声明中使用try-catch捕捉异常
一个方法被覆盖时，覆盖他的方法必须抛出相同的异常或异常的子类
如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常