Java 如何将此泛型类转换为可包裹类？

我想把这个泛型类转换成一个可包裹的对象，但我对这个问题的概念不是很清楚

类别：

public class Type<T> implements Parcelable {

    // T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }

    public T get() { return t; }

}

公共类类型实现可包裹{
//T代表“类型”
私人T；
公共无效集（T）{this.T=T；}
公共T get（）{return T；}
}

这就是我试过的，。但我知道这是不正确的，或者这是不完整的

public class Type<T> implements Parcelable {

    // T stands for "Type"
    private T t;

    protected Type(Parcel in) {
    }

    public void set(T t) { this.t = t; }

    public T get() { return t; }

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
    }

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

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

}

公共类类型实现可包裹{
//T代表“类型”
私人T；
受保护类型（包裹中）{
}
公共无效集（T）{this.T=T；}
公共T get（）{return T；}
@凌驾
公共int描述内容（）{
返回0；
}
@凌驾
公共无效写入包裹（包裹目的地，内部标志）{
}
公共静态最终创建者<类型>创建者=新创建者<类型>（）{
@凌驾
公共类型createFromParcel（中的地块）{
返回新类型（in）；
}
@凌驾
公共类型[]新数组（整数大小）{
返回新类型[大小]；
}
};
}

您的通用数据类型可能会导致运行时错误

因此，请确保您实现了Parcelable，并且您要传递的类也应该实现Parcelable，否则将导致运行时错误

     public class Type<T extends Parcelable> implements Parcelable {

    // T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }

    public T get() { return t; }


    protected Type(Parcel in) {
        final String className = in.readString();
        try {
            t = in.readParcelable(Class.forName(className).getClassLoader());
        } catch (ClassNotFoundException e) {
            Log.e("readParcelable", className, e);
        }
    }

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeValue(t);
    }

    @SuppressWarnings("unused")
    public static final Parcelable.Creator<Type> CREATOR = new Parcelable.Creator<Type>() {
        @Override
        public Type createFromParcel(Parcel in) {
            return new Type(in);
        }

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

公共类类型实现可包裹{
//T代表“类型”
私人T；
公共无效集（T）{this.T=T；}
公共T get（）{return T；}
受保护类型（包裹中）{
最终字符串className=in.readString（）；
试一试{
t=in.readParcelable（Class.forName（className）.getClassLoader（））；
}catch（classnotfounde异常）{
Log.e（“readParcelable”，类名，e）；
}
}
@凌驾
公共int描述内容（）{
返回0；
}
@凌驾
公共无效写入包裹（包裹目的地，内部标志）{
目的地书面价值（t）；
}
@抑制警告（“未使用”）
public static final Parcelable.Creator=新建Parcelable.Creator（）{
@凌驾
公共类型createFromParcel（中的地块）{
返回新类型（in）；
}
@凌驾
公共类型[]新数组（整数大小）{
返回新类型[大小]；
}
};
}

您的通用数据类型可能会导致运行时错误

因此，请确保您实现了Parcelable，并且您要传递的类也应该实现Parcelable，否则将导致运行时错误

     public class Type<T extends Parcelable> implements Parcelable {

    // T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }

    public T get() { return t; }


    protected Type(Parcel in) {
        final String className = in.readString();
        try {
            t = in.readParcelable(Class.forName(className).getClassLoader());
        } catch (ClassNotFoundException e) {
            Log.e("readParcelable", className, e);
        }
    }

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeValue(t);
    }

    @SuppressWarnings("unused")
    public static final Parcelable.Creator<Type> CREATOR = new Parcelable.Creator<Type>() {
        @Override
        public Type createFromParcel(Parcel in) {
            return new Type(in);
        }

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

公共类类型实现可包裹{
//T代表“类型”
私人T；
公共无效集（T）{this.T=T；}
公共T get（）{return T；}
受保护类型（包裹中）{
最终字符串className=in.readString（）；
试一试{
t=in.readParcelable（Class.forName（className）.getClassLoader（））；
}catch（classnotfounde异常）{
Log.e（“readParcelable”，类名，e）；
}
}
@凌驾
公共int描述内容（）{
返回0；
}
@凌驾
公共无效写入包裹（包裹目的地，内部标志）{
目的地书面价值（t）；
}
@抑制警告（“未使用”）
public static final Parcelable.Creator=新建Parcelable.Creator（）{
@凌驾
公共类型createFromParcel（中的地块）{
返回新类型（in）；
}
@凌驾
公共类型[]新数组（整数大小）{
返回新类型[大小]；
}
};
}

这与vikas kumar的方法类似，但保证只能将Parcelable作为T参数传递，以避免异常

public class Type<T extends Parcelable> implements Parcelable {
    private T t;

    protected Type(Parcel in) {
        t = (T) in.readValue(t.getClass().getClassLoader());
    }

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

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

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeValue(t);
    }
}

公共类类型实现可包裹{
私人T；
受保护类型（包裹中）{
t=（t）in.readValue（t.getClass（）.getClassLoader（））；
}
公共静态最终创建者=新创建者（）{
@凌驾
公共类型createFromParcel（中的地块）{
返回新类型（in）；
}
@凌驾
公共类型[]新数组（整数大小）{
返回新类型[大小]；
}
};
@凌驾
公共int描述内容（）{
返回0；
}
@凌驾
公共无效写入包裹（包裹目的地，内部标志）{
目的地书面价值（t）；
}
}

这与vikas kumar的方法类似，但保证只能将Parcelable作为T参数传递，以避免异常

public class Type<T extends Parcelable> implements Parcelable {
    private T t;

    protected Type(Parcel in) {
        t = (T) in.readValue(t.getClass().getClassLoader());
    }

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

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

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeValue(t);
    }
}

公共类类型实现可包裹{
私人T；
受保护类型（包裹中）{
t=（t）in.readValue（t.getClass（）.getClassLoader（））；
}
公共静态最终创建者=新创建者（）{
@凌驾
公共类型createFromParcel（中的地块）{
返回新类型（in）；
}
@凌驾
公共类型[]新数组（整数大小）{
返回新类型[大小]；
}
};
@凌驾
公共int描述内容（）{
返回0；
}
@凌驾
公共无效写入包裹（包裹目的地，内部标志）{
目的地书面价值（t）；
}
}

我已经发布了。我已经发布了。谢谢，我使用的是ANDROID包裹生成器，但是对于私有的T，出现了错误。T=（T）在.readValue（T.class.getClassLoader（））中；正在用一个错误警告我。我不知道如何修复它：DWorks。如何使用它？只需创建类型obj=new Type（）；但是我需要在一个方法上引用它，比如：public void method_x（Type typeObject{}），但是我得到一个错误，说T没有定义。谢谢，我使用了一个android Parcelable生成器，但是对于私有的T，有错误。readValue（T.class.getClassLoader（））中的T=（T）；正在用一个错误警告我。我不知道如何修复它：DWorks。如何使用它？只需创建类型obj=new Type（）；但是我需要在一个方法上引用它，比如：public void method_x（Type typeObject{}），但是我得到一个错误，说T没有定义。