对象流

对象流：

对象进行序列化（解释一）：

        所谓对象序列化就是将对象的状态转换成字节流，以后可以通过这些值（字节序列）再生成相同状态的对象。

对象序列化（解释二）：
        当需要传输对象时，由于对象是很多属性和行为的封装，数据量很庞大。所以在传输对象之前需要将对象打散成字节序列，以利于传输，这个过程

 称为序列化过程。到达目的地以后，又需要将字节序列还原成对象，这个过程称为反序列化过程。

如何实现序列化：
       将需要传输的类，实现java.io.Serializable。这意味着该类的对象可以被打散成字节序列。

       transient 为属性修饰符。表示在传输对象时，该属性的值不做传输。、

代码实现：

package 对象流;

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

public class ObjectTest {
    /**
     * 将对象写入指定文件
     * @param obj
     */
    public void write(Object obj){
        //创建输出流
        OutputStream  out=null;
        //创建对象输出流
        ObjectOutputStream objOut=null;
        
        try {
            
            out=new FileOutputStream("obj.txt");
            
            objOut=new ObjectOutputStream(out);
            //写入对象，对象obj必须实现序列化接口
            objOut.writeObject(obj);
            
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                objOut.close();
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    public Object read(){
        Object obj=null;
        
        InputStream in=null;
        ObjectInputStream objIn=null;
        
        try {
            in=new FileInputStream("obj.txt");
            objIn=new ObjectInputStream(in);
            //从文件中读取对象数据
            obj=objIn.readObject();
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                objIn.close();
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        return obj;
    }
    
    public static void main(String[] args) {
        ObjectTest test=new ObjectTest();
//        test.write(new Man(1,"姓名","电话",5757));        
        System.out.println(test.read());
    }
}

package 对象流;

import java.io.Serializable;

/**
 * 公民类
 * @author Administrator
 *
 */

//Man类实现了Serializable,表示该类对象可以被序列化，可以传输该对象。
public class Man implements Serializable{
    /**编号*/
    private int id;
    /**姓名*/
    private String name;
    /**电话*/
    private String tel;
   //该属性加上transient修饰符后，表示该对象在做序列化传输时，money的值 不会被序列化，即不会被传输。这样有利于保护数据的安全性 
    private transient int money;  

    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 String getTel() {
        return tel;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Man [id=" + id + ", name=" + name + ", tel=" + tel + ", money="
                + money + "]";
    }

    public Man(int id, String name, String tel, int money) {
        super();
        this.id = id;
        this.name = name;
        this.tel = tel;
        this.money = money;
    }

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