1.知识点：

1.泛型类
2.异常处理

2.知识点的运用：

1.在实际运用中，用到泛型的地方并不多，所以在这里只介绍泛型类：

泛型类的一般格式：

//泛型标识：可以随便写任意标识号，标识指定的泛型的类型
class 类名称 <泛型标识>{
//泛型变量
  private 泛型标识  a; 
//泛型方法
public 返回值  函数名 （参数类型 形参名，泛型标识 形参名）{
        //函数体
    }  
}

例：

public class MyClass {
    public static void main(String[] args){
        GenericTest<Integer> genericTest = new GenericTest<>();
        genericTest.test(10,10);
    }
}
class GenericTest<T>{
    int age;
    T a1;
    T a2;
    public void test(T a1, T a2){
        this.a1 = a1;
        this.a2 = a2;
        System.out.println(a1);
        System.out.println(a1.equals(a2));
    }
}

2.异常处理：

• 异常类及其子类的框架：

  
  image.png

• 异常的定义：异常是程序运行过程过程出现的错误，在Java中用类来描述，用对象来表示具体的异常。Java将其区分为Error与Exception，Error是程序无力处理的错误，Exception是程序可以处理的错误。异常处理是为了程序的健壮性。
• 异常处理关键字：
  1. try语句 ：用大括号{}指定了一段代码，该段代码可能会抛弃一个或多个例外。
  2. catch语句：catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包含对象的处理，其中可以调用对象的方法。
  3. finally语句：try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语句可以指定一块代码。无论什么情况，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作，如关闭、打开文件等。
  4. throws语句：throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。
  5. throw语句：throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句不执行。
• 异常链：(Throwable类中的常用方法)

1. getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。
2. getMessage()：返回异常的消息信息。
3. printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的异常链顾名思义就是将异常
   发生的原因一个传一个串起来，即把底层的异常信息传给上层，这样逐层抛出。

3 . 异常处理的实际运用：

• 常规模式：

        FileReader reader = null;
        try {
            System.out.println("Hello");
            reader = new FileReader("re");
            
        }catch (FileNotFoundException e) {
            e.printStackTrace();
        }finally {
            try{
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

• try后面加括号：

        //try括号中只能添加可以关闭的对象
        //实现了Closeable接口的对象，如果出现异常，系统自己关闭这个资源
        try (FileReader reader1 = new FileReader("rewrwr")){
            //使用对象
        }catch (IOException e){
            e.printStackTrace();
        }

• 写一个方法，在方法中抛出异常：

        try {
            TException.test();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }

        try {
            TException.test3();
        }catch (ykException e){
            System.out.println(e.getMessage());
        }
//自定义类：
class TException{
    public static void test() throws  FileNotFoundException,NullPointerException{
        FileReader reader = new FileReader("fsf");

    }
    //三：
    public static void test2()throws IllegalAccessException {
        if (2 > 1){
            throw new IllegalAccessException();
        }
    }
}

• 自定义异常：

        try {
            TException.test3();
        }catch (ykException e){
            System.out.println(e.getMessage());
        }
class TException{
    public static void test3() throws ykException {
        StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
        StackTraceElement e = stackTrace[2];
        String detail = e.getFileName()+"->"+e.getMethodName()+"->"+e.getLineNumber();
        throw new ykException( "自己的异常类：无所作为"+detail);
    }
}
//自定义异常
class ykException extends java.lang.Exception{
    //提供一个无惨构造方法
    public ykException (){}
    //提供一个有惨构造方法
    public ykException(String desc){
        super(desc);
    }
}

4.部分总结：

• 异常处理格式：

try{
//执行的代码
//一旦出现异常，系统自动为我们创建异常类，并输出
 }catch（NullPointerException  e){
//如果需要自己处理异常，就catch
 }catch（IOExcepton e){

 //如果有多个异常，catch的顺序是从小到大
}catch(Exception e){

}finally{
 //资源回收：网络连接 数据库连接 文件流 I/O流
// 不关也没有异常，finally都会被执行
}

• 从出现异常开始，后面的代码将不会执行，改为执行catch的代码 ，所以不要抓太多的异常
• 第二种异常处理方式：使用throws，交给外部处理