Java——异常处理（详解）

定义概念：

所谓异常就是程序运行时可能出现的一些错误，比如试图打开一个根本不存在的文件、配置问题、错误输入等问题，异常处理将会改变程序的控制流程，让程序有机会对错误做出处理。语法错误和逻辑错误不是异常。

java异常处理过程：
（1）当程序运行到某一句时，发生了异常，那么程序会先停下来
（2）程序会在这句代码处，查看原因，生成一个合理“异常对象”，然后“抛”出
（3）JVM会检测在这句代码的外围，是否有try…catch结构，可以“捕获”异常对象。

如果可以捕获，那么程序再处理完异常后，继续下面的运行，不会崩溃；
如果不能捕获，那么会把这个异常继续抛给“上级”，如果“上级”能处理，那么程序从“上级"处理完的代码后面继续运行；

如果上级也不能处理，那么继续往上抛，一直到达JVM，那么就“崩溃”

演示代码:

public static void main(String[] args) {
        int sum = 0;
        System.out.println("sum = " + sum);
        testInput();  //第18行代码
        System.out.println("main的其他代码");
    }

    public static void testInput(){
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入一个整数：");
            int num = input.nextInt(); //第24行代码
        } catch (ArrayIndexOutOfBoundsException e) {//获取数组越界异常对象
            System.out.println("输入有误");//这里 只是提醒，没有让他 重新输入
        }
        System.out.println("其他的代码");
    }

分析：
从第34行开始，由于输入不匹配，抛出输入不匹配异常对象，尽管有try…catch可以捕获异常对象，但是catch的是数组越界异常对象，因此无法捕获，于是将异常对象继续抛给上级。因为是在main函数调用的方法，于是就抛给了main函数（第18行），但是main函数也无法处理，于是继续抛给虚拟机，最终程序崩溃。

修改过后：

public static void main(String[] args) {
        int sum = 0;
        System.out.println("sum = " + sum);
        try {
            testInput();
        } catch (InputMismatchException e) {
            System.out.println("成功捕获异常对象");
        }
        System.out.println("main的其他代码");
    }

    public static void testInput(){
        Scanner input = new Scanner(System.in);
        try {
            System.out.print("请输入一个整数：");
            int num = input.nextInt();
        } catch (ArrayIndexOutOfBoundsException e) {//获取数组越界异常对象
            System.out.println("输入有误");//这里 只是提醒，没有让他 重新输入
        }
        System.out.println("其他的代码");
    }

异常类型

1、异常的公共父类：java.lang.Throwable
(1)只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句“抛”出。
(2)只有此类或其子类之一才可以是 catch 子句中的参数类型。

2、Throwable又分为两大派别：
（1）Error：错误
一般指严重错误，一般合理的应用程序不应该试图去捕获它。
如果出现这个问题，要么需要升级修改程序，要么需要升级架构，要么需要升级硬件。
例如：报了一个OutOfMemoryError
经典代表：VirtualMachineError（堆内存溢出OutOfMemoryError，栈内存溢出StackOverflowError）

（2）Exception：异常
一般异常，合理的应用程序应该试图去捕获它。

3、Exception还可以分为两大类：
（1）运行时异常(RuntimeException或它子类)：又称为非受检异常。
编译时，编译器是不会提醒你做处理的，只有运行期间，才会发生。

运行时异常是不建议用try…catch，因为它发生频率太高，而且一般都是很不应该发生的问题。
例如：空指针异常，数组下标越界异常，类型转换异常等，这些异常完全可以避免掉。
但是如果实在没有考虑到，也可以通过try…catch处理。

（2）编译时异常，除了RuntimeException系列以外的，都是编译时异常。又称为受检异常。
编译时，编译器会强制要求程序员编写处理的代码，如果你不编写，那么就编译不通过。
例如：FileNotFoundException，IOException等

异常处理：

try…catch

1、格式：

 try{
		可能发生异常的代码
 }catch(异常类型1  异常对象名){//异常对象名绝大多数都是写e
 		处理这个异常的代码
 }catch(异常类型2  异常对象名){//异常对象名绝大多数都是写e
	处理这个异常的代码
}catch(异常类型3  异常对象名){//异常对象名绝大多数都是写e
		处理这个异常的代码
 }... ...

