对象IO流

对象IO流
1.ObjectInputStream:反序列化（把字节序列转化为对象）
2.ObjectOutStream：序列化（把java对象转化为字节序列）

package file;

import java.io.Serializable;

/*
1.Serializable是一个标识型接口,序列化接口
2.serialVersionUID
实现Serializable接口时，最好加serialVersionUID(序列化版本ID)
如果不加，主要类重新编译，原来序列化的数据就无法重新序列化
如果加了，就算类重新编译，serialVersionUID值发生变化，原来序列化的数据仍然可以反序列化
3.transient
如果某些属性不想要序列化,如：计算的值或者多变的值，加transient,瞬时的

4.一个类的静态变量是不会序列化的
静态变量是对象共享的，不是某个对象特有的信息

*/

public class Employee implements Serializable {
    private static final long serialVersionUID=1L;
    private int id;
    private String name;
    private transient double salary;
    private static String company="shanxi";
    
    
    
    public Employee(int id, String name, double salary) {
        super();
        this.id = id;
        this.name = name;
        this.salary = salary;
    }
    
    
    public Employee() {
        super();
    }
    

    


    @Override
    public String toString() {
        return "Employee [id=" + id + ", name=" + name + ", salary=" + salary + ", company="+company+ "]";
    }


    public void test() {
        System.out.println("serialVersionUID");
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public static String getCompany() {
        return company;
    }
    public static void setCompany(String company) {
        Employee.company = company;
    }
    
    
    

}

package file;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;



/*
 * 
java.io.Externalizable接口：程序员决定如何序列化和反序列化
writeExternal(ObjectOutput out)
readExternal(ObjectInput in)

*/

public class Student implements Externalizable {
    private static String school;
    private int id;
    private String name;
    private transient int age;
    public Student(int id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
    }
    public static String getSchool() {
        return school;
    }
    public static void setSchool(String school) {
        Student.school = school;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    //程序员决定如何属反序列化
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        school=in.readUTF();
        id=in.readInt();
        name=in.readUTF();
        age=in.readInt();
        
    }
    
    //程序员决定如何序列化
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(school);
        out.writeInt(id);
        out.writeUTF(name);
        out.writeInt(age);
    }
}

package file;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import org.junit.Test;

/*
 对象IO流

1.ObjectOutputStream：序列化    读入对象   对象-->字节序列
      writeObject(obj)
2.ObjectInputStream:反序列化   输出对象   字节序列-->对象
      readObject();

*/ 

public class test10 {
    
    @Test
    public void read() throws FileNotFoundException, IOException, ClassNotFoundException {
                
        //1.创建IO流对象
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("resource/emp.dat"));
        
        //2.读取
        Object obj=ois.readObject();
        System.out.println(obj); //Employee [id=1, name=zhang_shan, salary=0.0, company=shanxi]
        
        //关闭
        ois.close();        
    }
    
    
    @Test
    public void save() throws FileNotFoundException, IOException {
        Employee emp=new Employee(1,"zhang_shan",10000);
        emp.setCompany("beijing");//无法修改静态属性
        
        //1.创建IO流对象
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("resource/emp.dat"));
        
        //2.输出对象
        oos.writeObject(emp);
        
        //关闭
        oos.close();        
    }
}