android parcelable 中封装一个parcelable

原创

mob649e816a3664 2024-10-13 06:18:37 ©著作权

©著作权归作者所有：来自51CTO博客作者mob649e816a3664的原创作品，请联系作者获取转载授权，否则将追究法律责任

如何在 Android 中封装一个 Parcelable

在 Android 开发中，Parcelable 接口是用来序列化对象的工具。如果你需要传递自定义对象的实例，比如在 Activity 之间传递数据，使用 Parcelable 是非常普遍的做法。当你的自定义对象里又有另外一个 Parcelable 对象时，就需要在你的对象中进行嵌套封装。下面，我将详细指导你如何实现这一过程。

流程概述

在实现的过程中，我们可以把整个流程分为几个步骤：

步骤编号	步骤描述	代码示例
1	创建内层 Parcelable 类	`InnerClass.java`
2	创建外层 Parcelable 类	`OuterClass.java`
3	实现 Parcelable 接口	在两者中添加它
4	实现写入和读取的逻辑	在两者中实现

下面，我们来逐步实现这几个步骤。

步骤 1：创建内层 Parcelable 类

首先，我们创建一个内层的 Parcelable 类，用于封装一个简单的对象。

// InnerClass.java
import android.os.Parcel;
import android.os.Parcelable;

public class InnerClass implements Parcelable {
    private String name;

    public InnerClass(String name) {
        this.name = name;
    }

    protected InnerClass(Parcel in) {
        name = in.readString(); // 读取 String 数据
    }

    public static final Creator<InnerClass> CREATOR = new Creator<InnerClass>() {
        @Override
        public InnerClass createFromParcel(Parcel in) {
            return new InnerClass(in); // 创建 InnerClass 实例
        }

        @Override
        public InnerClass[] newArray(int size) {
            return new InnerClass[size]; // 创建 InnerClass 数组
        }
    };

    @Override
    public int describeContents() {
        return 0; // 表示没有文件描述符
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name); // 写入数据
    }
}

步骤 2：创建外层 Parcelable 类

在创建完内层类后，我们需要创建外层的 Parcelable 类来封装内层类的实例。

// OuterClass.java
import android.os.Parcel;
import android.os.Parcelable;

public class OuterClass implements Parcelable {
    private InnerClass innerClass;

    public OuterClass(InnerClass innerClass) {
        this.innerClass = innerClass;
    }

    protected OuterClass(Parcel in) {
        innerClass = in.readParcelable(InnerClass.class.getClassLoader()); // 读取内层 Parcelable
    }

    public static final Creator<OuterClass> CREATOR = new Creator<OuterClass>() {
        @Override
        public OuterClass createFromParcel(Parcel in) {
            return new OuterClass(in); // 创建 OuterClass 实例
        }

        @Override
        public OuterClass[] newArray(int size) {
            return new OuterClass[size]; // 创建 OuterClass 数组
        }
    };

    @Override
    public int describeContents() {
        return 0; // 表示没有文件描述符
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeParcelable(innerClass, flags); // 写入内层类实例
    }
}

步骤 3：实现 Parcelable 接口

注意到，我们在内层和外层的类中都实现了 Parcelable 接口，它们都是通过重写 writeToParcel 和 createFromParcel 的方法来实现序列化与反序列化。

步骤 4：实现写入和读取的逻辑

最终，我们的对象和其包含的对象都已经可以通过 Parcelable 存储和传递了。

甘特图

以下是整个实现过程的甘特图，展示了各个步骤的时间线：

gantt
    title Parcelable 实现步骤
    section 步骤
    创建内层 Parcelable 类    :a1, 2023-10-01, 1d
    创建外层 Parcelable 类    :after a1  , 1d
    实现 Parcelable 接口       :after a2  , 1d
    实现写入和读取的逻辑      :after a3  , 1d

序列图

以下是序列图，展示了两个类如何进行交互：

sequenceDiagram
    participant A as OuterClass
    participant B as InnerClass
    A->>B: writeToParcel() // 从外层类写入
    B-->>A: Data written
    A->>B: readParcelable() // 从外层类读取
    B-->>A: Data read