JAVA学习7-----异常

1.异常的概念

异常：指的是程序在执行过程中，出现非正常的情况，最终会导致JVM的非正常停止。

在JAVA中，异常就是一个类，产生异常就是创建异常对象并抛出一个异常对象。JAVA处理异常的方式是中断处理。异常不包括语法错误。

1.1异常的体系

异常机制是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：
（1）java.lang.Error;//不能处理的，只能尽量避免，只能修改代码才能继续执行，比如创建数组太大了，内存溢出，超出了给JVM分配的内存；
（2）java.lang.Exception;//一般异常指的是这个，编译期异常，由于使用不当导致，可以避免，处理后可继续执行；
Exception下，又有一个RuntimeException，它叫运行期异常，java程序运行过程中出现得问题，比如数组越界访问之类的。

1.2异常的分类

在代码中，对于异常，一般有两种处理方法，一是交给虚拟机处理，这样的话，遇到异常时编译器会终止程序，即中断处理，把异常打印到控制台；二是try-catch处理方式，仍然会把异常打印到控制台，但是不会中断处理，后续代码仍然会执行。

注意，在IDEA中，编写代码时，编译器在可能出现异常的地方会标记红色波浪线，这时候按Alt+回车，可以选择处理异常的两种方式。

//第一种处理方法，交给虚拟机
public class Demo1Exception {
	public static void main(String[] args) throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date date = sdf.parse("1999-03-22");
		System.out.println(date);
	}
}

//第二种处理方法，try-catch方法；
public class Demo1Exception {
	public static void main(String[] args) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date date = null;
		try {
			date = sdf.parse("1999-03-22");
		} catch (ParseException e) {
			e.printStackTrace();
		}
		System.out.println(date);
	}
}

1.3 异常产生和处理过程分析

/*例程*/
public class Demo2Exception {
	public static void main(String[] args) {
		int[] arr = {1,2,3};
		int e = getElement(arr,3);
		System.out.println(e);
	}
	public static int getElement(int[] arr,int index){
		int ele = arr[index];
		return ele;
	}
}

上述程序会抛出异常，在虚拟机JVM上抛出异常并中断程序。具体过程如下：

Step1：访问了数组中的3索引，而数组没有3索引，JVM就会检测程序出现异常。JVM就会做出两件事情：
（1）JVM会根据异常产生的原因创建一个异常对象，这个异常对象包含了异常产生的内容、原因、位置，例程中产生的是new ；ArrayIndexOutOfBoundsException(“3”);
（2）在getElement方法中，没有异常的处理逻辑(try…catch)，那么JVM会把异常对象抛出给方法的调用者main方法处理这个异常；

Step2:main方法接收到了这个异常对象，main方法也没有异常的处理逻辑，继续把对象抛出给main方法的调用者JVM处理。

Step3：JVM接收到这个异常对象，做两件事：
（1）把异常对象（内容、原因、位置）以红色的字体打印在控制台；
（2）JVM会终止当前正在执行的java程序，即做中断处理；

2.异常的处理

异常处理五个关键字:try,catch,finally,throw,throws;

2.1抛出异常throw

/*
例程
throw关键字
作用：
	可以使用throw关键字在指定的方法中抛出指定的异常；
使用格式：
	throw new xxxException("产生异常的原因");
注意：
	1.throw关键字必须写在方法的内部；
	2.throw关键字后边new的对象必须是Exception或者Exception的子类对象；
	3.throw关键字抛出指定的异常对象，我们就必须处理这个异常对象。throw关键字后边创建的是RuntimeException或者是RuntimeException的子类对象，我们可以不处理，默认交给JVM处理（打印异常对象，中断程序）
	throw关键字后边创建的是编译异常（写代码的时候报错），我们就必须处理这个异常，要么throws，要么try...catch
*/

public class Demo3Throw {
	/*	
		定义一个方法获取数组指定索引处的元素值
		在日后的工作中，我们必须对方法传递过来的参数进行合法性校验，如果参数不合法，那我们就必须用抛出异常的方式，告知方法的调用者，传递参数有问题
	*/
	public static int getElement(int[] arr, int index){
		if(arr==null){
			throw new NullPointException("传递的数组值是空！");
			//但NullPointException是一个运行期异常，我们也可以不用处理，默认交给JVM处理;
		}
		if(index<0 || index>arr.length-1) {
			throw new ArrayIndexOutOfBoundsException(”传递的索引超出了数组的使用范围！“);
			//但ArrayIndexOutOfBoundsException是一个运行期异常，我们也可以不用处理，默认交给JVM处理;
		}
		return arr[index];
	}
}

