JAVA自学课程笔记5

2021年2月10日21点59分
JAVA自学课程笔记5：
	
	异常（Exception）
		当Java程序运行出现问题时，系统会自动检测到该错误，并立即生成一个与该错误对应的异常对象。	

		异常（Exception）的分类：
			Throwable（可抛出的）：
				Error（系统错误，程序员无法处理这些异常）
				Exception（程序员可以捕获并处理的异常）
				RuntimeException（其子类所有的异常处理与否按需）：
					（其子类异常可处理可不处理）
		重写方法抛出异常的范围不能大于被重写方法抛出的异常的范围。（即子类抛出异常范围不能比父类大。）

		通过try-catch语句去捕获更正错误：
			class A{
				public int divide(int a, int b){
					int ans = a / b;
					return ans;
				}
			}

			public class Test1{
				public static void main(String[] args){
					A aa = new A();
					
					try{
						aa.divide(6, 0);
					}catch(ArithmeticException e){		//e用来接收18行抛出的异常对象（算术异常）
						System.out.printf("除零错误！除数不能为零！\n");
					}

					System.out.printf("You have excepted the error!\n");
				}
			}
		//输出结果：
			除零错误！除数不能为零！
			You have excepted the error!

		try语句只用于尝试不确定的语句，正确则运行，错误则被catch语句捕获并执行。若在try语句外出现错误，则仍会报错（相当于无视try后的源代码存在错误）。
			public class Test2{
				public static void main(String[] args){
					int m;

					try{
						m = 2;
						System.out.printf("m = %d\n", m);
					}catch(Exception e){
					}

					System.out.printf("m = %d\n", m);	//若该行存在，则显示m未初始化；若该行不存在，则显示41行的m = 2。
				}
			}
		通过e.printStackTrace();语句可以将编译错误信息显示出来。
		ArrayIndexOutOfBoundsException（数组下标越界异常）。

		throw和throws：
			若出现异常（假设这里由throw抛出异常），则可用throws将异常抛出给上层引用者。
				import java.io.*;
				
				class A{
					public void f() throws IOException{
						throw new IOException();	//throw抛出异常
					}
				}

				public class Test3{
					public static void main(String[] args){		//若在主函数后添加"throws IOException"则不会出现68行情况。												  而会“直接报错”。因为异常从主函数抛给了虚拟机。
						A aa = new A();
						//aa.f();		若使用对象a的f()函数，则会直接报错说明“抛出的异常未被处理”。
					}
				}

		try-catch语句中存在短路，若try有多条语句，则直接结束try语句跳转到catch。
		finally语句无论try语句中是否抛出异常，最终一定会执行。

		自定义异常：
			class NameException extends Exception{
				public NameException(String name){
					super(name);
				}
			}

			class A{
				public int divide(int a, int b) throws NameException{
					int m = 0;
					if(b == 0)
						throw new NameException("除数不能为零！\n");
					else
						m = a / b;
					return m;
				}
			}

			public class Test4{
				public static void main(String[] args){
					A aa = new A();
					try{
						aa.divide(6, 0);
					}catch(Exception e){
						e.printStackTrace();
					}
				}
			}
		//运行结果：
			NameException: 除数不能为零！

				at A.divide(test1.java:11)
				at test1.main(test1.java:22)


		建议在调用f()方法时对可能抛出的A异常进行捕捉（void f() throws A{}），其只是未雨绸缪的作用，且就算出现异常也不一定会对A异常进行捕捉（若异常为RuntimeException子类异常则不进行处理）。

		所有的catch语句只能有一个被执行。所以要遵循先catch子类异常再catch父类异常的规则的话，把catch子类语句写在catch父类语句之前。两条catch语句之间不能有任何别的代码。

		常见异常类型和说明：
			Exception
				异常层次结构的父类
			ArithmeticException
				算术错误情形，如以零作除数
			ArrayIndexOutOfBoundsException
				数组下标越界
			NullPointerException
				尝试访问null对象成员
			ClassNotFoundException
				不能加载所需的类
			IllegalArgumentException
				方法接收到非法参数
			ClassCastException
				对象强制类型转换出错
			NumberFormatException
				数字格式转换异常，如把"abc"转换成数字
		
		throw和throws的使用：
			public void dothing(int a，int b) throws Exception1，Exception3 {
				try{
					 //......
				}catch(Exception1 e){
					throw e;
				}catch(Exception2 e){
					System.out.println("自己打印提示，不抛出");
				}

				if(a!=b)
					throw new  Exception3("自定义异常");
			}
		//代码块中try语句可能会产生3个异常，(Exception1,Exception2,Exception3)。
		//如果产生Exception1异常，则捕获之后再抛出，由该方法的调用者去处理。
		//如果产生Exception2异常，则该方法自己处理了（即打印出字符串：自己打印提示，不抛出）。所以该方法就不会再向外抛出Exception2异常了，void dothing() throws Exception1,Exception3 里面的Exception2也就不用写了（当然你写了也不会报错的），throws 就是声明可能抛出的错误，而Exception2 并未做出抛出操作。
		//而Exception3异常是该方法的某段逻辑出错，程序员自己做了处理，在该段逻辑错误的情况下抛出异常Exception3，则该方法的调用者也要处理此异常。

			class A extends Exception{}
			class B extends Exception{}
			class C extends Exception{}

			class M{
				void f() throws A,B{}
			}

			class N extends M{
				void f() throws A,B{}
			}

			class Test{
				public void k(M mm) throws A,B{
					mm.f();
				}
			}

			class Test5{
				public static void main(String[] args) throws A,B{
					M m = new M();
					N n = new N();
					
					System.out.println("this");

					Test aa = new Test();
					aa.k(m);
				}
			}
		//运行结果：
			this