JAVASE02-Unit08： 文本数据IO操作 、 异常处理

　　　　Unit08： 文本数据IO操作 、 异常处理　　　　

* java.io.ObjectOutputStream
 * 对象输出流，作用是进行对象序列化

package day08;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * java.io.ObjectOutputStream
 * 对象输出流，作用是进行对象序列化
 * 对象序列化:将一个java中的对象转换为一组字节的
 *           过程
 * 对象流是高级流。
 * @author adminitartor
 *
 */
public class ObjectOutputStream_WriteObject {
    public static void main(String[] args) throws Exception {
        Person person = new Person();
        person.setName("苍老师");
        person.setAge(18);
        person.setGender("女");

        List<String> otherInfo
            = new ArrayList<String>();
        otherInfo.add("是一名演员");
        otherInfo.add("爱好是写大字");
        otherInfo.add("促进中日文化交流");
        otherInfo.add("是广大男性同胞的启蒙老师");
        person.setOtherInfo(otherInfo);

        System.out.println(person);

        /*
         * 将Person对象写入文件
         */
        FileOutputStream fos
            = new FileOutputStream("person.obj");

        ObjectOutputStream oos
            = new ObjectOutputStream(fos);
        /*
         * void writeObject(Object obj)
         * 将给定的对象转换为一组字节后写出
         *
         * 若想将一个对象序列化，要求该对象所属的
         * 类必须实现可序列化接口，否则会抛出异常。
         */
        oos.writeObject(person);
        System.out.println("对象写出完毕!");

        oos.close();

    }
}

ObjectOutputStream_WriteObject.java

* 该类用于测试对象流的读写对象操作

package day08;

import java.io.Serializable;
import java.util.List;

/**
 * 该类用于测试对象流的读写对象操作
 * @author adminitartor
 *
 */
public class Person implements Serializable{
    private String name;
    private int age;
    private String gender;
    /*
     * transient关键字
     * 被该关键字修饰的属性在进行对象序列化的时候
     * 值会被忽略。将无需保存的属性用该关键字修饰
     * 可以达到对象序列化时的"瘦身"工作,减少资源
     * 开销
     * 除此之外，该关键字没有其他任何作用。
     */
    private transient List<String> otherInfo;

    Person(){

    }

    public Person(String name, int age, String gender, List<String> otherInfo) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.otherInfo = otherInfo;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    /**
     * 通常一个方法内部抛出什么异常，方法上就要
     * 使用throws声明该异常的抛出，以通知调用者
     * 这里可能出现什么问题，要求其处理。
     * 只有一类异常抛出时可以不声明，
     * 就是RuntimeException及其子类异常
     * @param age
     * @throws Exception
     */
    public void setAge(int age) throws Exception{
        if(age<0||age>100){
            throw new Exception("年龄不合法!");
        }
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public List<String> getOtherInfo() {
        return otherInfo;
    }
    public void setOtherInfo(List<String> otherInfo) {
        this.otherInfo = otherInfo;
    }

    @Override
    public String toString() {
        return name+","+age+","+gender+","+
               otherInfo;
    }
}

Person.java

* java.io.ObjectInputStream
 * 对象输入流，用于进行:对象返序列化

package day08;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

/**
 * java.io.ObjectInputStream
 * 对象输入流，用于进行:对象返序列化
 *
 * @author adminitartor
 *
 */
public class ObjectInputStream_ReadObject {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /*
         * 将person.obj文件中的对象读取出来
         */
        FileInputStream fis
            = new FileInputStream("person.obj");

        ObjectInputStream ois
            = new ObjectInputStream(fis);

        Person person = (Person)ois.readObject();
        System.out.println("读取对象完毕!");
        System.out.println(person);

        ois.close();
    }
}

ObjectInputStream_ReadObject.java

* java.io.OutputStreamWriter
 * 该流也叫做转换流，是字符输出流的一个常用实现类。

package day08;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

/**
 * Writer，Reader
 * 这俩个流是所有字符流的父类
 * 字符流:以字符为单位读写数据。
 *
 * java.io.OutputStreamWriter
 * 该流也叫做转换流，是字符输出流的一个常用
 * 实现类。
 * @author adminitartor
 *
 */
public class OutputStreamWriter_Write {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos
            = new FileOutputStream("osw.txt");

