04-异常处理

Posted 2020-10-20 道廷の博客

异常的概念（运行期出现的错误）

• java 异常是 java 提供的用于处理程序中错误的一种机制。

• 所谓的错误是指在程序运行的过程中发生的一些异常事件。（如：除0溢出，数组下标越界，所要读取的文件不存在）

• 设计良好的程序应该在异常发生时提供处理这些错误的方法，使得程序不会因为异常的发生而阻断或产生不可预见的结果。

• java 程序的执行过程中如果出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并将被提交给java运行时系统，这个过程被称为抛出（throw）异常。

• 当 java 运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象叫给其处理，这一过程称为捕获（catch）异常。

• try里面编写可能抛出异常的代码，catch编写捕获异常后处理的代码。

• 把发生异常的堆栈打印出来：e.printStackTrace();

异常的分类

• 异常根类 Throwable 分子类 Error + Exception

• Error 是系统内部错误（虚拟机生成并抛出，包括动态链接失败，虚拟机错误等，程序不对其做处理）。

• Exception是我们可以处理的所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显式的声明或捕获。

• Exception 分 RuntimeException（运行期异常）+ 其他。

• RuntimeException：一类特殊的异常，如除0异常，数组下标越界等，其产生的比较频繁，处理麻烦，如果显式的声明或者捕获将会对程序的可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序，用户可以catch，也可以不catch。

void m(int i) throws ArithmeticException {
    if(0==i) {
	    throw new ArithmeticException("除0异常 1th");
	}
}

public class Test {
	public static void main(String[] args) {
		
		try {
			Test t = new Test();
			t.m(0);
		} 
		catch (Exception e) {
			System.out.println("除0异常 2th");
		}
	}
}

• 常见异常类型举例：

1. ArithmeticException

int i = 1;
int k = 0;
int m = i/k;

2. NullPointerException

String s = null;
int l = s.length();

3. ClassCastException

Object o = new Object();
String s = (String)o;
int l = s.length();

4. NegativeArraySizeException

int len = -1;
int[] a = new int[len];
a[0] = 0;

5. ArrayIndexOutOfBoundsException

int len = 10;
int[] a = new int[len];
a[10] = 10;

---

异常的捕获和处理

• try语句：

1. try语句制定了一段代码，该段代码就是一次捕获并处理的例外的情况。
2. 在执行的过程中，该段代码可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理。
3. 如果没有例外产生，所有的catch代码段都被忽略不执行。

• catch语句：

1. 在catch语句块中是对异常进行处理的代码，每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
2. 在catch中声明的异常对象（catch (someExpresion e)）封装了异常事件发生的信息，在catch语句块中可以使用这个对象的一些方法获取这个信息：例如：getMessage(); 用来得到有关异常事件的信息；printStackTrace();用来跟踪异常事件发生时执行堆栈的内容。

• finally语句：

1. catch语句块后面可以跟上一个finally语句块。
2. finally语句为异常处理提供一个统一的出口，使得在控制流程转到程序的其他部分以前，能对程序的状态作统一的管理。
3. 无论try所指向的程序是否抛出异常，finally所指定的代码都要被执行。
4. 通常在finally语句中可以进行资源的清理工作。如：关闭打开的文件；删除临时文件等。

FileInputStream in = null;

try {
	in = new FileInputStream("myfile.txt");
	int b = 0;
	b = in.read();
	while(-1 != b) {
		System.out.print((char)b);
		b = in.rasd();
	}
} 
catch (FileNotFoundException e) {
    e.printStackTrace();
} 
catch (IOException e) {
	System.out.println(e.getMessage());
} 
finally {
	try {
		in.clsoe();
	}
	catch (IOException e) {
		e.printStackTrace();
	}
}

异常的抛出

public void someMethod() throws someExpresion { 
	if(someCondition()) {
		throw new someExpresion("错误原因"); // 然后在某种情况下抛出这种异常
	}
}

try {
	someMethod(); // 调用该方法时试图捕获异常
}
catch(someExpresion e) {
	// 异常处理代码
}

**
Tips：

1. public void someMethod() throws someExpresion：
   throws写在后面声明该方法可能抛出异常（由系统自动抛出异常），如果写了这句话，对于RuntimeException 则可以不catch，其他的异常则需要写try catch，如果你不想写try catch，则你可以再继续往外抛（在方法后面写throws）。

2.throw new someExpresion("错误原因");
表示的是手动抛出异常。
**

public class Test {
	public static void main(String[] args) {
		Test t = new Test();
		try {
			t.method1();
		} catch (someException e) {
			e.printStackTrace();
		}
	}
	
	public void method1() throws someException {
		 method2();
	}
	
	public void method2() throws someException {
		 method3();
	}
	
	public void method3() throws someException {
		 throw new someException("someException occur in method3.");
	}
}

---

注意

1. 执行throw语句之后，运行流程立即停止（如上第一份代码第二个End未打印）。然后系统立即检查是否有能够匹配的catch语句块，如果找到则执行对应的catch语句块，如果找不到则转向上一层的try语句块并继续查找对应的catch语句块，如果一直找不到对应的catch语句块，则异常对象被抛到系统异常处理。

public class Test {
	public static void pro(String s) {
		if(s != null) {
			System.out.println(s);
		}
		else {
			throw new NullPointerException("Ooops!, s is null.");
		}
		System.out.println("End");
	}
	
	public static void main(String[] args) {
		
		try {
			pro("Hello Java");
			pro(null);
		}
		catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}
}
/*
打印结果：
Hello Java
End
Ooops!, s is null.
*/

2. catch时注意：应该先捕获小的，再捕获大的，否则编译报错。

catch (NullPointerException e) {
	System.out.println("NullPointerException");
}
catch (Exception e) {
	System.out.println(e.getMessage());
}

使用自定义的异常

使用自定义异常一般有如下步骤：

1. 通过集成 java.lang.Exception 类声明自己的异常类。

2. 在方法适当的位置生成自定义异常的实例，并用 throw 语句抛出。

3. 在方法的声明部分用 throws 语句声明该方法可能抛出的异常。

class MyException extends Exception {
	private int id;
	
	public MyException(String message, int id) {
		super(message);
		this.id = id;
	}
	
	public int getId() {
		return id;
	}
}

public class Test {
	public void regist(int num) throws MyException {
		if(num < 0) {
			throw new MyException("人数为负。", 3);
		}
		System.out.println("登记人数：" + num);
	}
	
	public void manager() {
		try {
			regist(100);
		}
		catch (MyException e) {
			System.out.println("登记失败，出错类型码：" + e.getId());
			e.printStackTrace();
		}
		System.out.println("操作结束");
	}
	
	public static void main(String[] args) {
		Test t = new Test();
		t.manager();
	}
}

异常与继承

重写方法需要抛出与原方法所抛出异常类型一致的异常或不抛出异常。

例如：

class A {
	public void method() throws IOException {...}
}

class B1 extends A {
	public void method() throws FileNotFoundException {...} // 范围小了，错误
}

class B2 extends A {
	public void method() throws Exception {...} // 范围大了，错误
}

class B3 extends A {
	public void method() {...} // 正确
}

class B3 extends A {
	public void method() throws IOException, MyException{...} // 错误
}