IO第四天 字符流 异常处理机制

目录

字符流

转换流：

PW BR 高级流

异常处理机制

异常Throwable的分类

try{}catch{} 选中Ctrl +ALT+T

多个异常解决异常相同时  “或 |” 合并到一个异常处理

全部捕获  Exception e

Finally块

finally也会有报错 再次 try catch

自动关闭特性  try()中内容会在finally中调用close()关闭

---

对象流 OOS OIS 读写java对象

比如潜艇游戏里面 类里面保存数据 java对象和二进制（字节）之间转换

实体类 VO  alue Object 值对象

通常设计一个类用于保存一组数据时，这个类称为VO:Value Object 值对象
* 这种类通常要符合JAVA_BEAN的设计规范
* 1:属性私有化
* 2:提供公开的SET,GET方法
* 3:要提供公开的，无参构造器

 transient 序列化时忽略

serializable 可序列化的

当一个属性被关键字transient修饰后，那么当这个对象进行序列化时，这个
属性的值会被忽略。
忽略不必要的属性值可以达到对象序列化瘦身的目的。
这有助于减少磁盘开销或提高网络传输效率。

public class Person implements Serializable {
    private String name;
    private String gender;
    private int age;
    private transient String[] otherInfo;


    public Person(){}

    public Person(String name, String gender, int age, String[] otherInfo) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.otherInfo = otherInfo;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String[] getOtherInfo() {
        return otherInfo;
    }

    public void setOtherInfo(String[] otherInfo) {
        this.otherInfo = otherInfo;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                ", otherInfo=" + Arrays.toString(otherInfo) +
                '}';
    }
}

 

 

 对象序列化 Java对象转字节 writeObject(对象)

 

public class gOOSDemo {
    public static void main(String[] args) throws IOException {
        //将一个Person对象序列化后写入文件person.obj中
        String name = "刘桑";
        int age = 55;
        String gender = "男";
        String[] otherInfo = {"是一名老师","技术好","拍片儿也好","大家的启蒙老师"};

        Person p = new Person(name,gender,age,otherInfo);
        System.out.println(p);

        FileOutputStream fos = new FileOutputStream("person.obj");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        /*
            对象输出流在序列化对象时可能引发异常:
            java.io.NotSerializableException: io.Person
            原因:当序列化的对象没有实现接口:java.io.Serializable时出现上述异常
         */
        oos.writeObject(p);
        System.out.println("写出完毕!");
        oos.close();
    }
}

对象反序列化 读取文件字节转成Java对象 readObject()

字符流

JAVA IO将流按照读写单位划分为字节流与字符流

字节流的超类:java.io.InputStream和OutputStream

字符流的超类:java.io.Reader和Writer

字符流是以"char"为单位读写数据的，因此字符流【仅适合读写文本数据】 字符流都是高级流

转换流 ISR OSW： 字节与字符的转换工作

java.io.InputStreamReader和OutputStreamWriter 它们是常见的字符流的实现类，实际开发中我们不会直接操作这对流，但是在流连接 中它是重要的一环。 由于其他的高级字符流都只能连接在其他字符流上，是不能直接连接在字节流上使用的 因此转换流是唯一一个可以连接在字节流上的字符流，而其他的字符流可以连接在它上 因此转换流起到了"转换器"的作用，在流连接中就可以完成字符与字节流的串联工作了。

public class hOSWDemo {
    public static void main(String[] args) throws IOException {
        //向文件中写入文本数据
        FileOutputStream fos = new FileOutputStream("osw.txt");
        //创建转换流时通常会指定第二个参数来明确字符集，保证跨平台性
        OutputStreamWriter osw = new OutputStreamWriter(
                fos,
                StandardCharsets.UTF_8
        );
//        fos.write("我祈祷拥有一颗透明的心灵，和会流泪的眼睛。".getBytes(StandardCharsets.UTF_8));
//        fos.write("给我再去相信的勇气，越过谎言去拥抱你。".getBytes(StandardCharsets.UTF_8));
        osw.write("我祈祷拥有一颗透明的心灵，和会流泪的眼睛。");
        osw.write("给我再去相信的勇气，越过谎言去拥抱你。");
        System.out.println("写出完毕!");
        osw.close();//转换流内部有少量缓冲，因此用完及时关闭，避免数据没有写出。
    }
}