        OutputStreamWriter osw
            = new OutputStreamWriter(fos,"UTF-8");

        osw.write("我爱北京*");
        osw.write("*上太阳升");

        System.out.println("写出完毕!");
        osw.close();
    }
}

OutputStreamWriter_Write.java

* java.io.InputStreamReader
 * 转换流

package day08;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * java.io.InputStreamReader
 * 转换流
 * @author adminitartor
 *
 */
public class InputStreamReader_Read {
    public static void main(String[] args) throws IOException {
        FileInputStream fis
            = new FileInputStream("osw.txt");

        InputStreamReader isr
            = new InputStreamReader(fis,"UTF-8");

        int d = -1;
        while((d = isr.read())!=-1){
            System.out.print((char)d);
        }

        isr.close();
    }
}

InputStreamReader_Read.java

* java.io.PrintWriter
 * 常用的缓冲字符输出流
 * 特点是:可以按行写出字符串，并且具有自动行刷新

package day08;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * java.io.PrintWriter
 * 常用的缓冲字符输出流
 * 特点是:可以按行写出字符串，并且具有自动行刷新
 * PrintWriter内部嵌套java.io.BufferedWriter
 * 所以缓冲功能是靠内部的BW实现的。
 * @author adminitartor
 *
 */
public class PrintWriter_Println {
    public static void main(String[] args) throws IOException {
        /*
         * PrintWriter提供了多种构造方法
         * 方便快速创建。
         * 其中有直接针对文件写操作的构造方法:
         * PrintWriter(String path)
         * PrintWriter(File file)
         */
        PrintWriter pw
            = new PrintWriter("pw.txt","utf-8");

        pw.println("锄禾日当午");
        pw.println("清明上河图");

        System.out.println("写出完毕!");
        pw.close();
    }
}

PrintWriter_Println.java

* 当使用PrintWriter处理其他流的时候，
 * 可以指定自动行刷新，即:每当使用println方法
 * 写出内容后，会自动flush

package day08;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

/**
 * 当使用PrintWriter处理其他流的时候，
 * 可以指定自动行刷新，即:每当使用println方法
 * 写出内容后，会自动flush
 * @author adminitartor
 *
 */
public class PrintWriter_AutoFlush {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos
            = new FileOutputStream("pw1.txt");
        //若需要按照指定字符集，需要加上转换流
        OutputStreamWriter osw
            = new OutputStreamWriter(fos,"UTF-8");
        /*
         * 当创建PrintWriter时第一个参数为流，
         * 那么就支持传入第二个参数，该参数为
         * boolean值，表示是否自动行刷新。当
         * 该值为true则具备自动行刷新
         */
        PrintWriter pw
            = new PrintWriter(osw,true);
        /*
         * 具备自动行刷新的PW在调用println方法
         * 写出一行字符串后会自动flush。
         * 注意，调用print方法不会自动刷新
         */
        pw.println("随便吧");
        pw.println("我已经不知道该写啥了");

        System.out.println("写出完毕!");
        pw.close();
    }
}

PrintWriter_AutoFlush.java

* java.io.BufferedReader
 * 缓冲字符输入流，特点:使用它可以按行读取字符串

package day08;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * java.io.BufferedReader
 * 缓冲字符输入流，特点:使用它可以按行读取字符串
 * @author adminitartor
 *
 */
public class BufferedReader_ReadLine {
    public static void main(String[] args) throws IOException {
        FileInputStream fis
            = new FileInputStream(
                "src"+File.separator+
                "day08"+File.separator+
                "BufferedReader_ReadLine.java"
            );

        InputStreamReader isr
            = new InputStreamReader(fis);

        BufferedReader br
            = new BufferedReader(isr);

        /*
         * String readLine()
         * 按行读取字符串
         * 连续读取若干字符，直到遇见换行符为止，
         * 然后将换行符之前的内容以一个字符串返回
         * 但是返回的字符串中不含有最后的换行符
         * 当返回值为NULL时，表示读取到末尾了
         */
        String line = null;
        while( (line = br.readLine()) != null  ){
            System.out.println(line);
        }

        br.close();
    }
}

BufferedReader_ReadLine.java

* 异常捕获机制中的try-catch

package day08;
/**
 * 异常捕获机制中的try-catch
 * @author adminitartor
 *
 */
