【常用API】之序列化与反序列化Serializable

【序列化：Serializable】

有一个具体的类对象，它用于保存程序运行过程中，产生的数据。
目前它是在内存上的，程序一旦结束就没有了。
有么有可能，它运行过程中的类，包括里面的数据，保存下来。
下一次运行程序的时候，拿出来，继续操作。

把这个运行过程中的类及数据，保存成一个文件。

要使用的时候再读取出来。

【对象序列化】：
将一个有数据的类信息，写成一个文档，保存到硬盘上。

序列化的条件：

如果一个类对象，需要被序列化操作的，它不能是普通的类，
它必须是：Serializable 的实现类

import java.IO.Serializable;

public class 类 implements Serializable{}

【反序列化】：
把那个硬盘上的文件，读取到程序中，回到内存上变成类对象。

程序必须有原始的类对象文件：

序列后的生成的文件，它主要是运行过程中的数据。

反序列化的时候，把文件中的数据读取出来，通过 serialVersionUID去对应类

然后：实例化类，填入数据，恢复到内存上。

其中:

transient：修饰符：
正常使用，但是禁止序列化（序列化会忽略）
都是给属性使用的。

对象流：建立在基础的字节流之上【用于序列化】
ObjectInputStream
ObjectOutputStream

序列化的实例：

1、首先创建一个需要被实例化的类，然后implements Serializable类

package com.xzm.test;

//导入序列化操作的接口包文件
import java.io.Serializable;


//自定义：用于的数据实体模型类
//没有行为，只有属性，用于存取数据
//需要 序列化的，
public class User implements Serializable {
    
    //serialVersionUID：这个属性是固定的
    //用户可以自定义它的值，long类型
    //如果不写，程序会默认自动创建
    //这个属性是提供程序把文件读取出来以后，转换成指定的类的一个对应成
    //主要就是用于判断，转换的是不是同一个类
    //【通常不用自定义，程序自动填充】---> 提示中选择第二项，分配
    private static final long serialVersionUID = 3050851876068541840L;

    
    
    //普通的属性及封装属性【会序列化】
    private int id;       //变量
    private String name;  //类对象
    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 User(int id, String name) {
        this.id = id;
        this.name = name;
    }
    
    
    //--------------------------------------------
    // transient：修饰符
    // 用于序列化，表示 暂时的
    // 正常操作没有问题，内存上与普通的一样，
    // 但是，它不会被序列化到物理文件中
    public transient int age = 28;
    
    
    
    
}

2、将上面的User类实例化操作

package com.xzm.test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class 序列化User {

    public static void main(String[] args) {
        
        //强制异常处理
        try {
            
            //第一步：
            // 定义File对象，定义目标源。
            // 内存数据写成文件，通常是不允许直接打开预览的
            // 大部分应用程序是写后缀，
            // 游戏类的会自定义名称， 
            // 标准开发的时候，推荐:  .es
            File f = new File("C:/aaa/User.es");
            
            
            //第二步：创建 基础 字节 输出流
            FileOutputStream fos = new FileOutputStream(f);
            
            
            //第三步：
            // 创建高层 对象 输出 流
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            
            
            //操作对象--->在内存
            User u = new User(555, "张三");
            
            
            //第四步：写文件，生成序列化文档
            oos.writeObject(u);
            
            
            //关闭
            oos.close();
            fos.close();
            
            //提示：
            System.out.println("保存成功！");
            
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        
    }

}

此时通过上面两步，已经将User类实例化了，现在再将它反序列化

package com.xzm.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class 反序列化es {

    public static void main(String[] args) {
        
        try {            
        
            //【反序列化】：把物理文件，恢复到内存
            
            //第一步：（目标源）
            File f = new File("C:/aaa/User.es");
        
            
            //第二步：基础 字节 输入流
            FileInputStream fis = new FileInputStream(f);
            
            
            //第三步：高层对象输入流
            ObjectInputStream ois = new ObjectInputStream(fis);
            
        
            //第四步：
            // 调用方法，读取文件，得到一个Object对象
            // 文件读取到系统中，都是一个Object
            Object obj = ois.readObject();
        
        
            //第五步：
            //转换类型，把对象转换成所对应的类
            //这时，会判断： serialVersionUID 是否一样
            User u = (User)obj;
            
            
            //关闭
            ois.close();
            fis.close();
            
            //============================================
            
            System.out.println(u.getId());
            
            System.out.println(u.getName());
            
            
            
            
            
            
            
        
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }

    }

}

总结：

序列化与反序列化的操作，一帮用于单机程序的配置保存，

特别是哪些单机的应用程序，游戏，都是这个操作。
应用程序：配置文件
游戏： 配置文件，存档