千峰教育2218期2022.11.08

[TOC]

复习

方法权限修饰符：
	private 限制方法有且只能在类内使用
	public 类外可以按照语法规则使用
	【注意】
		使用 private 关键字限制所谓的角色权限访问是不可靠的
		private 修饰方法：
			1. 方法内容是原本的其他方法的一部分代码内容，只是因为需要复用，封装 private 方法内部使用
				例如： 指定 id 找出对应的学生所在下标位置
					成绩合法性判断，年龄合法性判断，性别合法性判断
			2. 方法内容执行属于类内其他方法【触发】操作，同时当前方法交由外部操作不合适/不合法
				例如： 数组扩容 grow 方法
				
静态成员变量，成员变量和局部变量的选择		

对比	成员变量	静态成员变量	局部变量
持久性	类对象生存周期	整个程序运行周期	大括号所在范围
共享性	不具备	针对于当前类和对应对象共享	不具备
独立性	对象的独立特征	不具备	具备，范围极其有限

扩容方法流程【背下来】
	1. 获取原数组容量 oldCapacity
	2. 计算得到新数组容量，新数组容量是原数组容量的大约 1.5 倍
		int newCapacity = oldCapacity + oldCapacity / 2
	3. 判断新数组容量是否满足最小容量需求 minCapacity 是当前方法参数，由目前的有效元素个数 + 添加数据个数决定
	4. 判断新数组容量是否超出 MAX_ARRAY_SIZE 最大允许数组容量范围
	5. 根据新数组容量创建对应的数据类型的新的数组
	6. 从原数组中移动复制数据到新数组
	7. 保存新数组地址
	
补充方法
	项目进程中发现有可以复用的代码，一定要非常严谨去封装

异常

1. 为什么要使用异常

在数组中找出用户指定下标位置对应的元素，数组为 int 类型
	public static int get(int[] arr, int index);
	if(index < 0 || index > arr.length - 1) {
	// 方法返回值为 int 类型，无论返回任何一个整数都有可能是正常数据
    // 问题：没有合理合适的方法告知用户当前操作存在的问题，返回值数据无法明确标识
    // 如果使用 System.exit(0) 不合适
	}

	Java 中提供异常机制，将错误信息封装到一个异常对象中，将异常对象抛出当前方法之外，方法外部可以获取到对应的异常信息，对当前异常进行处理或者分析
   	注意代码中不是为了写异常，而是通过异常的方式提供更多的错误信息，异常信息，代码运行的非正常状态信息给到程序反馈，方便更好的修改代码，调试代码。

2 异常类型结构和继承关系

class Throwable
	Java 中所有异常和错误的基类，规定了一些异常和错误的必要方法(信息获取，简要描述，控制器异常/错误原因展示)
------| class Exception extends Throwable
	Java 中的异常 可以处置
------| class Error extends Throwable
	Java 中的错误 只能避免 
	
Throwable 常用 API
	构造方法：
		Thowable();
			无参数构造方法，和 new 关键字联用，可以实例化 Throwable 对象，异常/错误信息为 message 
	成员方法：
		String toString();
			获取当前错误/异常的简要描述
		String getMessage();
			仅获取错误/异常信息
		void prinStackTrace();
			展示错误/异常方法调用流程，栈区错误信息流程，可以看到异常的前因后果

package com.qfedu.a_throwable;

public class Demo1 {
	public static void main(String[] args) {
		// 无参数构造方法，和 new 关键字联用，可以实例化 Throwable 对象，异常/错误信息为 null
		Throwable throwable = new Throwable();
		// 有参数构造方法，和 new 关键字联用，可以实例化 Throwable 对象，异常/错误信息为 message
		//
		Throwable t1 = new Throwable("SingleDog Expection");
		
		System.out.println(t1.toString());
		System.out.println(t1.getMessage());
		System.out.println();
		
		// t1.printStackTrace();
		test();
	}
	public static void test() {
		Throwable t = new Throwable("调用方法出现异常情况");
		t.printStackTrace();
	}

}

3. 异常和错误的区别