public class Exception_Try_Catch {
    public static void main(String[] args) {
        System.out.println("程序开始了");

        try{

            String str = "a";
            System.out.println(str.length());

            System.out.println(str.charAt(0));

            System.out.println(Integer.parseInt(str));

            //try中出错代码之下的代码都不会被执行
            System.out.println("!!!!!!!!");

        }catch(NullPointerException e){
            System.out.println("出现了空指针!");

        }catch(StringIndexOutOfBoundsException e){
            System.out.println("字符串下标越界了!");
        /*
         * 应当有一个好习惯，在最后一个catch中捕获
         * Exception.
         * 并且多个catch捕获异常时，子类异常在上先
         * 捕获，而父类异常在下后捕获。
         */
        }catch(Exception e){
            System.out.println("反正就是出了个错!");
        }

        System.out.println("程序结束了");
    }
}

Exception_Try_Catch.java

* 异常捕获机制中的finally块

package day08;
/**
 * 异常捕获机制中的finally块
 * finally块只能定义在异常捕获机制的最后
 * finally块可以保证其中的代码一定被执行，无论
 * try块中的代码是否抛出异常，甚至return。
 *
 * 通常会将诸如释放资源等一类的代码定义在finally中
 * 比如:使用流后的close工作可以放在finally中确保
 *      一定可以关闭流。
 * @author adminitartor
 *
 */
public class Exception_Finally {
    public static void main(String[] args) {
        System.out.println("程序开始了");

        try {
            String str = "";
            System.out.println(str.length());
            return;
        } catch (Exception e) {
            System.out.println("出错了");
        } finally{
            System.out.println("finally代码执行了!");
        }            

        System.out.println("程序结束了");
    }
}

Exception_Finally.java

* finally在流处理中的应用

package day08;

import java.io.PrintWriter;

/**
 * finally在流处理中的应用
 * @author adminitartor
 *
 */
public class Exception_Finally2 {
    public static void main(String[] args) {
        PrintWriter pw = null;
        try {
            pw = new PrintWriter("pw.txt");
            pw.println("hello");
        } catch (Exception e) {
            System.out.println("出错了!");
        } finally{
            if(pw != null){
                pw.close();
            }
        }
    }
}

Exception_Finally2.java

* throw关键字

package day08;
/**
 * throw关键字
 * 用于将一个异常抛出
 * 通常两种情况下会主动抛出异常:
 * 1:遇到满足语法要求，但是不满足业务逻辑要求时，
 *   可以当作异常对待抛出，通知调用者这是非法操作。
 * 2:当遇到了一个异常，但是当前代码不应当解决该
 *   异常时，可以将其抛出交给调用者解决。
 * @author adminitartor
 *
 */
public class Exception_Throw {
    public static void main(String[] args) {
        Person p = new Person();
        try{
            /*
             * 当调用一个含有throws声明异常抛出
             * 的方法时，编译器要求必须有处理该
             * 异常的手段，有两种:
             * 1:使用try-catch捕获
             * 2:在当前方法上继续使用throws声明
             *   这个异常的抛出
             * 具体用哪个取决于异常应该归谁处理。
             */
            p.setAge(10);
        }catch(Exception e){
            System.out.println("出错了!");
        }
        System.out.println(p.getAge());
    }
}

Exception_Throw.java

* 子类在重写父类含有throws声明异常抛出的方法时
 * 子类该方法中throws的重写准则

package day08;

import java.awt.AWTException;
import java.io.IOException;
import java.sql.SQLException;
/**
 * 子类在重写父类含有throws声明异常抛出的方法时
 * 子类该方法中throws的重写准则
 * @author adminitartor
 *
 */
public class Exception_Override {
    public void dosome()
        throws IOException,AWTException{

    }
}

class Son extends Exception_Override{
    /**
     * 抛出部分异常
     */
//    public void dosome() throws IOException{
//
//    }
    /**
     * 不再抛出任何异常
     */
//    public void dosome(){
//
//    }

    /**
     * 可以抛出父类方法抛出异常的子类型异常
     */
//    public void dosome() throws FileNotFoundException{
//
//    }

    /**
     * 不可以抛出父类方法抛出异常的父类型异常
     */
//    public void dosome() throws Exception{
//
//    }

    /**
     * 不可以抛出额外异常
     */
//    public void dosome() throws SQLException{
//
//    }
}

