Sérialisation et désérialisation d'interfaces et de classes abstraites en Java

Les interfaces ne peuvent pas être sérialisées directement. Les classes abstraites peuvent être sérialisées mais seulement si elles ne contiennent pas de champs non statiques et non transitoires ou si elles ne remplacent pas les méthodes writeObject() et readObject(). Des instances spécifiques peuvent être implémentées via des classes concrètes qui implémentent le. ou remplacez l'implémentation de writeObject() et de la classe Abstract de la méthode readObject().

Sérialisation et désérialisation des interfaces et des classes abstraites en Java

Introduction

La sérialisation en Java est un processus de conversion d'un objet en une séquence d'octets pour le stockage ou la transmission. La désérialisation est le processus inverse de restauration d'une séquence d'octets dans un objet. Java fournit une prise en charge intégrée de la sérialisation et de la désérialisation pour les objets qui implémentent l'interface Sérialisable. Cependant, pour les interfaces et les classes abstraites, la situation est différente. Serializable 接口的对象，Java 提供了内置的序列化和反序列化支持。然而，对于接口和抽象类，情况却有所不同。

接口的序列化

接口本身不是对象，因此不能被序列化。要序列化和反序列化接口的实例，需要创建一个实现该接口的具体类，并确保该具体类实现 Serializable 接口。

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

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

抽象类的序列化

抽象类可以被序列化，前提是它们不包含任何非静态、非瞬态字段。如果一个抽象类包含非静态、非瞬态字段，那么它不能被序列化，除非显式地实现 writeObject() 和 readObject() 方法。

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

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

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

实战案例

序列化

可以使用 ObjectOutputStream 类将对象序列化为字节序列。

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

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

反序列化

使用 ObjectInputStream

Sérialisation des interfaces

🎜🎜L'interface elle-même n'est pas un objet et ne peut donc pas être sérialisée. Pour sérialiser et désérialiser les instances d'une interface, créez une classe concrète qui implémente l'interface et assurez-vous que la classe concrète implémente l'interface Sérialisable. 🎜

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

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

🎜🎜Sérialisation des classes abstraites🎜🎜🎜Les classes abstraites peuvent être sérialisées à condition qu'elles ne contiennent aucun champ non statique et non transitoire. Si une classe abstraite contient des champs non statiques et non transitoires, elle ne peut pas être sérialisée à moins que les méthodes writeObject() et readObject() ne soient explicitement implémentées. 🎜rrreee🎜🎜Cas pratique🎜🎜🎜🎜Serialization🎜🎜🎜 Vous pouvez utiliser la classe ObjectOutputStream pour sérialiser des objets en séquences d'octets. 🎜rrreee🎜🎜Désérialisation🎜🎜🎜Utilisez la classe ObjectInputStream pour désérialiser une séquence d'octets en un objet. 🎜rrreee🎜De cette façon, les instances d'interfaces et de classes abstraites peuvent être sérialisées et désérialisées. Il convient de noter que pour garantir le succès de la sérialisation et de la désérialisation, les règles de sérialisation Java doivent être respectées. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!