2、异常对象的常用方法
（1）e.printStackTrace();
打印异常的详细信息，包括对象跟踪信息，即这个异常对象一路经过了哪些方法
（2）e.getMessage()；
返回异常对象中简单的错误信息提示

3、打印异常/错误信息
System.err.println(xx);打印错误信息（打印红色字体）
System.out.println(xx);打印正常信息

4、多个catch分支，如何匹配和执行的？
从上到下依次判断，一旦有一个满足，后面就不看了。
建议：如果多个catch中的异常类型有大小包含关系，那么小的在上，大的在下，如果没有大小包含关系，顺序随意。

5、如果catch，可以捕获try中发生的异常，那么程序，会从try…catch下面的代码继续运行 ，不会崩溃。
如果catch无法捕获try中发生的异常，那么就会导致当前方法结束，并把异常对象抛出调用者。
如果调用者可以处理，那么从调用者处理代码的后面继续运行，否则继续往上抛，最终到达JVM，程序就崩溃了。

演示代码：

//从命令行接收2个整数，求商
	public static void main(String[] args) {
		try {
			int a = Integer.parseInt(args[0]);//第一个参数赋值给a变量
			int b = Integer.parseInt(args[1]);//第二个参数赋值给b变量
			int shang = a/b;
			System.out.println(a +"/" + b + "=" + shang);
		} catch (NumberFormatException e) {
			e.printStackTrace();//标准的
      //System.err.println(e.getMessage());
      //System.out.println(e.getMessage());
		} catch (ArrayIndexOutOfBoundsException e){
			e.printStackTrace();
		} catch (ArithmeticException e){
			e.printStackTrace();
		} catch (Exception e){
			e.printStackTrace();
		} 				
		System.out.println("其他的代码....");
	}

try…catch finally

格式：

try{
	可能发生异常的代码
}catch(异常类型1  异常对象名){//异常对象名绝大多数都是写e
	处理这个异常的代码
 }catch(异常类型2  异常对象名){//异常对象名绝大多数都是写e
	处理这个异常的代码
}catch(异常类型3  异常对象名){//异常对象名绝大多数都是写e
	处理这个异常的代码
}
 ... ...
 finally{
	不管try中是否发生异常，也不管catch是否可以捕获异常，这里代码都必须执行
}

一般用于编写释放资源，断开连接等代码

特殊情况：可以没有catch部分

 try{	
}finally{
}

演示代码：

public static void main(String[] args) {
		try {
			int a = 1;
			int b = 0;
			System.out.println(a/b);
		} catch (ArrayIndexOutOfBoundsException e) {
			e.printStackTrace();
		} finally{
			System.out.println("最终块");
		}
	}

补：finally与return混用：

public static void main(String[] args) {
		int num = getNum(4);
		System.out.println(num);//0
	}
	
	public static int getNum(int a){
		int result = 10;
		try{
			System.out.println(a/0);
			if(a > 0){
				result = 20;
				return result;
			}else if(a < 0){
				result = -20;
				return result;
			}else{
				return result;
			}
		}catch(Exception e){
			System.out.println("exception");
			result = 0;
			return result;
		}finally{
			result = 30;
			System.out.println("finally");
       //return result;//如果有这句，结果就变成30
		}
	}

finally与return混用：

（1）不管try中是否发生异常，也不管catch是否可以捕获异常，也无论try或catch中是否有return。 finally中的代码都必须执行
（2）如果finally中有return，就从finally块的的return回去。
（3）如果finally中没有return，那么先把try或catch中该执行的执行完（包括把返回值的结果放到要带回调用处的操作数栈的位置），在return结束当前方法之前，先走一下finally，然后回去结束当前方法.

结论，如果finally中没有return，finally中的代码不影响返回值。

但是如果try-catch语句执行了程序退出代码，即执行System.exit(0);，则不执行finally子语句（当然包括其后的所有语句）

throws关键字

异常处理的方式之一：
在当前方法中直接用try…catch处理
异常处理的方式之二：
在当前方法中不处理，扔/抛给调用者处理（throws的作用）

格式：

【修饰符】 返回值类型  方法名(【形参列表】)throws 异常列表们{
}
说明：throws后面可以跟好几个异常，顺序无所谓，每一个异常之间使用,分割

