Java核心API-高级流、异常处理机制

高级流

节点流与处理流

节点流

又称低级流

• 特点:直接链接程序与另一端的"管道"，是真实读写数据的流
• IO一定是建立在节点流的基础上进行的
• 文件流就是典型的节点流(低级流)

处理流

又称高级流

• 特点:不能独立存在，必须链接在其他流上
• 目的:当数据经过当前高级流时可以对数据进行某种加工操作，来简化我们的同等操作
• 实际开发中我们经常"串联"一组高级流最终到某个低级流上，使读写数据以流水线式的加工处理完成，这一操作也被称为使"流的链接"，流链接也是JAVA IO的精髓所在

流链接

开发中常连接一组高级流到某个低级流上，使得读写数据以流水线式的加工处理完成，这也被称为流的链接

对象流

java.io.ObjectInputStream和ObjectOutputStream

作用

• 对象输出流:将我们的java对象进行序列化
• 对象输入流:将java对象进行反序列化

序列化

将一个对象转换为一组可被传输或保存的字节，这组字节中除了包含对象本身的数据外，还会包含结构信息

序列化的意义

实际开发中，我们通常会将对象

• 写入磁盘，进行长久保存
• 在网络间两台计算机中的java间进行传输

无论是保存在磁盘中还是传输，都需要将对象转换为字节后才可以进行

对象输出流的序列化操作

void writeObject(Object obj)
将给定的对象转换为一组可保存或传输的字节然后通过其链接的流将字节写出

public class OOSDemo {
    public static void main(String[] args) throws IOException {
        String name = "张三";
        int age = 18;
        String gender = "男";
        String[] otherInfo = {"Java高手","嗓门大","黑","佳木斯口音"};
        Person person = new Person(name,age,gender,otherInfo);

        FileOutputStream fos = new FileOutputStream("person.obj");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
     
        oos.writeObject(person);
        System.out.println("写出完毕");
        oos.close();
    }
}

对象输入流的反序列化操作

Object readObject()
进行对象反序列化并返回，该方法会从当前对象输入流链接的流中读取若干字节并将其还原为对象
读取的字节必须是由ObjectOutputStream序列化一个对象所得到的字节

public class OISDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileInputStream fis = new FileInputStream("person.obj");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Person person = (Person)ois.readObject();
        System.out.println(person);
        ois.close();
    }
}

序列化要求

• 对象输出流要求写出的对象必须实现接口:java.io.Serializable
• 该接口没有任何抽象方法，但是只有实现了该接口的类的实例才能进行序列化与反序列化
• 写出的对象没有实现java.io.Serializable时会抛出异常java.io.NotSerializableException

异常处理机制

• java 中所有错误的超类为 Throwable，其下有两个子类：Error 和 Exception
• Error的子类描述的都是系统错误，比如虚拟机内存溢出等
• Exception的子类描述的都是程序错误，比如空指针，下表越界等
• 通常我们程序中处理的异常都是Exception

try-catch

try-catch是 Java 里处理异常的一种机制，程序在运行的时候可能会碰到各种各样的问题，像除以零、访问空对象的方法，这些问题就会导致异常，try-catch能让我们捕获这些异常，然后做一些处理，而不是让程序直接挂掉

语法结构

try {
    // 可能会抛出异常的代码
} catch (异常类型 异常对象名) {
    // 处理异常的代码
}

• try块：这里面放的是可能会出问题的代码。当程序执行到try块里的代码时，如果发生了异常，程序就会立刻停止try块里后续代码的执行，然后跳转到对应的catch块
• catch块：它跟在try块后面，用来捕获和处理try块里抛出的异常。catch后面括号里要写清楚要捕获的异常类型，然后给这个异常对象起个名字，在catch块里就可以用这个对象来获取异常的信息

