Java 异常处理

异常处理的好处

   通过学习异常,从而处理异常,让项目在运行的过程中不会出现JVM非正常的停止,保证JVM可以继续运行

		System.out.println("开始");
		try {
			System.out.println(1);
			System.out.println(2);

			System.out.println(1/0);

			System.out.println(3);
		} catch (Exception e) {
			System.out.println("出现问题的解决方案代码");
		}
		System.out.println("结束");

Throwable类

   类的特点
       Throwable 类是 Java 语言中所有错误(XxxError)或异常(XxxException)的父类。
       错误(Error)和异常(Exception)的区别
           Error:无法通过程序员的后续代码进行解决,只能进行事先避免
           Exception:程序中出现了不正常的情况,最终导致JVM非正常停止.可以通过程序员的代码进行补救
   类的位置
       java.lang
   类的构造器
       public Throwable()
           构造一个将 null 作为其详细消息的新 throwable。
       public Throwable(String message)
           构造带指定详细消息的新 throwable。
   类的方法
       public void printStackTrace()
           将此 throwable 及其追踪输出至标准错误流。
       public String getMessage()
           返回此 throwable 的详细消息字符串。

		System.out.println("开始");
		//创建Throwable对象
		Throwable t = new Throwable("自定义Throwable对象");

		//打印Throwable对象的详细信息
		t.printStackTrace();
		//获取异常的原因
		System.out.println(t.getMessage());

		System.out.println("结束");

Exception类

   类的特点
       Exception 类及其子类是 Throwable 的各种异常情况的分类
   类的位置
       java.lang
   类的构造器
       public Exception()
           构造详细消息为 null 的新异常
       public Exception(String message)
           构造带指定详细消息的新异常。
   类的方法
       详见Throwable类的常用方法

Exception类的分类:
   运行时异常:
       位置:RuntimeException及其子类
       特点:代码没有任何语法格式错误,但在运行期间出现了不正常情况
   编译时异常
       位置:Exception类及其子类(RuntimeException及其子类除外)
       特点:代码没有任何语法格式错误,但在编译期间出现了编译报错

异常处理

   异常处理的关键字:
       throws,try,catch,finally
   异常处理的前提条件的关键字
       throw
   分类:
       异常声明(将异常信息在方法进行标记,交给调用者进行解决)
           关键字:throws
       异常捕获(将异常信息自己尝试处理)
           关键字:try,catch,finally
   注意事项:
       在程序中无论"运行时异常"还是"编译时异常"都必须解决
       运行时异常:
           可以程序员手动解决,也可以程序员不解决交给JVM进行解决
               手动解决:
                   异常声明
                   异常捕获
               自动解决:
                   交给JVM进行解决(1.调用该异常对象printStackTrace() 2.终止JVM)
       编译时异常:
           必须由程序员手动解决
               异常声明
               异常捕获

throw关键字

   含义:
       抛出异常对象(让JVM识别到该异常对象)
   格式:
       throw new 异常类名(实参);

			public static void method (int num) {
				if (num == 1) {
					//throw new IOException("自定义IO异常对象");
				}
			}

异常声明

   原因:
       在方法内部不进行解决,在方法声明上进行异常标记,交给调用解决
   格式:
       修饰符 返回类型 方法名 () throws 异常类名1,异常类名2,......,异常类名n {

       }

		public static void main(String[] args) throws IOException{
			method(1);
		}
	
		public static void method (int num) throws IOException {
			if (num == 1) {
				throw new IOException("自定义IO异常对象");
			}
		}

异常声明的注意事项:继承
   声明的异常类存在子父类继承关系:
       1.当方法中存在多个异常时,进行异常声明的时候无需考虑异常声明顺序
       2.当方法中存在多个异常时,进行异常声明的时候可以进行简化,声明异常父类即可
   异常所在的类存在子父类继承关系
       如果在父类被重写的方法中
           子类重写父类含有异常的方法时,无需考虑父类该方法的异常情况
       如果在子类重写后的方法中
           必须通过异常的捕获进行处理

Exception异常处理:异常捕获

   原理:
       在可能出现异常的代码中捕获不同的异常从而给出出现不同异常时的解决方案,从而保障程序可以继续运行
   格式:
       try {
           可能出现异常的代码
       } catch (异常类型 对象名) {
           出现该类型异常的解决方案
       }

		try {
			if (a == 1) {
				throw new IOException("自定义IO异常对象");
			}
		} catch (IOException e) {
			System.out.println("IO异常的解决方案");
		}

异常捕获的注意事项:继承

   代码中的异常类存在子父类继承关系
       如果存在子父类继承关系的异常类解决方案不同,可以分别捕获,分别处理
       如果存在子父类继承关系的异常类解决方案不同,有依赖关系,可以一次捕获,分别处理
           注意:分别处理时需要将异常子类的处理方案写在最上面
       如果存在子父类继承关系的异常类解决方案相同,一次捕获,一次处理
   异常类所在的类存在子父类继承关系
       异常类在父类被重写的方法中,子类重写该方法时无需关注被重写方法的异常
       异常类在子类重写后的方法中,子类重写该方法时只能使用异常的捕获处理该异常信息

finally关键字

   含义:
       异常捕获处理时必须执行的代码
   格式:
       try {
           可能出现异常的代码
       } catch(异常类型 对象名) {
           解决方案
       } finally {
           必须执行的代码
       }
       
finally关键字的注意事项:
   在try,catch,finally里面尽量避免使用return

//前
		Scanner sc = null;

		try {
			sc = new Scanner(System.in);
			System.out.println("请键盘输入一个整数:");
			int num = sc.nextInt();

			System.out.println("num = " + num);

			System.out.println("关闭资源");
			sc.close();
		} catch (Exception e) {
			System.out.println("解决方案");

			if (sc != null) {
				System.out.println("关闭资源");
				sc.close();
			}
		}
// 后
		Scanner sc = null;

		try {
			sc = new Scanner(System.in);
			System.out.println("请键盘输入一个整数:");
			int num = sc.nextInt();

			System.out.println("num = " + num);
		} catch (Exception e) {
			System.out.println("解决方案");
		} finally {
			if (sc != null) {
				System.out.println("关闭资源");
				sc.close();
			}
		}

自定义异常

   自定义运行时异常
   自定义编译时异常

自定义运行时异常步骤:
   1.自定义运行时异常类,并让这个类继承RuntimeException
   2.根据RuntimeException和需求生成合适的构造器(至少2个,无参和String参数)

自定义编译时异常步骤:
   1.自定义编译时异常类,并让这个类继承Exception
   2.根据Exception和需求生成合适的构造器(至少2个,无参和String参数)