学习Java第十七天

Java异常

什么是异常

• 错误在我们编写程序过程中经常发生，包括编译期间和运行期间的错误

运行期间错误

• 在程序运行过程中，意外发生的情况，背离我们程序本身的意图的表现，都可以理解为异常

异常分类

• Throwable有两个重要的子类：Eexeption 和 Error

Error

• Error是程序无法处理的错误，表示运行应用程序中较严重的问题。大多数错误与代码编写者的执行操作无关，而表示代码运行时的JVM（Java虚拟机）出现的问题
• 例如，Java虚拟机运行错误（virtual MachineError），当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError
• 这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况
• 对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况
• 因此我们编写程序时不需要关心这类异常

Exception

• Exception 是程序本身可以处理的异常，异常处理通常只针对这种类型异常的处理
• Exception 类的异常包括 checked exception 和 unchecked exception

unchecked exception

• unchecked exception：编译器不要求强制处理的异常
• 包含RuntimeException 类及其子类异常
• 如NullPointerException（空指针异常）、IndexOutOfBoundsException（下标越界异常）等，这些异常是unchecked exception
• Java编译器不会检查这些异常，在程序中可以选择捕获处理，也可以不处理，照样正常编译通过

checked exception

• checked exception：编译器要求必须处理的异常
• 要RuntimeException 及其子类以外，其他的Exception子类
• 如IOException、SQLException等
• Java编译器会检查这些异常，当程序中可能出现这类异常时，要求必须进行异常处理，否则编译不会通过

异常处理

在Java应用程序中，异常处理机制为：抛出异常、捕获异常

抛出异常

• 当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统
• 异常对象中包含了异常类型和异常出现时的程序状态等异常信息
• 运行时系统负责寻找处置异常的代码并执行

捕获异常

• 在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器
• 运行时系统从发生异常的方法开始，依次回查调用栈中的方法，当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适的异常处理器
• 当运行时系统遍历调运栈而未找到合适的异常处理器，则运行时系统终止。同时，意味着Java程序的终止
• 对于运行时的异常，错误或可查异常，Java技术所要求的异常处理方式有所不同
  
  简单来说，异常总是先被抛出，后被捕捉

通过5个关键字实现：try、catch、finally、throw、throws

try-catch-finally

多重catch

• 一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会
• 对于有多个catch子句的异常程序而言，应该尽量将捕获底层异常类的catch子句放在前面，同时尽量将捕获相对高层的异常类的catch子句放在后面。否则，捕获底层异常类的catch子句将可能会被屏蔽

引发多种类型的导常

-排列 catch 语句的顺序：先子类后父类
-发生异常时按顺序逐个匹配
-只执行第一个与异常类型匹配的catch

实际应用中的经验与总结

• 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
• 在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常
• 对于不确定的代码,也可以加上try-catch，处理潜在的异常
• 尽量去处理异常，切忌只是简单的调用prinsStackTrace()去打印输出
• 具体如何处理异常，要根据不同的业多需求和异常类型去决定
• 尽量添加finally语句块去释放占用的资源

package com.sh.test;
import java.util.InputMismatchException;
import java.util.Scanner;

public class TryDemoOne {

	public static void main(String[] args) {
	/*	// 要求：定义两个整数，输出两数之商
		
		int one=12;
		int two=2;
		System.out.println("one和two的商是："+ (one/two));
    */
		
		// 要求：定义两个整数，接受用户的键盘输入，输出两数之商
		Scanner input=new Scanner(System.in);
		System.out.println("=====运算开始=====");
		try{
			System.out.print("请输入第一个整数：");
			int one=input.nextInt();
			System.out.print("请输入第二个整数：");
			int two=input.nextInt();
			System.out.println("one和two的商是："+ (one/two));
		}catch(ArithmeticException e){
			System.exit(1);//终止程序运行
			System.out.println("除数不允许为零");
			e.printStackTrace();
		}catch(InputMismatchException e){
			System.out.println("请输入整数");
			e.printStackTrace();
    	}catch(Exception e){
			System.out.println("出错啦~~");
			e.printStackTrace();
		}finally{
			System.out.println("=====运算结束=====");
		}
	}
}

return关键字在异常中的用法

package com.sh.test;
import java.util.InputMismatchException;
import java.util.Scanner;

public class TryDemoTwo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int result=test();
		System.out.println("one和two的商是："+ result);
		
	}

	public static int test(){
		Scanner input=new Scanner(System.in);
		System.out.println("=====运算开始=====");
		try{
			System.out.print("请输入第一个整数：");
			int one=input.nextInt();
			System.out.print("请输入第二个整数：");
			int two=input.nextInt();
			return one/two;
		}catch(ArithmeticException e){
			System.out.println("除数不允许为零");
			return 0;
		}finally{
			System.out.println("=====运算结束=====");
		//	return -100000;
		}
	}
}

throw & throws

• 可以通过throws声明将要抛出何种类型的异常,通过throw将产生的异常抛出

throws

• 如果一个方法可能会出现异常,但没有能力处理这种异常,可以在方法声明处用throws子句来声明抛出异常
• 例如:汽车在运行时可能会出现故障,汽车本身没办法处理这个故障, |那就让开车的人来处理

