Java对象为啥要实现Serializable接口？

水深无声 2023-10-04 15:06 25阅读 0赞

1.  为什么一定要实现Serializable接口?
2.  它的底层原理是什么?
3.  为什么一定要序列化？
4.  序列化又是什么?

## **1、Serializable接口概述** ##

> Serializable是java.io包中定义的，用于实现Java类的序列化操作而提供的一个语义级别的接口。Serializable序列化接口没有任何方法或者字段，只是用于标识可序列化的语义。实现了Serializable接口的类可以被ObjectOutputStream转换为字节流，同时也可以通过ObjectInputStream再将其解析为对象。

例如，我们可以将序列化对象写入文件后，再次从文件中读取它并反序列化成对象，也就是说，可以使用表示对象及其数据的类型信息和字节在内存中重新创建对象。

而这一点对于面向对象的编程语言来说是非常重要的，因为无论什么编程语言，其底层涉及IO操作的部分还是由操作系统帮其完成的，而底层IO操作都是以字节流的方式进行的，所以写操作都涉及将编程语言数据类型转换为字节流，而读操作则又涉及将字节流转化为编程语言类型的特定数据类型。而Java作为一门面向对象的编程语言，对象作为其主要数据的类型载体，为了完成对象数据的读写操作，也就需要一种方式来让JVM知道在进行IO操作时如何将对象数据转换为字节流，以及如何将字节流数据转换为特定的对象，而Serializable接口就承担了这样一个角色。

### 2、序列化的用途 ###

*  想把的内存中的对象状态保存到一个文件中或者数据库中时候。
 *  想把对象通过网络进行传播的时候。

## 3、如何序列化 ##

只要一个类实现Serializable接口，那么这个类就可以序列化了。

例如有一个 Person类，实现了Serializable接口，那么这个类就可以被序列化了。

piblic class Person implements Serializable{   
        private static final long serialVersionUID = 1L; //一会就说这个是做什么的
        String name;
        int age;
        public Person(String name,int age){
            this.name = name;
            this.age = age;
        }   
        public String toString(){
            return "name:"+name+"\tage:"+age;
        }
    }

通过ObjectOutputStream 的writeObject()方法把这个类的对象写到一个地方（文件），再通过ObjectInputStream 的readObject()方法把这个对象读出来。

public static void writeObj() { 
    	File file = new File("file"+File.separator+"out.txt");
        
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
            ObjectOutputStream oos = null;
            try {
                oos = new ObjectOutputStream(fos);
                Person person = new Person("tom", 22);
                System.out.println(person);
                oos.writeObject(person);            //写入对象
                oos.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    oos.close();
                } catch (IOException e) {
                    System.out.println("oos关闭失败："+e.getMessage());
                }
            }
        } catch (FileNotFoundException e) {
            System.out.println("找不到文件："+e.getMessage());
        } finally{
            try {
                fos.close();
            } catch (IOException e) {
                System.out.println("fos关闭失败："+e.getMessage());
            }
        }
    }

public static void readObj() { 
    	FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            ObjectInputStream ois = null;
            try {
                ois = new ObjectInputStream(fis);
                try {
                    Person person = (Person)ois.readObject();   //读出对象
                    System.out.println(person);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } 
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    ois.close();
                } catch (IOException e) {
                    System.out.println("ois关闭失败："+e.getMessage());
                }
            }
        } catch (FileNotFoundException e) {
            System.out.println("找不到文件："+e.getMessage());
        } finally{
            try {
                fis.close();
            } catch (IOException e) {
                System.out.println("fis关闭失败："+e.getMessage());
            }
        }
    }

输出结果为：

name:tom age:22
    name:tom age:22

结果完全一样。如果我把Person类中的implements Serializable 去掉，Person类就不能序列化了。此时再运行上述程序，就会报**java.io.NotSerializableException**异常。

#### 4、serialVersionUID ####

注意到上面程序中有一个 serialVersionUID ，实现了Serializable接口之后，Eclipse就会提示你增加一个 serialVersionUID，虽然不加的话上述程序依然能够正常运行。

序列化 ID 在 Eclipse 下提供了两种生成策略

*  一个是固定的 1L
 *  一个是随机生成一个不重复的 long 类型数据（实际上是使用 JDK 工具，根据类名、接口名、成员方法及属性等来生成）

上面程序中，输出对象和读入对象使用的是同一个Person类。

如果是通过网络传输的话，如果Person类的serialVersionUID不一致，那么反序列化就不能正常进行。例如在客户端A中Person类的**serialVersionUID=1L**，而在客户端B中Person类的**serialVersionUID=2L** 那么就不能重构这个Person对象。

