2021-10-8 Java学习（异常）

一、（oop补充）内部类

1. 实例化内部类的方法

public class InnerClass {
    public static void main(String[] args) {
        //创建Dog实例  静态的成员内部类
        Person.Dog dog=new Person.Dog();
        //创建Bird实例 非静态的成员内部类
        //非静态要先有外部类的实例
        Person p=new Person();
        Person.Bird bird=p.new Bird();
    }
}

2. 内部类在开发中的应用场景

public class InnerClassTest1 {
    
    //开发中常用于返回一个实现了Comparable接口的类的对象
    public Comparable getComparable()
    {
        //局部内部类
        //创建一个实现了Comparable接口的类
        //why不放在外面。。。因为外面不用QAQ
        class  MyComparable implements Comparable
        {

            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        
        return new MyComparable();
        
    }
}

二、异常

1. 概述

异常事件可以分为2类

• Error
  Java虚拟机无法解决的严重问题。比如：JVM系统错误、资源耗尽等严重情况。比如栈溢出 Stack OverflowError
  一般不编写针对性的代码进行处理

• Exception
  可以使用针对性代码处理。
  eg.空指针访问、试图读取不存在的文件、网络连接中断…

捕获错误最理想的是在编译期间，但有的错误只有在运行时候才发生，
分为编译时异常（checked）和运行时异常（unchecked）

2. 异常处理机制try-catch-finally

一、异常处理-抓抛模型
1.抛
程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象，并将此对象抛出。
一旦抛出对象以后，其后的代码就不再执行

2.抓
抓住抛出来的对象？ 理解为异常处理的方式
① try-catch-finally
② throw

二、try-catch-finally的使用
try{
//可能出现异常的代码
}catch(异常类型1 变量名1)
{
//处理异常的方式1
}catch(异常类型1 变量名1)
{
//处理异常的方式1
}

finally
{一定会执行的代码}

注意点：

1. catch中的异常类型如果满足子父类关系，则要求子类声明一定在父类的上面
2. 常用的异常对象处理的方式

• String getMessage()
• printStackTrace()方法 e.printStackTrace

使用try-catch-finally处理编译时异常，编译时程序不报错，运行时依旧可能错误；
针对编译时异常，一定要考虑异常处理

finally使用

finally中声明的是一定会被执行的代码。

像数据库连接、输入输出流、网络编程socket等资源，JVM是不能自动回收的，需要自己手动进行资源的释放。此时的资源释放，就需要声明在finally中。

3. 异常处理机制throws+异常类型

eg

public class ExceptionTest {
    public static void main(String[] args) { //一直把错误往上抛，最终还是要处理掉的
        try {
            test1();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    
    public static void test2() throws IOException {
        test1();
    }
    

    public static void test1() throws IOException {
        File file=new File("hello.txt");
        FileInputStream fis=new FileInputStream(file);
        
        int data=fis.read();
        while(data!=-1)
        {
            System.out.println((char)data);
            data=fis.read();
        }
        fis.close();
        
    }
}

• try-catch-finally 真正将异常处理掉了
  throws的方式只是将异常抛给了方法调用者
• 父类中被重写的方法没有throws方式处理异常，则子类重写的方式也不能用throws，意味着如果子类重写方法中有异常，必须使用try-catch-finally来处理。

4. 手动抛出异常对象

异常对象的产生：1. 系统自动生成异常对象
2. 手动生成异常对象，并抛出throw

public class StudentTest {
    public static void main(String[] args) {
        try {
            Student s=new Student();
            s.register(-1001);
            System.out.println(s);
        } catch (Exception e) {
           // e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
}

class Student
{
    private int id;
    public void register(int id) throws Exception
    {
        if(id>0) this.id=id;
        else
        {
            //System.out.println("输入数据非法");
            //这里可以手动抛出异常对象
            //throw new RuntimeException("输入数据非法");
            throw new Exception("输入数据非法");//写了exception，则要考虑处理异常
        }

    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                '}';
    }
}

5. 自定义异常

如何自定义异常类?

1. 继承于现有的异常结构：RuntimeException、Exception
2. 提供全局常量serialVersionUID，可以理解为这个类的标识
3. 提供重载的构造器

public class MyException extends RuntimeException{
    static final long serialVersionUID = -7034897190745766939L;
    
    public MyException()
    {
        super();
    }
    public MyException(String message)
    {
        super(message);
    }
}

6. 补充：throw和throws的区别

throw：表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。
throws属于异常处理的一种方式，声明在方法的声明处。