Java 异常处理与自定义异常

异常体系

1. 异常是程序运行时出现意外的,不正确的情况或结果,若没有正确处理异常会导致程序中断
2. Throwable继承自Object类,是所有异常的父类,有Error和Exception两个直接子类,Error表示错误,Exception表示异常
3. 异常又分运行异常和编译异常,运行异常在编译时期不检查,只有在运行时才会出现,而编译异常在编译时期将被检查,如果检查出来不处理程序将无法执行
   

Throwable、Error、Exception的区别

1. Throwable包括Error和Exception(Throwable是Error和Exception的父类)
2. Error表示程序错误,Exception表示程序异常
3. 异常能被程序本身处理,而错误是无法处理的,将直接停止JVM的运行

try-catch处理异常

捕获单个异常

/* 
	一旦出现异常,程序会立即终止,所以我们必须处理异常
	处理异常有两种方式,一种是抛出异常给调用者处理,一种是捕获异常自己直接处理
*/

/* 捕获单个异常
try {
	有异常的代码块
} catch(异常类型 变量) {
	处理异常的代码块
}
*/
public class CatchDemo {
    public static void main(String[] args) {
        System.out.println("begin...");
        
        // 有异常,但是已经处理了,所以可以运行后面的代码,如果不处理将终止程序,后面代码将不再执行
        divide(1, 0);	
        
        System.out.println("end...");	// 如果没有处理异常,这里将不会执行到
    }

    public static void divide(int a, int b) {
    	// 捕获单个异常
        try {
            System.out.println(a / b);
        } catch (ArithmeticException e) {
        	// 处理异常,这里暂时做打印处理
            System.out.println("分母为0,除法运算错误");
        }
    }
}

捕获多个异常

在处理多种异常类型时，必须先捕获子类型异常，后捕获父类型异常。

/*	语法:
	捕获多个异常
	try {
		有异常的代码块
	} catch(异常类型A 变量) {
		处理异常的代码块
	} catch(异常类型B 变量) {
		处理异常的代码块
	}
	解析:1. 异常代码块可能不止一个异常,可以捕获多个异常,每加一个catch就能多捕获一个
		2. 异常类型自上而下依次增大,父类型异常不能放在子异常类型前面
		3. 最后面的异常捕获尽量使用一个Exception异常,防止出现其他没有考虑到的异常
		4. 虽然异常处理可以直接使用一个最大类的异常(Exception)处理,但是处理结果太笼统
*/
public class CatchCatchDemo {
    public static void main(String[] args) {
        System.out.println("begin...");

		// 异常处理完才能运行后面的代码
        divide("1", "p");

        System.out.println("end...");
    }

    public static void divide(String a, String b) {
    	// 捕获多个异常
        try {
            System.out.println(Integer.parseInt(a) / Integer.parseInt(b));
        } catch (NumberFormatException e) {			// 异常类型从小到大,可以存在平级
            System.out.println("数字格式化异常");
        } catch (ArithmeticException e) {
            System.out.println("算术运算异常");
        } catch (Exception e) {
        	System.out.println("其他异常");
        }
    }
}

finally语句块

try语句块必须和catch语句块或者finally语句块同在,finally语句块总会执行,不论是否有错误出现,但如果try语句块存在JVM退出代码(System.exit(0)),finally语句块就不会执行了.一般的,我们把关闭资源的代码放在finally语句块中,保证资源总是能关闭.

try {
	有异常代码块
} catch(异常类型 变量) {
	异常处理代码块
} finally {
	代码块,不论异常是否被处理都会执行的代码块
}

throws关键字

/* 	
	throws抛出异常,方法里面可能会产生异常,但是方法不想处理,提醒调用该方法的方法需要做异常处理
 	若某方法内可能出现多个异常,那么可以同时声明抛出多个异常类型,
 	异常类之间使用逗号隔开,或者使用Exception
*/
public void divide(int a, int b) throws ArithmeticException {
	System.out.println(a / b);	// 提醒调用该方法的方法需要处理异常
}

throw关键字

/*
	当方法内需要返回一个错误给调用者时,使用throw关键字在方法内手动抛出一个具体的异常对象
*/
public class MathDemo {
	public int getDiv(int a, int b) {
		if(b == 0) {
			throw new Arithmetic("输入错误,除数不能为0");
		}
		return a / b;
	}
}

throws与throw的区别

1. throws是用于方法声明上,表示该方法不需要处理某种类型的异常,也在提醒该方法的调用者需要处理异常
2. throw用于返回一个错误结果,抛出具体异常类的对象给调用者

自定义异常

1. 一个异常类只表示某一种特定的异常类型
2. 在项目开发中可能会出现特定的逻辑错误,此时可以把这些错误封装成异常,也就是自定义异常
3. 自定义异常可以继承Exception类或RuntimeException类,一般推荐继承RuntimeException类
4. 继承异常类之后需要提供无参构造器和一个带String类型参数的构造器

// 需求:模拟银行存取款,取款金额为负或者取款大于存款时提示用户

// 取款金额为负时抛出NagativeFundsException自定义异常
public class NegativeFundsException extends RuntimeException {
	// 无参构造器
	public NegativeFundsException() {}

	// 带String类型参数的构造器
	public NegativeFundsException(String message) {
		super(message);
	}
}

// 取款金额大于存款时抛出InsufficientFundsException自定义异常
public class InsufficientFundsException extends RuntimeException {
	// 无参构造器
	public InsufficientFundsException() {}

	// 带String类型参数的构造器
	public InsufficientFundsException(String message) {
		super(message);
	}
}

// 银行类
public class Account {
	private double balance;	// 存款

	public Account(double balance) {	// 构造器,初始化账户余额
		this.balance = balance;	
	}

	public void withDraw(double dAmount) {	// 取款方法
		if(dAmount < 0) {	// 取款金额为负,抛出自定义异常
			throw new NagativeFundsException("取款金额不能为负");
		}
		if(balance < dAmount) {	// 取款金额大于余额抛出自定义异常
			throw new InsufficientFundsException("余额不足");
		}
		System.out.println("取款成功,余额: " + (balance - dAmount));
	}

}