客户端A中的Person类：**serialVersionUID=1L**

public class Person implements Serializable{   
        
        private static final long serialVersionUID = 1L;
        
        String name;
        int age;
        
        public Person(String name,int age){
            this.name = name;
            this.age = age;
        }   
        public String toString(){
            return "name:"+name+"\tage:"+age;
        }
    }

客户端B中的Person类：**serialVersionUID = 2L;**

public class Person implements Serializable{   
        
        private static final long serialVersionUID = 2L;
        
        String name;
        int age;
        
        public Person(String name,int age){
            this.name = name;
            this.age = age;
        }   
        public String toString(){
            return "name:"+name+"\tage:"+age;
        }
    }

试图重构就会报**java.io.InvalidClassException**异常，因为这两个类的版本不一致，local class incompatible，重构就会出现错误。

如果没有特殊需求的话，使用用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。那么随机生成的序列化 ID 有什么作用呢，有些时候，通过改变序列化 ID 可以用来限制某些用户的使用。

## 5、静态变量序列化 ##

串行化只能保存对象的非静态成员交量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符都不能保存。

如果把Person类中的name定义为static类型的话，试图重构，就不能得到原来的值，只能得到null。说明对静态成员变量值是不保存的。

这其实比较容易理解，**序列化保存的是****对象****的状态，****静态变量属于类的状态**，因此 **序列化并不保存静态变量**。

## 6、transient关键字 ##

经常在实现了 Serializable接口的类中能看见transient关键字。这个关键字并不常见。

**transient关键字的作用是**：**阻止实例中那些用此关键字声明的变量持久化**；**当对象被反序列化时（从源文件读取字节序列进行重构），这样的实例变量值不会被持久化和恢复**。

当某些变量不想被序列化，同是又不适合使用static关键字声明，那么此时就需要用transient关键字来声明该变量。

例如用 transient关键字 修饰name变量

public class Person implements Serializable{   
        
        private static final long serialVersionUID = 1L;
        
        transient String name;
        int age;
        
        public Person(String name,int age){
            this.name = name;
            this.age = age;
        }   
        public String toString(){
            return "name:"+name+"\tage:"+age;
        }
    }

在反序列化试图重构对象的时候，作用与static变量一样： 输出结果为：

name:null   age:22

**在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。**

注：对于某些类型的属性，其状态是瞬时的，这样的属性是无法保存其状态的。例如一个线程属性或需要访问IO、本地资源、网络资源等的属性，对于这些字段，我们必须用transient关键字标明，否则编译器将报措。

#### 7、序列化中的继承问题 ####

*  当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。
 *  一个子类实现了 Serializable 接口，它的父类都没有实现 Serializable 接口，要想将父类对象也序列化，就需要让父类也实现Serializable 接口。

第二种情况中：如果父类不实现 Serializable接口的话，就需要有默认的无参的构造函数。这是因为一个 Java 对象的构造必须先有父对象，才有子对象，反序列化也不例外。在反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时，它的值是调用父类无参构造函数后的值。在这种情况下，在序列化时根据需要在父类无参构造函数中对变量进行初始化，否则的话，父类变量值都是默认声明的值，如 int 型的默认是 0，string 型的默认是 null。

例如：

public class People{
        int num;
        public People(){}           //默认的无参构造函数，没有进行初始化
        public People(int num){     //有参构造函数
            this.num = num;
        }
        public String toString(){
            return "num:"+num;
        }
    }
    
    public Person extends People implements Serializable{    
        
        private static final long serialVersionUID = 1L;
        
        String name;
        int age;
        
        public Person(int num,String name,int age){
            super(num);             //调用父类中的构造函数
            this.name = name;
            this.age = age;
        }
        public String toString(){
            return super.toString()+"\tname:"+name+"\tage:"+age;
        }
    }

在一端写出对象的时候

Person person = new Person(10,"tom", 22); //调用带参数的构造函数num=10,name = "tim",age =22
        System.out.println(person);
        oos.writeObject(person);                  //写出对象

在另一端读出对象的时候

Person person = (Person)ois.readObject(); //反序列化，调用父类中的无参构函数。
        System.out.println(person);

输出为：

num:0   name:tom    age:22

发现由于父类中无参构造函数并没有对num初始化，所以num使用默认值为0。

### 8、总结 ###

序列化给我们提供了一种技术，用于保存对象的变量。以便于传输。虽然也可以使用别的一些方法实现同样的功能，但是java给我们提供的方法使用起来是非常方便的。