这是一个一般的 JAVA 问题。在android中,有一个接口(interface) Parcelable
:
这是 official documentation 中的一个示例:
public class MyParcelable implements Parcelable {
private int mData;
public int describeContents() {
return 0;
}
public void writeToParcel(Parcel out, int flags) {
out.writeInt(mData);
}
public static final Parcelable.Creator<MyParcelable> CREATOR
= new Parcelable.Creator<MyParcelable>() {
public MyParcelable createFromParcel(Parcel in) {
return new MyParcelable(in);
}
public MyParcelable[] newArray(int size) {
return new MyParcelable[size];
}
};
private MyParcelable(Parcel in) {
mData = in.readInt();
}
}
我们需要实现这两个功能 describeContents()
和 writeToParcel
.
(问题)
除了它们,我们还需要实现 Parcelable.Creator<T>
接口(interface)作为称为 CREATOR 的静态字段。
实际上一切都是直截了当的。现在我想创建一个具有 Parcelable 类类型的通用类:
public class ShushContainer<T extends Parcelable> implements Parcelable
我能够实现 Parcelable。我可以调用 T
的 writeToParcel
功能。但是,我无法访问静态 CREATOR 字段。
public class ShushContainer<T extends Parcelable> implements Parcelable {
Vector<T> items;
String someField;
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(someField);
dest.writeInt(items.size());
for(int i=0;i<items.size();i++)
items.get(i).writeToParcel(dest, flags);
}
public ShushContainer(Parcel in) {
someField = in.readString();
int size = in.readInt();
for(int i=0;i<size;i++)
//this does not work
items.add(T.CREATOR.createFromParcel(in));
}
public static final Parcelable.Creator<ShushContainer> CREATOR = new Parcelable.Creator<ShushContainer>() {
public ShushContainer createFromParcel(Parcel in) {
return new ShushContainer(in);
}
public ShushContainer[] newArray(int size) {
return new ShushContainer[size];
}
};
}
最佳答案
而不是 <T extends Parcelable>
你需要<T extends ShushContainer<T> & Parcelable>
这样你指定 T
是ShushContainer
这样您就可以访问方法和变量。
public class ShushContainer<T extends ShushContainer<T> & Parcelable>
implements Parcelable
这是使用 Serializable
的示例
class Sample<T extends Sample<T> & Serializable> implements Serializable {
public static int CONST = 0;
public void foo()
{
T.CONST = 5;
}
}
更新
如果我理解正确的话,还有另一个实现了 Parcelable
的类其中有 CREATOR
您正在尝试静态变量的动态多态性,这是不可能的。
展示它如何失败的示例
public class Base {
public static int count = 10;
}
public class Child extends Base {
public static int count = 20;
}
class Sample<T extends Base> {
T t = null;
public void printCount() {
System.out.println(T.count);
}
public Sample(T t) {
this.t = t;
}
public static void main(String[] args) {
Sample<Child> sample = new Sample<Child>(new Child());
Sample<Base> sample1 = new Sample<Base>(new Base());
sample.printCount();//Child value printed as 10
sample1.printCount();//Same for parent value printed as 10
}
}
这个程序失败是因为静态字段绑定(bind)到类而不是实例所以有两个独立的count
一个用于 Base
和一个 Child
如果您访问 Base
的值那么它将永远是 10。
您可以使用反射来检查是否CREATOR
字段存在并访问它。如果没有对象或类对象,这是不可能的。
或者您可以使用 TypeToken 执行如下操作
class Sample<T extends Serializable> implements Serializable {
public int abc = 0;
public void foo() {
}
public static void main(String[] args) throws SecurityException, NoSuchFieldException {
TypeToken<Sample<Integer>> token = new TypeToken<Sample<Integer>>() {
};
Class<?> t = token.getRawType();
Field field = t.getDeclaredField("abc");
field.setAccessible(true);
System.out.println(field.getName());
}
}
关于java - 具有约束访问问题的通用类,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/12601489/