Serialization and deserialization of interfaces and abstract classes in Java

Interfaces cannot be serialized directly. Abstract classes can be serialized but only if they do not contain non-static, non-transient fields or override writeObject() and readObject() methods. Specific instances can be implemented through concrete classes that implement the interface or override writeObject() ) and readObject() methods.

Serialization and deserialization of interfaces and abstract classes in Java

Introduction

In Java Serialization is the process of converting an object into a sequence of bytes for storage or transmission. Deserialization is the reverse process of restoring a sequence of bytes into an object. Java provides built-in serialization and deserialization support for objects that implement the Serializable interface. However, for interfaces and abstract classes, the situation is different.

Serialization of interfaces

The interface itself is not an object and therefore cannot be serialized. To serialize and deserialize instances of an interface, you need to create a concrete class that implements the interface, and ensure that the concrete class implements the Serializable interface.

// 接口
public interface Shape {
    // ...
}

// 具体类并实现 Serializable 接口
public class Circle implements Shape, Serializable {
    // ...
}

Serialization of abstract classes

Abstract classes can be serialized provided that they do not contain any non-static, non-transient fields. If an abstract class contains non-static, non-transient fields, it cannot be serialized unless the writeObject() and readObject() methods are explicitly implemented.

// 抽象类实现 Serializable 接口
public abstract class Animal implements Serializable {
    // ...

    // 覆盖 writeObject() 方法
    private void writeObject(ObjectOutputStream out) throws IOException {
        // ...
    }

    // 覆盖 readObject() 方法
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        // ...
    }
}

Practical case

Serialization

You can use the ObjectOutputStream class to serialize the object into Byte sequence.

// 创建 ObjectOutputStream 对象
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.ser"));

// 序列化对象
out.writeObject(circle);

Deserialization

Use the ObjectInputStream class to deserialize a sequence of bytes into an object.

// 创建 ObjectInputStream 对象
ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.ser"));

// 反序列化对象
Circle circle = (Circle) in.readObject();

In this way, instances of interfaces and abstract classes can be serialized and deserialized. It should be noted that in order to ensure the success of serialization and deserialization, Java serialization rules need to be followed.

The above is the detailed content of Serialization and deserialization of interfaces and abstract classes in Java. For more information, please follow other related articles on the PHP Chinese website!