名称区别:
	所有的异常结尾都是 Exception
	所有的错误结尾都是 Error
	
Exception 可以处置
	抛出 社区医院无法处理骨折问题，建议去大医院，大医院处置
	捕获 伤口包扎社区医院直接处置
	
Error 无法处理

【注意】
	Java 代码中出现了异常/错误，代码停止执行，需要后续处理	

4. 异常处理方式

目前异常处理针对于当前的代码体验不佳，使用不明显
【重点】 异常对象存储有异常相关关系，异常内容出现的方法调用顺序，方法执行过程 ==> 存储到日志
后期课程对于异常进行等级分类
Info 信息 Warning 警告 Danger 危险
对于目前而言 Eclipse 当中处理异常都是 Ctrl + 1

4.1 捕获处理

格式：
	try {
		有可能出现异常的代码 例如：数组下标操作，引用数据类型指向 null
	} catch (异常类型 异常对象名，常用小写 e1) { 
		catch 小括号声明告知当前大括号处理的是哪一个异常类型
		针对于当前处理的处理方式，目前而言无法采用日志方式进行存储，只能展示。。
		
		
	} catch (异常类型 异常对象名，常用小写 e2) { 	
	    catch 小括号声明告知当前大括号处理的是哪一个异常类型
	}
	
	

package com.qfedu.a_throwable;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

/*
 *  try catch 异常捕获演示
 */
public class Demo3 {
	public static void main(String[] args) {
		/*
		 * 根据当前系统中的 D：/AQF/1.txt 路径对应的文件，创建对应文档的字节输入流对象、 Java 从文件中获取数据
		 * 该代码有隐患，例如文件不存在，路径不合法，没有 D 盘，没有操作权限 .... 以上隐患对于 Java 代码而言是通过异常方式来处理
		 * 
		 * Unhandled exception type FileNotFoundException 
		 * 尚未处理 FileNotFoundException 异常，尚未处理文件未找到异常 Ctrl + 1 快速修复选择 ==> Surround with try/catch 捕获处理
		 * 
		 * 代码提示尚未处理的异常是语法错误，提供报错，使用捕获处理之后，代码不再报错
		 * 
		 * 代码中的异常出现之后，通过捕获操作， JVM 认为已经没有异常存在，代码可以正常运行 在 try
		 * 大括号中，如果出现了异常，从异常位置开始，之后的代码不再执行
		 */
		try {
			FileInputStream fileInputStreaSm = new FileInputStream("D:/aaa/1.txt");
			System.out.println("~~~~~~~~~~~~~代码运行中~~~~~~~~~~~~~");
			} catch (FileNotFoundException e) {
				// 针对于 FileNotFoundException 异常处理的方式
				// 目前有且只能控制台展示异常的方法调用顺序，代码执行流程，错误信息z.....
			e.printStackTrace();
		}
		
		System.out.println("~~~~~~~代码继续执行中~~~~~");
		
	}

}

package com.qfedu.a_throwable;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
/*
 *  多异常情况处理
 *  
 *  try - catch 结构允许并行多个 catch 块，分门别类处理不同异常
 */
public class Demo4 {
	public static void main(String[] args) {
	
		try {
			/*
			 * Unhandled exception type FileNotFoundException
			 * 文件未找到异常
			 */
			/*
			 * Unhandled exception type InterruptedException
			 * 中断异常
			 */
			FileInputStream fileInputStream = new FileInputStream("G:/aaa/测试.txt");
			Thread.sleep(1000);
		} catch (FileNotFoundException e) {
			System.out.println("文件未找到异常");
		} catch (InterruptedException e) {
			System.out.println("中断异常");
		}
		
		
		try {
			/*
			 * Unhandled exception type FileNotFoundException
			 * 文件未找到异常
			 */
			/*
			 * Unhandled exception type InterruptedException
			 * 中断异常
			 */
			FileInputStream fileInputStream = new FileInputStream("G:/aaa/测试.txt");
			Thread.sleep(1000);
		} catch (FileNotFoundException | InterruptedException e) {
            // 允许两个异常并行！！！ 同时处理，适用于将同级别，同类型异常统一处理
			System.out.println("同级别异常：" + e.toString());
		}
	}
}

