利⽤Kotlin如何实现Android开发中的Parcelable详解
坑
先来看看 Android Studio 给的⾃动实现。
新建⼀个数据类，让它实现 Parcelable
data class Worker(
var id: Int,
var name: String,
var tasks: MutableList<Int>
) : Parcelable
使⽤ Android Studio ⾃带的 Add Parcelable Implementation ，然后你就得到了。。。
data class Worker(cet官网
var id: Int,
var name: String,
var tasks: MutableList<Int>
) : Parcelable {
constructor(parcel: Parcel) : this(
梯子英语
TODO("tasks")) {
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
parcel.writeInt(id)
parcel.writeString(name)
}
override fun describeContents(): Int {
return 0
}
companion object CREATOR : Parcelable.Creator<Worker> {
override fun createFromParcel(parcel: Parcel): Worker {
return Worker(parcel)
}
override fun newArray(size: Int): Array<Worker?> {
return arrayOfNulls(size)
}
}
high impact polystyrene}
有什么问题呢？
⾄少现在可以编译过了。。。
很明显的，⾃动⽣成的 Parcelable 实现没有包含对 MutableList 的处理，因为 Parcel 原⽣只⽀持 ArrayList ，所以这是需要你⾃⼰实现的部分。先来解决这个问题。
虽然名字是 MutableList ，但是实际上这只是 Kotlin 的⼀个辅助类型，可以⽤ Tools -> Kotlin -> Show Kotlin Bytecode 查看它编译成 JVM 字节码之后的样⼦。
// access flags 0x2
// signature Ljava/util/List<Ljava/lang/Integer;>;
// declaration: java.util.List<java.lang.Integer>
private Ljava/util/List; tasks
@Lorg/jetbrains/annotations/NotNull;() // invisible
点击 [Decompile] 按钮还可以直接反编译到 Java 。
编译之后 MutableList 变成了 Java 的原⽣类型 java.util.List 。因此我们只需要在对应的地⽅调⽤ Parcel 中对 List 和 ArrayList 的处理⽅法就可以了。
constructor(parcel: Parcel) : this(
}
override fun writeToParcel(parcel: Parcel, flags: Int) {
parcel.writeInt(id)
parcel.writeString(name)
parcel.writeList(tasks)
}
writeList 是可以兼容 Kotlin 的 List 与 MutableList 类型的，但是 ArrayList 还需要强转⼀下才⾏，虽然能跑但是会很难看，能不能变好看⼀点呢？
加⼀个扩展⽅法就好了
inline fun <reified T> adMutableList(): MutableList<T> {
@Suppress("UNCHECKED_CAST")
return readArrayList(T::class.java.classLoader) as MutableList<T>
}
然后就可以这样写
constructor(parcel: Parcel) : this(
}
cf的英文override fun writeToParcel(parcel: Parcel, flags: Int) {
parcel.writeInt(id)
parcel.writeString(name)
parcel.writeList(tasks)
}
CREATOR 与 companion object 之争
Parcelable 有个特殊的要求，在⾥是这样写的
Parcelable interface must also have a non-null static field called CREATOR of a type that implements the Parcelable.Creator interface.
这是因为 Java 的泛型有运⾏时消除机制的限制， Parcel 需要⼀个辅助对象来协助构造你的对象以及你的对象的数组，这就是CREATOR 。 Parcelable 要求每个实现类都有这个 CREATOR 对象，并且它必须是⾮空的、公有的、静态字段。在 Java 程序中，对于每个类 CREATOR 有⾮常稳定的实现。假如上⾯的例⼦是⽤ Java 写的，由于我们已经有了⼀个以 Parcel 为参数的构造⽅法，我们只需要这样实现 CREATOR 。
public static final Creator<Worker> CREATOR = new Creator<Worker>() {
@Override
public Worker createFromParcel(Parcel in) {
return new Worker(in);
}
@Override
成都法语培训
public Worker[] newArray(int size) {
return new Worker[size];
}
};
那么在 Kotlin 中是什么样的呢，我们可以先看看 Android Studio ⽣成的实现：
companion object CREATOR : Parcelable.Creator<Worker> {
override fun createFromParcel(parcel: Parcel): Worker {
return Worker(parcel)
rimmel
}
override fun newArray(size: Int): Array<Worker?> {
return arrayOfNulls(size)
}
}
在 Kotlin 中，使⽤命名的 companion object 确实可以⽣成⼀个对应名字的静态字段，并且它是公有的，会随着类的加载⽽被创建。但是⼀个类⾥只能有⼀个伴⽣对象，这个实现把伴⽣对象给占据了。虽然并没有什么影响的样⼦，但是看着总是不舒服。
面子英文通过 Kotlin 提供的注解，我们可以让 Kotlin 编译器把它作为⼀个字段进⾏处理，那我们可以在 companion object ⾥定义⼀个CREATOR ，然后给它加上 @JvmField 注解。
companion object {
@JvmField val CREATOR = object : Parcelable.Creator<Worker> {
override fun createFromParcel(parcel: Parcel): Worker {
return Worker(parcel)
}
override fun newArray(size: Int): Array<Worker?> {
return arrayOfNulls(size)
}
}
}
这样做有什么好处呢？ CREATOR 不再占据整个 companion object ，⽽是只是作为 companion object 中的⼀个字段，代码⼲净了很多。
此外， Kotlin 还对 inline ⽅法提供了 reified 泛型机制，这种泛型会被编译器直接具体化⽽不会像 Java 泛型⼀样会被运⾏时擦除。如果不需要太考虑效率，我们可以定义⼀个这样的⽅法。
inline fun <reified T : Parcelable> parcelableCreatorOf(): Parcelable.Creator<T> = object : Parcelable.Creator<T> {
override fun newArray(size: Int): Array<T?> = arrayOfNulls(size)
override fun createFromParcel(source: Parcel?): T =
T::DeclaredConstructor(Parcel::class.java).newInstance(source)
}
在每⼀个 Parcelable 实现类中就只需要⼀⾏代码了。
companion object {
@JvmField val CREATOR = parcelableCreatorOf<Worker>()
}
End
最后，再来看看我们的 Parcelable 实现类。
data class Worker(
var id: Int,
gossip girl结局var name: String,
var tasks: MutableList<Int>
) : Parcelable {
constructor(parcel: Parcel) : this(
override fun writeToParcel(parcel: Parcel, flags: Int) {
parcel.writeInt(id)
parcel.writeString(name)
parcel.writeList(tasks)
}
override fun describeContents(): Int = 0
companion object {
@JvmField val CREATOR = parcelableCreatorOf<Worker>()
}
}
本⽂中的关键代码，我已经封装成了⼀个⼯具类，添加依赖即可使⽤ ->
Kotlin使⽤parcelable出现：BadParcelableException: Parcelable protocol requires a
在Kotlin编写代码过程中，需要⽤到parcelable来进⾏传值，按照以前的写法，进⾏序列化：
class PayTypeInfo : Parcelable{
var payMethodId: String? = null//⽀付⽅式ID
var payMethodName: String? = null//⽀付⽅式名称
override fun writeToParcel(dest: Parcel, flags: Int) {
dest.writeString(payMethodId)
dest.writeString(payMethodName)
}
override fun describeContents(): Int {
return 0
}
companion object {
val CREATOR: Parcelable.Creator<PayTypeInfo> = object : Parcelable.Creator<PayTypeInfo> {
override fun createFromParcel(source: Parcel): PayTypeInfo {
val payTypeInfo = PayTypeInfo()
payTypeInfo.payMethodId = adString()
payTypeInfo.payMethodName = adString()
return payTypeInfo
}
override fun newArray(size: Int): Array<PayTypeInfo> {
return newArray(size)
}
}
}
}
这样序列化的实体类就写完了，然后进⾏传值articlea
val bundle = Bundle()
val typeList = ArrayList<PayTypeInfo>()
自我介绍英语作文
bundle.putParcelableArrayList("payType", typeList)
接受数据时：
val bundle = as
val payTypeList = ParcelableArrayList<PayTypeInfo>("payType")
运⾏程序，出现错误，错误代码为：BadParcelableException: Parcelable protocol requires a
经过查找资料，找到了解决办法，只需要在代码CREATOR前⾯添加@JvmField即可：
@JvmField val CREATOR: Parcelable.Creator<PayTypeInfo> = object : Parcelable.Creator<PayTypeInfo> {
override fun createFromParcel(source: Parcel): PayTypeInfo {
val payTypeInfo = PayTypeInfo()
payTypeInfo.payMethodId = adString()
payTypeInfo.payMethodName = adString()
return payTypeInfo
}
override fun newArray(size: Int): Array<PayTypeInfo> {
return newArray(size)
}
}
在运⾏程序，传值成功
总结
以上就是这篇⽂章的全部内容了，希望本⽂的内容对⼤家的学习或者⼯作具有⼀定的参考学习价值，如果有疑问⼤家可以留⾔交流，谢谢⼤家对的⽀持。
