10

我需要知道如何制作一个内部类 Parcelable 以便其类型的对象可以通过 AIDL 传递给远程服务。我找不到这方面的任何信息。

这是我要完成的示例代码，但它无法编译，因为 Bar 类中的 CREATOR 不能是静态的（即因为它在内部类中）。我不能使 Bar 成为静态内部类，也不能将 Bar 移到 Foo 类之外（系统内的其他依赖项）。我还需要知道如何从 AIDL 文件中引用 Bar 类。任何帮助是极大的赞赏。

public class Foo implements Parcelable
{
    private int a;

    public Foo()
    {
    }

    public Foo(Parcel source)
    {
        this.a = source.readInt();
    }

    public int describeContents()
    {
        return 0;
    }

    public void writeToParcel(Parcel dest, int flags)
    {
        dest.writeInt(this.a);
    }

    public static final Parcelable.Creator<Foo> CREATOR
    = new Parcelable.Creator<Foo>()
    {
        ...
    }

    public class Bar implements Parcelable
    {
        private int b;

        public Bar()
        {
        }

        public Bar(Parcel source)
        {
            this.b = source.readInt();
        }

        public int describeContents()
        {
            return 0;
        }

        public void writeToParcel(Parcel dest, int flags)
        {
            dest.writeInt(this.b);
        }

        public static final Parcelable.Creator<Bar> CREATOR
        = new Parcelable.Creator<Bar>()
        {
            ...
        }
    }
}
4

4 回答 4

8

我最近遇到了同样的问题，并使内部类 static 在我的情况下工作。

我阅读了为什么这实际上会起作用，这对我来说更有意义，所以我想我会分享。内部类是嵌套在另一个类中的类，并且具有对其包含类的实例的引用。通过该引用，它可以访问包含类的成员，就好像它是包含类本身一样。因此它绑定到包含类的实例，因此不能有静态成员（因为它们不会绑定到包含类）。

将嵌套类声明为静态可以将其与包含类的实例分离，因此可以拥有自己的静态变量（以及常规类可以拥有的任何其他变量）。当然它不能访问包含类的成员。

于 2014-01-14T18:05:43.973 回答
3

答案是内部类总是可以变成它自己的类。无论内部类需要从外部类的实例访问什么功能，反之亦然，都可以通过接口或公共 API 完成。尝试让 Bar 成为自己的类。Foo Bar 的任何组件都需要访问，通过将 Foo 的实例传递给 Bar 并实现适当的 API 来提供。

于 2012-01-27T00:50:01.327 回答
1

如果您的外部类保留对内部类实例的引用，您可以这样做：

public class OuterClass implements Parcelable
{
    private InnerClass reference;

    protected OuterClass( Parcel source )
    {
        this.reference = new InnerClass( source );
        // ...
    }

    @Override
    public void writeToParcel( Parcel destination, int flags )
    {
        reference.writeToParcel( destination, flags );
        // ...
    }

    public class InnerClass implements Parcelable
    {
        protected InnerClass( Parcel source )
        {
            // Read from your parcel.
        }

        @Override
        public void writeToParcel( Parcel destination, int flags )
        {
            // Write to your parcel.
        }
    }

    public static final Parcelable.Creator<OuterClass> CREATOR = new Creator<OuterClass>()
    {
         @Override
         public OuterClass createFromParcel( Parcel source )
         {
             return new OuterClass( source );
         }

         @Override
         public OuterClass[] newArray( int size )
         {
             return new OuterClass[size];
         }
    }
}
于 2012-12-02T19:28:31.590 回答
1

您的 Bar 不必是 Parcelable。您可以将 Bar 字段与 Foo 字段一起保存并在createFromParcel(Parcel)方法中恢复整个对象。

这是一些代码示例：

import android.os.Parcel;
import android.os.Parcelable;

public class Foo implements Parcelable {
    private int mFooData = 0;
    private Bar mBar;

    public Foo() {
    }

    protected Foo(Parcel in) {
        mFooData = in.readInt();

        // Reading Bar
        int barData = in.readInt();
        mBar = new Bar(barData);
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(mFooData);

        // Writing Bar
        dest.writeInt(mBar.getBarData());
    }

    @Override
    public int describeContents() {
        return 0;
    }

    public static final Creator<Foo> CREATOR = new Creator<Foo>() {
        @Override
        public Foo createFromParcel(Parcel in) {
            return new Foo(in);
        }

        @Override
        public Foo[] newArray(int size) {
            return new Foo[size];
        }
    };

    public class Bar {
        private int mBarData = 0;

        public Bar(int barData) {
            mBarData = barData;
        }

        public int getBarData() {
            return mBarData;
        }

        public void setBarData(int mBarData) {
            this.mBarData = mBarData;
        }
    }
}
于 2017-09-07T14:05:06.630 回答