throws的好处：
（1）throws：告知被调用者，我这个方法可能会抛出哪些异常，使得调用者可以明确的知道应该catch什么异常。
如果没有throws，那么调用者就不清楚，只能按照Exception处理，或者根据错误经验来处理。
2）编译时异常，如果在当前方法中不用try…catch处理，编译不通过，那么可以通过throws明确的说明，抛给调用者处理

演示代码：

public static void main(String[] args) {
			try {
				divide(1,1);
			} catch (ArithmeticException e) {
				e.printStackTrace();
			} catch (RuntimeException e) {
				e.printStackTrace();
			}
			
			try {
				copy("1.txt","2.txt");
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}			
	}
	
public static void divide(int a, int b)throws ArithmeticException,RuntimeException{
		System.out.println(a/b);
	}
	
public static void copy(String srcFile, String destFile) throws FileNotFoundException{
		FileInputStream fis = new FileInputStream(srcFile);//用来读取srcFile文件的内容
	}

关于方法重写时，对throws抛出的异常的要求：
子类重写的方法抛出的异常类型必须<=父类被重写的方法抛出的异常类型。
例如：
Exception > RuntimeException > ArrayIndexOutOfBoundsException

public static void main(String[] args) {

        Father f = new Son();//多态引用
        try {
            f.method();
        } catch (RuntimeException e) {
            e.printStackTrace();
        }

        Father f2 = new Son();
        Object str = f2.test();
    }

class Father{
    public void method()throws RuntimeException{
        //....
    }
    public Object test(){
        return null;
    }
}
class Son extends Father{
    @Override
    public void method()throws ArrayIndexOutOfBoundsException{
        //....
    }
    @Override
    public String test(){
        return "";
    }
}

throw关键字

异常的对象的创建和抛出有两种方式：
（1）JVM创建并抛出
（2）程序员new出来，然后由throw抛出。throw用于手动抛出异常对象。可以代替return语句，结束当前的方法。

 public static void main(String[] args) {
        Account a = new Account(100);
        try {
            boolean flag = a.withdraw(500);
            //如果没有异常，取款成功
            System.out.println("取款成功" + flag);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (RuntimeException e) {
            e.printStackTrace();
        }
    }
}

class Account {
    private double balance;

    public Account(double balance) {
        super();
        this.balance = balance;
    }

    public boolean withdraw(double money) {
        if (money < 0) {
            throw new IllegalArgumentException("取款金额" + money + "有问题，取款金额不能小于0");
        }
        if (money > balance) {
            throw new RuntimeException("余额不足");
        }
        balance -= money;
        return true;
    }
}

throw和throws什么区别？

（1）throw用于方法内部，手动抛出异常对象，是个可执行的语句。throws用于方法声明。
（2）throw后面抛出异常对象且只有一个，throws声明异常类型且可以是多种。

自定义异常

如果系统预定义的异常类型，
例如：ArrayIndexOutOfBoundsException
ClassCastException//类型转换异常
NullPointerException
ArithmeticException
InputMisMatchException
IllegalAugumentException
…
发现不能准确的表达你当前的异常类型的意思时，可以选择自定义一个异常类。

1、自定义的要求：
（1）必须继承Throwable或它的子类
但是实际开发中，一般继承RuntimeException和Exception

（2）建议保留两种构造器的形式
①无参构造
②带给父类的message属性赋值的构造器

2、如何使用自定义异常
只能使用throw语句进行手动抛出。它不能由JVM自动抛出。

3、建议
在自定义异常时，异常的类型名非常重要，见名知意。

演示代码：

 public static void main(String[] args) {
        Account a = new Account(100);
        try {
            a.withdraw(-100);
        } catch (MoneyCannotNegativeException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }
}

//例如：声明一个异常类型，表示金额不能为负数
class MoneyCannotNegativeException extends Exception {

    public MoneyCannotNegativeException() {
        super();
    }

    public MoneyCannotNegativeException(String message) {
        super(message);
    }

}

class Account {
    private double balance;

    public Account(double balance) {
        super();
        this.balance = balance;
    }

    public boolean withdraw(double money) throws MoneyCannotNegativeException {
        if (money < 0) {
            throw new MoneyCannotNegativeException("取款金额" + money + "有问题，取款金额不能小于0");
        }
        if (money > balance) {
            throw new RuntimeException("余额不足");
        }
        balance -= money;
        return true;
    }
}