4.2 抛出处理

关键字
	throw
    	方法中判断条件无法满足代码正常运行的情况下，实例化异常对象，并且提供字符串信息作为异常信息，抛出异常对象，提示用户/代码运行存在问题
    例如：
    	数组下标越界，数据参数不符合，学生成绩不合法.....
	throws
		【方法声明】 位置告知方法的调用者，当前方法有哪些异常存在，提示用户/代码，需要对异常进行处理，注意异常的出现情况
	

package com.qfedu.a_throwable;

/*
 * 抛出异常演示
 */
public class Demo5 {
	public static void main(String[] args) {
		int[] arr = {1, 3, 5, 7, 9, 0, 5, 8};
		/*
		 * 调用一个带有异常抛出的方法
		 *  1. 继续抛出
		 *  2. 捕获处理
		 *   
		 */
		
		// 捕获处理
		try {
			test(arr, 15);
		} catch (ArrayIndexOutOfBoundsException e) {
			System.out.println("异常处理：" + e.toString());
		}
		test(arr, 20);
	}
	/*
	 * 文档注释中多出了一个 @throws 需要对抛出异常进行解释，异常类型，异常情况，异常说明
	 */
	/**
	 * 展示指定数组下标内容
	 * 
	 * @param arr  int 类型数组
	 * @param index 指定下标参数
	 * @throws ArrayIndexOutOfBoundsException  给予方法数组下标越界异常
	 */
	public static void test(int[] arr, int index) 
			throws ArrayIndexOutOfBoundsException{
		// 数组下标越界
		if (index < 0 || index > arr.length - 1) {
			/*
			 * 根据 if 条件判断情况，得出当前异常为数组下标越界异常
			 */
			throw new ArrayIndexOutOfBoundsException("用户提供数组下标越界");
		}
		System.out.println(arr[index]);
	}

}

package com.qfedu.a_throwable;
/*
 * 抛出异常特征语法
 */
public class Demo6 {
	public static void main(String[] args) {
			
	}
	
	public static void test(int[] arr, int index) 
			throws NullPointerException, ArrayIndexOutOfBoundsException{
		
		// 当前数组为 null，数组不存在，并且 null 不能操作
		/*
		 * if (null == arr || index < 0 || index > arr.length - 1) {
		 * 		System.out.println("用户提供数据不合法"); 
		 *		return;
		 *  }
		 */
		if (null == arr) {
			/*
			 *  NullPointerException 空指针异常
			 *  throw 抛出异常操作之后的代码都是 UNreachable code 无法触及的代码，无法执行的代码
			 *  方法从异常超出位置开始终止运行
			 *  
			 *  代码中如果需要抛出多个异常，每一个异常都需要独立的 if 判断条件
			 *  
			 */
			throw new NullPointerException("数组不能为 null");	
		}
		if (index < 0 || index > arr.length - 1) {
			// ArrayIndexOutOfBoundsException 数组下标越界异常
			throw new ArrayIndexOutOfBoundsException("数组下标越界异常");
		}
		System.out.println(arr[index]);
	}

}

5. 什么时候抛出，什么时候捕获

····

6. 运行时异常和编译时异常

目前而言最大的对比
运行时异常不会报错，编译时异常必须 Ctrl + 1 处理
如果发现异常报错 UNhandle exception XXX 证明当前异常为编译时异常，必须处理

运行时异常
	常见异常，不操心的异常，不仔细的异常，不认真的异常。
	例如：
		数组下标越界异常 ArrayIndexOutofBoundException
		空指针异常 NullPointerException
		~~~~~
	运行时异常基类是 RuntimeException extends Exception
	
编译时异常
	代码操作存在语法级别隐患，需要在代码书写过程中，对当前异常有对应的处理方式和处理方法。
	例如：
		文件中未找到/文件不存在异常 FileNotFoundException 
		中断异常 InterruptedException 
		SQL 数据库 SQL 语句异常 SQLException
		
		编译时异常的父类都是 Exception