public class TryCatchDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        /*
         * try{}语句块不能单独写，后面要么跟catch语句块要么跟finally语句块
         * 异常处理机制关注的是:明知道程序可能出现某种错误，但是该错误无法通过修改逻辑
         * 完全规避掉时，我们会使用异常处理机制，在出现该错误是提供一种补救办法。
         * 凡是能通过逻辑避免的错误都属于bug！就应当通过逻辑去避免!
         */
        try {
            // String str = null;
            // String str = "";
            String str = "a";
            /*
             * 若str=null的情况
             * 当JVM执行到下面代码时:str.length()会出现空指针，此时虚拟机就会根据该情况
             * 实例化一个对应的异常实例出来，即:空指针异常实例 NullPointerException实例
             * 然后将程序从一开始执行到报错这句话的过程设置到该异常实例中，此时该异常通过
             * 类型名字可以表达出现了什么错误，并将来可以通过输出错误信息来得知错误出现在那里
             * 虚拟机会将该异常抛出
             * 当某句代码抛出了一个异常时，JVM会做如下操作:
             * 1:检查报错这句话是否有被异常处理机制控制(有没有try-catch)
             * 如果有，则执行对应的catch操作，如果没有catch可以捕获该异常则视为没有
             * 异常处理动作
             * 2:如果没有异常处理，则异常会被抛出当当前代码所在的方法之外由调用当前方法的
             * 代码片段处理该异常
             */
            System.out.println(str.length());// 抛出空指针异常
            System.out.println(str.charAt(0));
            System.out.println(Integer.parseInt(str));
            /*
             * 当try中某句代码报错后，就会跳出try执行下面对应的catch块，执行后就会
             * 退出catch继续向后执行。因此try语句块中报错代码以下的内容都不会被执行
             */
            System.out.println("!!!!!!!!!!!!!!");
        // } catch(NullPointerException e) {
        //     // 这里实际开发中是写补救措施的，通常也会将异常信息输出便于debug
        //     System.out.println("出现了空指针，并解决了!");
        // } catch(StringIndexOutOfBoundsException e) {
        //     System.out.println("处理字符串下标越界问题!");
        // }
        /*
         * 当try语句块中可能出现的几种不同异常对应的处理办法相同时，可以采取合并
         * catch的做法，用同一个catch来捕获这几种可能出现的异常，而执行措施使用
         * 同一个。
         */
        } catch (NullPointerException | StringIndexOutOfBoundsException e) {
            System.out.println("处理空指针或下标越界!");
            /*
             * 当catch捕获某个超类型异常时，那么try语句块中出现它类型异常时都可以被这个
             * catch块捕获并处理。
             * 如果多个catch捕获的异常之间存在继承关系时，一定是子类异常在上超类异常在下
             */
        } catch (Exception e) {
            System.out.println("反正就是出了个错!");
        }
        System.out.println("程序结束了...");
    }
}

finally块

finally块是异常处理机制中的最后一块

• finally可以直接跟在try语句块之后
• finally可以跟在最后一个catch块之后
• fianlly下面不能再定义catch块

特点

只要程序执行到异常处理机制中(执行到try语句块中)，无论try中的代码是否出现异常，finally最终都必定执行

作用

通常用来执行释放资源这一类操作，例如IO操作完毕后的流关闭

在IO中的应用

