Android 继承人类的getCreator存在可包裹继承问题

我有一个包裹类

a

和

B

，它扩展了

a

例如：

甲级

public abstract class A implements Parcelable {
    private int a;

    protected A(int a) {
        this.a = a;
    }

    public int describeContents() {
        return 0;
    }

    public static Creator<A> getCreator() {
        return CREATOR;
    }

    public static final Parcelable.Creator<A> CREATOR = new Parcelable.Creator<A>() {
        public A createFromParcel(Parcel in) {
            return new A(in);
        }

        public A[] newArray(int size) {
            return new A[size];
        }
    };

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

    protected A(Parcel in) {
        a = in.readInt();
    }
}

公共抽象类A实现可包裹{
私人INTA；
受保护A（INTA）{
这个a=a；
}
公共int描述内容（）{
返回0；
}
公共静态创建者getCreator（）{
回归创造者；
}
public static final Parcelable.Creator=新建Parcelable.Creator（）{
公共A createFromParcel（中的地块）{
返回新的A（in）；
}
公共A[]新数组（整数大小）{
返回新的[尺寸]；
}
};
公共无效写入包（包出，内部标志）{
出、出、出（a）；
}
受保护的一个（包裹中）{
a=in.readInt（）；
}
}

B类继承人

public class B extends A {
    private int b;

    public B(int a, int b) {
        super(a);
        this.b = b;
    }

    public static Creator<B> getCreator() {
        return CREATOR;
    }

    public static final Parcelable.Creator<B> CREATOR = new Parcelable.Creator<B>() {
        public B createFromParcel(Parcel in) {
            return new B(in);
        }

        public B[] newArray(int size) {
            return new B[size];
        }
    };

    public int describeContents() {
        return 0;
    }

    public void writeToParcel(Parcel out, int flags) {
        super.writeToParcel(out, flags);
        out.writeInt(b);
    }

    private B(Parcel in) {
        super(in);
        b = in.readInt();
    }
}

公共类B扩展了{
私人INTB；
公共B（内部a、内部B）{
超级（a）；
这个.b=b；
}
公共静态创建者getCreator（）{
回归创造者；
}
public static final Parcelable.Creator=新建Parcelable.Creator（）{
公共B createFromParcel（地块中）{
返回新的B（in）；
}
公共B[]新数组（整数大小）{
返回新的B[尺寸]；
}
};
公共int描述内容（）{
返回0；
}
公共无效写入包（包出，内部标志）{
super.writeToParcel（输出，标志）；
外写（b）；
}
二等兵B（包内）{
超级(in),；
b=in.readInt（）；
}
}

在B中，我在中得到错误“返回类型与A.getCreator（）不兼容”

publicstaticcreatorgetcreator（）{
回归创造者；
}

显然，如果我试图将类

B

的

getCreator

的类型更改为

Creator

，则不起作用，因为包裹创建者的类型是

B

---

我如何解决这个问题？

以下是我如何实现的。我创建了一个抽象父类，让我们使用父类

A

，您应该在其中添加两个抽象方法：

protected abstract void writeChildParcel（包裹pc，int标志）

和

protected abstract void readFromParcel（包裹pc）

然后需要一个静态方法来创建

a

的正确实例。在我的例子中，有一个type属性（您可以使用

enum

）是有意义的，在这里我可以识别它们中的每一个。这样我们就可以有一个静态的

newInstance（int-type）

方法，如下所示：

public static A newInstance(int type) {
    A a = null;
    switch (type) {
    case TYPE_B:
            a = new B();
            break;
        ...
    }
    return a;
 }

public static A newInstance(Parcel pc) {
    A a = A.newInstance(pc.readInt()); //
    //call other read methods for your abstract class here
    a.readFromParcel(pc);
    return a;
 }

public static final Parcelable.Creator<A> CREATOR = new Parcelable.Creator<A>() {
    public A createFromParcel(Parcel pc) {
        return A.newInstance(pc);
    }
    public A[] newArray(int size) {
        return new A[size];
    }
};

现在去掉

B

中的

CREATOR

和所有其他

Parcelable

方法，只需在其中实现

writeChildParcel

和

readFromParcel

。你该走了

希望能有帮助

public static A newInstance(int type) {
    A a = null;
    switch (type) {
    case TYPE_B:
            a = new B();
            break;
        ...
    }
    return a;
 }

public static A newInstance(Parcel pc) {
    A a = A.newInstance(pc.readInt()); //
    //call other read methods for your abstract class here
    a.readFromParcel(pc);
    return a;
 }

public static final Parcelable.Creator<A> CREATOR = new Parcelable.Creator<A>() {
    public A createFromParcel(Parcel pc) {
        return A.newInstance(pc);
    }
    public A[] newArray(int size) {
        return new A[size];
    }
};

public void writeToParcel(Parcel out, int flags) {
    out.writeInt(type);
    //call other write methods for your abstract class here
    writeChildParcel(pc, flags);
}