小tip：
public static T requireNonNull(T obj):查看指定引用对象是不是null，用的也是这种方法，因此类似的方法中，可以直接使用objects.requireNonNull(obj)即可。

public class Demo4 {
	public static void main(String[] args) {
		method(null);
	}
	public static void method(Object obj) {
		/*if(obj==null) {
			throw new NullPointerException("传递的值是null");
		}*/
		Objects.requireNonNull(obj,"传递的值是null");//重载，只有一个参数也行
	}
}

2.2声明异常throws

将问题标识出来，报告给调用者，如果方法内通过throw抛出了编译时的异常，而没有捕获处理，那么需要通过throws进行声明，让调用者去处理。

/*
	throws关键字:异常处理第一种方式，交给别人处理
	作用：
		当方法内部抛出异常的时候，那么我们必须处理这个异常对象；
		可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者（自己不处理，给别人处理），最终交给JVM处理，即中断处理
	使用方法：
		修饰符 返回值类型 方法名（参数列表） throws AAAException,BBBException...{
			throw new AAAException(”产生的原因“）；
			throw new BBBException("产生的原因");
		}
	1.throws关键字必须写作方法声明处；
	2.throws关键字后边声明的异常必须是Exception或者其子类
	3.方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常；如果抛出多个异常对象有子父类关系，那么直接声明父类异常即可；
	4.调用了一个声明抛出异常的方法，我们就必须处理声明的异常，要么继续throws声明抛出，交给方法的调用者处理，最终交给JVM中断处理，要么try...catch自己处理异常
*/

public class Demo5Throws {
	public static void main(String[] args) throws FileNotFoundException,IOException {
	//因为上面两个异常都是Exception的子类，因此直接在这里写Exception就可以了
		readFile("c:\\a.txt");
	}
	/*
		注意：FileNotFoundException是编译异常，抛出了编译异常，就必须处理这个异常，可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法的调用者处理
	*/
	public static void readFile(String filename) throws FileNotFoundException，IOException{
		if(!fileName.equals("c:\\a.txt")) {
			throw new FileNotFoundException("传递的文件路径不是c:\\a.txt");
		}
		if(!fileName.endsWith(".txt")) {
			throw new IOException("文件的后缀名不对");
		}
	}
	//也可以多抛出几个
	
}

2.3异常的第二种处理方式，捕获异常

第一种是throws抛出异常给调用者。
第二种方式：try-catch，这不会使程序停止。

/*
	try...catch异常处理的方式，自己处理异常
	格式：
		try{
			可能产生异常的代码
		}catch(定义一个异常的变量，用来接收try种抛出的异常对象){
		异常的处理逻辑，捕获异常对象后，怎么处理异常对象；
		一般在工作中，会把异常的信息记录到一个日志种
		}
		...
		catch(异常类名 变量名){
		
		}

	注意：
		1.try中可能会抛出多少个异常对象，那么就可以使用多少个catch来处理这些异常对象；
		2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，然后继续执行之后的代码；若没产生异常，则只执行try中的代码，然后执行之后的代码；
*/