package com.sh.test;
import java.util.InputMismatchException;
import java.util.Scanner;

public class TryDemoThree {

	public static void main(String[] args) throws Exception {
//		try {
//			// TODO Auto-generated method stub
//			int result = test();
//			System.out.println("one和two的商是：" + result);
//		} catch (ArithmeticException e) {
//			System.out.println("除数不允许为零");
//			e.printStackTrace();
//		}catch(InputMismatchException e){
//			System.out.println("请输入整数");
//			e.printStackTrace();
//	}
		try{
			int result = test();
			System.out.println("one和two的商是：" + result);
		}catch(ArithmeticException e){
			
		}catch(InputMismatchException e){
			
		}catch(Exception e){
			
		}
		int result2=test();
	}

	/*通过throws抛出异常时，针对可能出现的多种异常情况，解决方案：
	 * 1、throws后面接多个异常类型，中间用逗号分隔
	 * 2、throws后面接Exception
	 * */
	/**
	 * 测试接收数据相除结果的方法
	 * @return 两个接收数据的商
	 * @throws ArithmeticException
	 * @throws InputMismatchException
	 */
//	public static int test() throws ArithmeticException,InputMismatchException{
//		Scanner input = new Scanner(System.in);
//		System.out.println("=====运算开始=====");
//		System.out.print("请输入第一个整数：");
//		int one = input.nextInt();
//		System.out.print("请输入第二个整数：");
//		int two = input.nextInt();
//		System.out.println("=====运算结束=====");
//		return one / two;
//	}

	public static int test() throws Exception{
		Scanner input = new Scanner(System.in);
		System.out.println("=====运算开始=====");
		System.out.print("请输入第一个整数：");
		int one = input.nextInt();
		System.out.print("请输入第二个整数：");
		int two = input.nextInt();
		System.out.println("=====运算结束=====");
		return one / two;
	}
}

throws使用规则

• 如果是不可查异常( unchecked exception )，即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过,但在运行时会被系统抛出
• 如果一个方法中可能出现可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误
• 当抛出了异常，则该方法的调用者必须处理或者重新抛出该异常
• 当子类重写父类抛出异常的方法时，声明的异常必须是父类方法所声明异常的同类或子类

throw

• throw用来抛出一个异常
• 例如: throw new IOException();
• throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象
• 例如：throw new String(出错啦")；是错误的

自定义异常

• 使用Java内置的异常类可以描述在编程时出现的大部分异常情况
• 也可以通过自定义异常描述特定业务产生的异常类型
• 所谓自定义异常,就是定义一个类，去继承Throwable类或者它的子类

自定义异常类

package com.sh.test;

public class HotelAgeException extends Exception {
	public HotelAgeException(){
		super("18岁以下，80岁以上的住客必须由亲友陪同");
	}
}

class SubException extends HotelAgeException{
	
}

package com.imooc.test;

import java.util.Scanner;

public class TryDemoFour {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			testAge();
		} catch (HotelAgeException e) {
			System.out.println(e.getMessage());
			System.out.println("酒店前台工作人员不允许办理入住登记");
		}catch(Exception e){
			e.printStackTrace();
		}
	}

	/*
	 * throw抛出异常对象的处理方案：
	 * 1、通过try..catch包含throw语句--自己抛自己处理
	 * 2、通过throws在方法声明出抛出异常类型--谁调用谁处理--调用者可以自己处理，也可以继续上抛
	 *    此时可以抛出与throw对象相同的类型或者其父类
	 */
	// 描述酒店的入住规则：限定年龄，18岁以下，80岁以上的住客必须由亲友陪同
	/*public static void testAge() {

		try {
			System.out.println("请输入年龄：");
			Scanner input = new Scanner(System.in);
			int age = input.nextInt();
			if (age < 18 || age > 80) {
				throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");
			} else {
				System.out.println("欢迎入住本酒店");
			}
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}*/
	public static void testAge() throws HotelAgeException {
		System.out.println("请输入年龄：");
		Scanner input = new Scanner(System.in);
		int age = input.nextInt();
		if (age < 18 || age > 80) {
			//throw new ArithmeticException();
			//throw new Exception("18岁以下，80岁以上的住客必须由亲友陪同");
			throw new HotelAgeException();
		} else {
			System.out.println("欢迎入住本酒店");
		}
	}
}

异常链

• 有时候我们会捕获一个异常后再抛出另一个异常
• 顾名思义就是：将异常发生的原因一个传一个串起来，即把底层的异常信息传给上层，这样逐层抛出

package com.sh.test;
public class TryDemoFive {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			testThree();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public static void testOne() throws HotelAgeException {
		throw new HotelAgeException();
	}

	public static void testTwo() throws Exception {
		try {
			testOne();
		} catch (HotelAgeException e) {
			throw new Exception("我是新产生的异常1",e);
		}
	}

	public static void testThree() throws Exception {
		try {
			testTwo();
		} catch (Exception e) {
			Exception e1=new Exception("我是新产生的异常2");
			e1.initCause(e);
			throw e1;
//			throw new Exception("我是新产生的异常2",e);
		}
	}
}

总结

• 异常
• 异常分类
• 异常处理（抛出异常，捕获异常）
• 异常处理 try-catch-finally
• 自定义异常
• 异常链
• 常见异常类型