PW BR 高级流

异常处理机制

异常Throwable的分类

java.lang.Throwable是java中所有异常的顶级超类，下面有两个派生类：

java.lang.Exception:意外，例外，是可以恢复的错误

java.lang.Error:错误，是不可以恢复的错误，程序一旦出现Error就会中止

java的异常处理机制是针对Exception的，用于捕获并恢复程序的运行。
异常处理机制中最常见的两块:
try语句块和catch语句块。
try语句块不可以单独时候，后面要跟catch或finally语句块

try{}catch{} 选中Ctrl +ALT+T

    public static void main(String [] arags){
      System.out.println("程序开始了");//程序开始了
      String line=null;
      System.out.println(line.length());/空指针异常
             jvm自身运行的会杀掉这个错误 不再运行后面即闪退 
      System.out.println("程序开始了");


       报错后 有异常处理机制 可以接着往下走

jvm会new一个异常出来 传参一样传给catch      catch代码块里面写出现异常的补救措施

• 多个异常解决异常相同时  “或 |” 合并到一个异常处理

            String line="";
            System.out.println(line.length());
            System.out.println(line.charAt(1));//string8方法 根据索引显示字符
      }catch(NullPointerException e){//如同参数
          System.out.println("出现了空指针并且解决了");
        }
 
        catch(StringIndexOutOfBoundsException e){
        System.out.println("出现了字符串下标越界，解决了");
                                                    }

        //多个异常解决办法相同时 可以合并到一个catch中处理
        catch(NullPointerException | StringIndexOutOfBoundsException e){
            System.out.println("出现空指针或下标越界的同一处理");
        }

• 全部捕获  Exception e

package exceptiion;
public class TrycatchDemo {
    public static void main(String [] arags){

        System.out.println("程序开始了");//程序开始了
        try{
            String line="abc";
            System.out.println(line.length());
            System.out.println(line.charAt(1));//string8方法 根据索引显示字符
            System.out.println(Integer.parseInt(line));//字符串解析整数
            //try语句块中出错代码一下的内容不会被执行 直接到catch
            System.out.println(“！！！！！！！”);//这句话不会执行
        //全部捕获
        catch(Exception e){
            System.out.println("反正出了个错");
        }
        System.out.println("程序结束了");
    }
}

Finally块

 * finally块
 * finally是异常处理机制中的最后一块
 * 它可以直接跟在try语句块之后或最后一个catch块之后。
 * finally块的特点:
 * 只要程序执行到try语句块中，无论try中的代码是否出现异常，finally最后都必定
 * 执行。
 * 通常我们会将释放资源这类操作放在finally中确保执行。 

public class bFinallyDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        try {
//            String line = null;
            String line = "abc";
            System.out.println(line.length());
            return;//没有报错进行到return 最后的不会执行了
        } catch (Exception e) {
            System.out.println("出错了");
        }finally {
            System.out.println("finally中的代码执行了");
        }
        System.out.println("程序结束了...");
    }
}

finally也会有报错 再次 try catch

public class bFinallyDemo2 {
    public static void main(String[] args) {
        FileOutputStream fos = null;//局部变量使用前必须初始化
        //在try中初始化 finally中关流 作用域不对 所以在try外面初始化
        try {
            fos = new FileOutputStream("fos.dat");
            fos.write(1);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {//close也会出现异常 不能finally close无线循环
                if(fos!=null) {//如果地址没写对 空指针无处不在
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

自动关闭特性  try()中内容会在finally中调用close()关闭

 JDK7之后，java推出了一个新的特性:自动关闭特性

 在try()中定义的内容最终都会被编译器改为在finally中调用close()关闭

只有实现了AutoCloseable接口的类才可以在这里定义

public class cAutoCloseableDemo {
    public static void main(String[] args) {
        //该特性是编译器认可的，代码编译后会变成FinallyDemo2的样子
        try(
//          在try()中定义的内容最终都会被编译器改为在finally中调用close()关闭
            FileOutputStream fos = new FileOutputStream("fos.dat");

            //只有实现了AutoCloseable接口的类才可以在这里定义
//            String str = "abc";//编译不通过
        ){

            fos.write(1);
        } catch (IOException e) {
            e.printStackTrace();

        }
    }
}