public class Demo5Throws {
	public static void main(String[] args) {
		try{
			readFile("c:\\a.txt");
		}catch (IOException e) {
			System.out.println("catch-传递的文件后缀不是.txt");
		}
		System.out.println(”后续代码“）;
	}
	/*
		注意：FileNotFoundException是编译异常，抛出了编译异常，就必须处理这个异常，可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法的调用者处理
	*/
	public static void readFile(String filename) throws IOException{
		if(!fileName.equals("c:\\a.txt")) {
			throw new IOException("文件的后缀名不对");
		}
	}
	//也可以多抛出几个
	
}

2.4 Throwable类中定义的三个异常处理的方法

Throwable类中定义了3个异常处理的方法；
（1）String getMessage()返回此Throwable的简短描述。
（2）String toString()返回此Throwable的详细消息字符串；
（3）void printStackTrace() JVM打印异常对象，默认调用此方法，因为这个方法异常信息最全面。

public class Demo5Throws {
	public static void main(String[] args) {
		try{
			readFile("c:\\a.txt");
		}catch (IOException e) {
			System.out.println(e.getMessage());
			System.out.println(e.toString());
			e.printStackTrace();
		}
		System.out.println(”后续代码“）;
	}

	public static void readFile(String filename) throws IOException{
		if(!fileName.equals("c:\\a.txt")) {
			throw new IOException("文件的后缀名不对");
		}
	}
	//也可以多抛出几个
	
}

2.4 finally代码块

public class Demo5Throws {
	public static void main(String[] args) {
		try{
			readFile("c:\\a.txt");
		}catch (IOException e) {
			e.printStackTrace();
		}finally {
			//无论是否出现异常都会执行
			/*
			注意：
				1.finally不能单独使用，必须和try一起；
				2.finally一般用于资源释放、资源回收
			*/
		}
		System.out.println(”后续代码“）;
	}

	public static void readFile(String filename) throws IOException{
		if(!fileName.equals("c:\\a.txt")) {
			throw new IOException("文件的后缀名不对");
		}
	}
}

2.5 多个异常捕获的三种方法

（1）多个try-catch的方法；
（2）一个try多个catch的方法，注意事项：
catch里面定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则会报错；
（3）多个异常一次捕获一次处理，即catch中直接定义Exception e，其他的异常都是它的子类。

注意：运行时异常被抛出可以不处理，即不捕获也不声明抛出，默认给JVM处理。

2.6 注意事项：子父类异常

子父类异常：
（1）如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者父类异常的子类或者不抛出异常。
（2）父类方法没有抛出异常，子类重写父类方法时也不可以抛出异常，此时子类产生该异常，只能捕获处理，不能声明抛出。

即父类异常是什么样，子类异常就是什么样。

3. 自定义异常

3.1 自定义异常概念

如我们有一个person类，我们需要定义一个关于person类的异常，就需要这个功能，类似的还有注册异常、登录异常等，只要java提供的异常类，不够我们使用，就需要自己定义一些异常类。

/*
	自定义异常类：
		java提供的异常类，不够我们使用，需要自己定义一些异常类
	格式：
		public class XXXException extends Exception或RuntimeException {
			添加一个空参构造方法
			添加一个带异常信息的构造方法
			以上两个方法内部，都是调用父类的构造方法而已
		}
	注意：
		（1）自定义异常类一般是以Exception结尾，说明类是一个异常类
		（2）自定义异常类，必须的继承Exception或者RuntimeException
			继承Exception：那么自定义的异常类就是一个编译期异常，如果方法内部抛出了编译器异常，要么throws，要么try...catch..
			继承RuntimeException:那么自定义的异常类就是一个运行期异常，无需处理，交给虚拟机处理（中断处理）
*/

public class RegisterException extends Exception {
	public RegisterExcetpion() {
		super();
	}

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

3.2 自定义异常的需求案例

/*
	要求：模拟注册操作，如果用户名已经存在，则抛出异常并提示相关信息。
	分析：
		1.使用数组保存已经注册过的用户名（数据库）
		2.使用Scanner获取用户输入的注册的用户名（前端页面）
		3.定义一个方法，对用户输入的用户名进行判断：遍历存储已经注册过的用户名数组，比较
			true:
				用户名已经存在，抛出RegisterException异常，告知用户已被注册；
			false:
				继续遍历比较
		结束后，无重复，则提示注册成功；
*/
public class RegisterException extends Exception {
	public RegisterExcetpion() {
		super();
	}

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

public calss Demo1 {
	static String[] usernames = {"刘某“，”郭某“，”林某“}；
	public static void main(String[] args) throws RegisterException {
		Scanner sc = new Scannerr(System.in);
		System.out.println("请输入你的名字");
		String username = sc.next();
		CheckUsername(username);
	}

	public static void checkUsername(String username) throws RegisterException {
		for(String name:usernames) {
			if(name.equals(username)) {
				throw new RegisterException("已被注册，请更改名字");
			}
		}
		System.out.println("注册成功");
	}

	//第二种方法，try-catch
	public static void checkUsername_TryCatch(String username) {
		for(String name:usernames) {
			if(name.equals(username)) {
				try {
					throw new RegisterException("已被注册");
				} catch (RegisterException e) {
					e.printStackTrace();
					return;
				}
			}
		}
		System.out.println("注册成功");
	}
}

注意，如果RegisterException继承的是RuntimeException，则在创建这个注册异常的其他类的方法中，不需要处理这个异常，也不需要throws这个异常，它会自动交给JVM处理，即中断处理。