【Java学习笔记】IO流之异常

package com.hw.exception;

public class ExceptionDemo1 {
	public static void main(String[] args) {
		method1();
	}

	private static void method1() {
		int a = 10;
		int b = 0;
		System.out.println(a/b);
		System.out.println("==========end==========");
	}
}

运行之后出现异常ArithmeticException，如下所示，可以看到，异常后面的语句并没有输出在控制台上！

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at com.hw.exception.ExceptionDemo1.method1(ExceptionDemo1.java:11)
	at com.hw.exception.ExceptionDemo1.main(ExceptionDemo1.java:5)

JVM发现运算违反了数学运算规则，java将这种常见的问题进行描述，并封装成了对象叫做ArithmeticException。当除0运算发生后，JVM将该问题打包成了一个异常对象，并将对象抛给调用者main函数，new ArithmeticException("/by zero")；

main函数收到这个问题时，有两种处理方式：

自己将该问题处理，然后继续运行
自己没有针对的处理方式，只有交给调用main的JVM来处理，JVM有一个默认的异常处理机制，就将该异常进行处理，并将该异常的名称、异常的信息、异常出现的位置打印在了控制台上，同时将程序停止运行！

上面的代码使用的是JVM的默认处理方案！

下面我们来看下如何使用try..catch和throws处理异常！

3.2 try...catch的方式处理异常

try {
    可能出现问题的代码;
}catch(异常名 变量) {
    针对问题的处理;
}finally {
    释放资源;
}

注意：
    try里面的代码越少越好；
    catch里面必须有内容；

使用try...catch处理上面3.1的代码，如下所示：

public static void main(String[] args) {
		// method1();
		method2();
}

private static void method2() {
	int a = 10;
	int b = 0;
	try {
		System.out.println(a/b);
	} catch (ArithmeticException e) {
		e.printStackTrace();
	}
	System.out.println("==========end==========");
}

运行结果如下：

java.lang.ArithmeticException: / by zero
	at com.hw.exception.ExceptionDemo1.method2(ExceptionDemo1.java:13)
	at com.hw.exception.ExceptionDemo1.main(ExceptionDemo1.java:6)
==========end==========

3.3 throws的方式处理异常

使用throws处理上面3.1的代码，如下：

// 尽量不要在main方法上throws抛出异常
public static void main(String[] args) {
	// method1();
	// method2();
	try {
		method3();
	} catch (ArithmeticException e) {
		e.printStackTrace();
	}

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

private static void method3() throws ArithmeticException {
	int a = 10;
	int b = 0;
	System.out.println(a/b);
}

运行结果如下所示：

java.lang.ArithmeticException: / by zero
	at com.hw.exception.ExceptionDemo1.method2(ExceptionDemo1.java:13)
	at com.hw.exception.ExceptionDemo1.main(ExceptionDemo1.java:6)
==========end==========

4.throw和throws的区别

throws

用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常

throw

用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw则是抛出了异常，执行throw则一定抛出了某种异常

需求：举例分别演示编译时异常对象和运行时异常对象的抛出！

4.1 运行时异常对象的抛出，代码如下：

public static void main(String[] args) {
	method1();
}

// 演示运行时异常对象的抛出
private static void method1() {
	int a = 10;
	int b = 0;
	if (b == 0) {
		throw new ArithmeticException("除数为0！");
	} else {
		System.out.println(a / b);
	}
}

4.2 编译时异常对象的抛出，如下所示：

5.final、finally和finalize的区别

final：最终的意思，可以修饰类，成员变量，成员方法；

修饰类，类不能被继承；
修饰变量，变量是常量；
修饰方法，方法不能被重写。

finally：是异常处理的一部分，用于释放资源。一般来说，代码肯定会执行，特殊情况：在执行到finally之前JVM退出了！

finalize：是Object类的一个方法，用于垃圾回收！

6.自定义异常

java不可能对所有的情况都考虑到，所以，在实际的开发中，我们可能需要自己定义异常。而我们自己随意的写一个类，是不能作为异常类来看的，要想你的类是一个异常类，就必须继承自Exception或者RuntimeException。

需求：自定义异常，考试成绩必须在0-100之间！

自定义一个异常类MyException.java，代码如下：

package com.hxs.exception;

/**
 * 自定义异常类
 * 
 * @author HW
 * 
 */
public class MyException extends Exception {

	public MyException() {
	}

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

	public MyException(Throwable cause) {
		super(cause);
	}

	public MyException(String message, Throwable cause) {
		super(message, cause);
	}
}

Teacher.java代码如下：

package com.hxs.exception;

public class Teacher {
	public void check(int score) throws MyException {
		if(score < 0 || score > 100) {
			throw new MyException("输入的学生分数必须在0-100之间！");
		} else {
			System.out.println("输入的学生分数没有问题！");
		}
	}
}

自定义异常测试类TeacherTest.java代码如下：

package com.hxs.exception;

import java.util.Scanner;

/**
 * 自定义异常测试类
 * 
 * @author HW
 * 
 */
public class TeacherTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入学生的成绩：");
		int score = sc.nextInt();
		
		Teacher teacher = new Teacher();
		try {
			teacher.check(score);
		} catch (MyException e) {
			e.printStackTrace();
		}
	}
}

例如：输入一个大于100的成绩，会抛出自定义异常，如下：