Exception_Override.java

* Exception中的常用方法

package day08;
/**
 * Exception中的常用方法
 * @author adminitartor
 *
 */
public class Exception_API {
    public static void main(String[] args) {
        System.out.println("程序开始了");
        try {
            String str = "abc";
            System.out.println(Integer.parseInt(str));
        } catch (Exception e) {
            //输出错误堆栈信息
            e.printStackTrace();
            //获取异常消息
            String message = e.getMessage();
            System.out.println(message);
        }
        System.out.println("程序结束了");
    }
}

Exception_API.java

异常的使用：

IllegalAgeException文件，是生成的，Source → Generate Constructors from Superclass ;

作用：(年龄不合法异常,当指定的年龄范围在0-100以外的数字时会抛出该异常)

Person文件：在set Age 方法这里使用了 IllegalAgeException 自己定义的这个异常；

Exception_Throw文件：使用set Age方法时候，要进行异常处理，并且把鼠标放在

“catch (IllegalAgeException e)”上面，还会有异常提示；

package day08;

import java.io.Serializable;
import java.util.List;

/**
 * 该类用于测试对象流的读写对象操作
 * @author adminitartor
 *
 */
public class Person implements Serializable{
    private String name;
    private int age;
    private String gender;
    /*
     * transient关键字
     * 被该关键字修饰的属性在进行对象序列化的时候
     * 值会被忽略。将无需保存的属性用该关键字修饰
     * 可以达到对象序列化时的"瘦身"工作,减少资源
     * 开销
     * 除此之外，该关键字没有其他任何作用。
     */
    private transient List<String> otherInfo;

    Person(){

    }

    public Person(String name, int age, String gender, List<String> otherInfo) {
        super();
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.otherInfo = otherInfo;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    /**
     * 通常一个方法内部抛出什么异常，方法上就要
     * 使用throws声明该异常的抛出，以通知调用者
     * 这里可能出现什么问题，要求其处理。
     * 只有一类异常抛出时可以不声明，
     * 就是RuntimeException及其子类异常
     * @param age
     * @throws Exception
     */
    public void setAge(int age) throws IllegalAgeException{
        if(age<0||age>100){
            throw new IllegalAgeException("年龄不合法!");
        }
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public List<String> getOtherInfo() {
        return otherInfo;
    }
    public void setOtherInfo(List<String> otherInfo) {
        this.otherInfo = otherInfo;
    }

    @Override
    public String toString() {
        return name+","+age+","+gender+","+
               otherInfo;
    }
}

Person.java

package day08;
/**
 * 年龄不合法异常
 * 当指定的年龄范围在0-100以外的数字时会抛出
 * 该异常
 * @author adminitartor
 *
 */
public class IllegalAgeException extends Exception{

    public IllegalAgeException() {
        super();
        // TODO Auto-generated constructor stub
    }

    public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
        // TODO Auto-generated constructor stub
    }

    public IllegalAgeException(String message, Throwable cause) {
        super(message, cause);
        // TODO Auto-generated constructor stub
    }

    public IllegalAgeException(String message) {
        super(message);
        // TODO Auto-generated constructor stub
    }

    public IllegalAgeException(Throwable cause) {
        super(cause);
        // TODO Auto-generated constructor stub
    }

}

IllegalAgeException.java

package day08;
/**
 * throw关键字
 * 用于将一个异常抛出
 * 通常两种情况下会主动抛出异常:
 * 1:遇到满足语法要求，但是不满足业务逻辑要求时，
 *   可以当作异常对待抛出，通知调用者这是非法操作。
 * 2:当遇到了一个异常，但是当前代码不应当解决该
 *   异常时，可以将其抛出交给调用者解决。
 * @author adminitartor
 *
 */
public class Exception_Throw {
    public static void main(String[] args) {
        Person p = new Person();

            /*
             * 当调用一个含有throws声明异常抛出
             * 的方法时，编译器要求必须有处理该
             * 异常的手段，有两种:
             * 1:使用try-catch捕获
             * 2:在当前方法上继续使用throws声明
             *   这个异常的抛出
             * 具体用哪个取决于异常应该归谁处理。
             */
            try {
                p.setAge(1000);
            } catch (IllegalAgeException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        System.out.println(p.getAge());
    }
}

Exception_Throw.java