public class FinallyDemo2 {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("./fos.dat");
            fos.write(1);
        } catch (IOException e) {
            System.out.println("出错了");
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

自动关闭特性

JDK7之后java推出了一个新特性：自动关闭特性可以更优雅的在异常处理机制中关闭IO

语法结构

try (
    // 声明并初始化IO对象
) {
    // IO操作
} catch (IOException e) {
    // catch各种IO异常
    ...
}

实例：

public class AutoCloseableDemo {
    public static void main(String[] args) {
        try (
            FileOutputStream fos = new FileOutputStream("fos.dat");
        ) {
            fos.write(1);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

throw关键字

throw用来对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常：

• 当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者
• 程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者

public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws Exception {
        if (age < 0 || age > 100) {
            // 使用 throw 对外抛出一个异常
            throw new Exception("年龄不合法!");
        }
        this.age = age;
    }
}

public class ThrowDemo {
    public static void main(String[] args) {
        Person p = new Person();
        try {
            p.setAge(10000); // 符合语法，但是不符合业务逻辑要求。
            System.out.println("此人年龄:" + p.getAge());
        } catch (Exception e) {
            System.out.println("出现异常：" + e.getMessage());
        }
    }
}

throws关键字

throws用来在声明方法时同时声明该方法可能抛出的异常，用于通知调用方添加处理该异常的手段

当一个方法中使用throw抛出一个非RuntimeException的异常时，就要在该方法上使用throws声明这个异常的抛出此时调用该方法的代码就必须处理这个异常，否则编译不通过

public class Person {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) throws Exception {
        if (age < 0 || age > 100) {
            // 使用 throw 对外抛出一个异常
            // throw new RuntimeException("年龄不合法!");
            // 除了 RuntimeException 之外，抛出什么异常就要在方法上声明 throws 什么异常
            throw new Exception("年龄不合法!");
        }
        this.age = age;
    }
}

当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通过， 处理手段有两种：

• 使用try-catch捕获并处理这个异常
• 在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。 具体选取那种取决于异常处理的责任问题

public class ThrowDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        try {
            Person p = new Person();
            p.setAge(100000); // 典型的符合语法，但是不符合业务逻辑要求
            System.out.println("此人年龄:" + p.getAge() + "岁");
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("程序结束了...");
    }
}

注意：永远不应当在main方法上使用throws!!

throws的重写规则

当一个子类重写超类含有throws声明异常抛出的方法时，针对throws的重写规则

• 允许不再抛出任何异常
• 允许仅抛出部分异常
• 允许抛出超类方法声明抛出异常的子类型异常
• 不允许抛出额外异常(超类方法没有声明的且不存在继承关系的)
• 不允许抛出超类方法抛出的异常的超类型异常

子类方法的几种重写分别解开注释就可以观察编译器是否允许该种重写方式

public class ThrowsDemo {
    public void dosome() throws IOException, AWTException {
    }
}

class SubClass extends ThrowsDemo {
    // 允许不再抛出任何异常
    // public void dosome() {
    // }

    // 允许仅抛出部分异常
    // public void dosome() throws IOException {
    // }

    // 允许抛出超类方法声明抛出异常的子类型异常
    // public void dosome() throws FileNotFoundException {
    // }

    // 不允许抛出额外异常(超类方法没有声明的且不存在继承关系的)
    // public void dosome() throws SQLException {
    // }

    // 不允许抛出超类方法抛出异常的超类型异常
    // public void dosome() throws Exception {
    // }
}

异常分类

Java异常可以分为可检测异常，非检测异常

• 可检测异常：可检测异常经编译器验证，对于声明抛出异常的任何方法，编译器将强制执行处理或声明规则，不捕捉这个异常，编译器就通不过，不允许编译
• 非检测异常：非检测异常不遵循处理或者声明规则。在产生此类异常时，不一定非要采取任何适当操作，编译器不会检查是否已经解决了这样一个异常
• RuntimeException 类属于非检测异常，因为普通JVM操作引起的运行时异常随时可能发生，此类异常一般是由特定操作引发。但这些操作在java应用程序中会频繁出现，因此它们不受编译器检查与处理或声明规则的限制。实际上RuntimeException及其子类型表达的都是因为程序漏洞(BUG),即:逻辑不严谨等原因导致的。这类异常都是通过修复代码可完全避免的异常，因此不应当由异常处理机制来处理

• 常见的RuntimeException子类

• IllegalArgumentException：抛出的异常表明向方法传递了一个不合法或不正确的参数
• NullPointerException：当应用程序试图在需要对象的地方使用 null 时，抛出该异常
• ArrayIndexOutOfBoundsException：当使用的数组下标超出数组允许范围时，抛出该异常
• ClassCastException：当试图将对象强制转换为不是实例的子类时，抛出该异常
• NumberFormatException：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常

异常API

Exception上有一些常用的方法

• void printStackTrace()
  用于输出当前异常的堆栈跟踪信息，便于程序员找到错误根源，分析错误原因制定B计划
• String getMessage()
  用于获取当前错误消息，多用于提示给用户或记录日志使用

public class ExceptionAPIDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了");
        try {
            String str = "abc";
            System.out.println(Integer.parseInt(str));
        } catch (NumberFormatException e) {
            // 输出错误堆栈跟踪信息便于程序员找到错误根源，分析错误原因制定B计划
            e.printStackTrace(); // 输出错误信息

            // 错误消息多用于提示给用户或记录日志使用
            String message = e.getMessage(); // 获取错误消息
            System.out.println(message);
        }
        System.out.println("程序结束了");
    }
}

自定义异常

自定义异常通常用来定义那些业务上的异常问题

定义自定义异常需要注意以下问题

• 异常的类名要做到见名知义
• 需要是Exception的子类
• 提供超类异常提供的所有种类构造器

public class IllegalAgeException extends Exception{
    public IllegalAgeException() {
    }

    public IllegalAgeException(String message) {
        super(message);
    }

    public IllegalAgeException(String message, Throwable cause) {
        super(message, cause);
    }

    public IllegalAgeException(Throwable cause) {
        super(cause);
    }

    public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}