Question

在使用koltin的Android中，其基类Filters是Parceable。它很好用。现在需要有一个派生类DerivedFilter，该类重写getIGenericHandler()的功能。

如果未实现自己的可分割部分，则覆盖功能将反序列化。

但是在实现其可打包部分时，出现了编译器错误：

处的"Primary constructor call expected"

   constructor(parcel: Parcel) : super(parcel)

为什么不能调用super(parcel)？

尝试了一些，但没有一个起作用（在代码中显示注释）。

如何从parcelable派生一个类并实现其自己的parceable部分？

尝试与this类似，但不起作用。

    open class Filters() : Parcelable {

        var streamType: String = ""
        // simplified it has map, list members

        constructor(streamTypeValue: String): this() {
           init(streamTypeValue)
        }

        constructor(parcel: Parcel) : this() {

            val streamTypeValue: String = parcel.readString()
            // simplified, it has map, list to build from the parcel

            init(streamTypeValue)
        }

        protected fun init(streamType: String) {

            this.streamType = streamType
            // simplified, it will pass in map, list to set to the corresponding members

        }

        open fun <T>getIGenericHandler(): IGenericHandler<IData<T>>? {
            return null
        }

        override fun describeContents(): Int {
            return 0
        }

        override fun writeToParcel(dest: Parcel, flags: Int) {

            dest.writeString(streamType)

        }

        companion object {
            @JvmField val CREATOR: Parcelable.Creator<Filters> = object : Parcelable.Creator<Filters> {
                override fun createFromParcel(parcel: Parcel): Filters {
                    return Filters(parcel)
                }

                override fun newArray(size: Int): Array<Filters?> {
                    return arrayOfNulls(size)
                }
            }
        }



    }


    class DerivedFilter(streamType: String)
        : Filters (streamType){


        override fun <T>getIGenericHandler(): IGenericHandler<IData<T>>? {

            val h = GenericHandler(null, null)
            return h as IGenericDataHandler<IData<T>>
        }


        private constructor(parcel: Parcel) : super(parcel) {  //<=== got compiler error: "Primary constructor call expected"

        }

        /**
         * private constructor(parcel: Parcel) : this() {}  //<=== got compiler error:

        //None of the following functions can be called with the arguments supplied:
        //private constructor DerivedFilter(parcel: Parcel) defined in com.test.DerivedFilter
        //public constructor DerivedFilter(streamType: String)

         // if add
         constructor(): this(){}
         // got error: There's a cycle in the delegate calls chain
        */
        override fun writeToParcel(out: Parcel, flags: Int) {
            super.writeToParcel(out, flags)
        }

        companion object {
            @JvmField
            val CREATOR: Parcelable.Creator<DerivedFilter> = object : Parcelable.Creator<DerivedFilter> {
                override fun createFromParcel(parcel: Parcel): DerivedFilter {
                    return DerivedFilter(parcel)
                }

                override fun newArray(size: Int): Array<DerivedFilter?> {
                    return arrayOfNulls(size)
                }
            }
        }

        override fun describeContents(): Int {
            return 0
        }

    }

Answer 1

请考虑使用@Parcelize批注而不是自己实现Parcelable接口。使用@Parcelize，将自动生成一个Parcelable实现。

Answer 2

您可以使用@Parcelize annotation来保存许多代码以实现Parcelable。

设置Kotlin Android扩展

我的gradle的配置如下：

Build.gradle //应用

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions' // Add this


androidExtensions {
  experimental = true // Add this
}

dependencies {
  implementation fileTree(dir: 'libs', include: ['*.jar'])

  // ------------------------- KOTLIN ------------------------- //
  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.3.11"

 ... // Other Dependencies

} 


@Parcelize
class Filters(var streamType: String = "") : Parcelable

Answer 3

这一个可行，也许还有更好的一个？

    class DerivedFilter()
        : Filters (){


        override fun <T>getIGenericHandler(): IGenericHandler<IData<T>>? {

            val h = GenericHandler(null, null)
            return h as IGenericDataHandler<IData<T>>
        }

        constructor(streamType: String)
                : this () {

            init(streamType)

        }

        // calling into base::init(parcel)
        private constructor(parcel: Parcel) : this() {
            init(parcel)
        }

        override fun writeToParcel(out: Parcel, flags: Int) {
            super.writeToParcel(out, flags)
        }

        companion object {
            @JvmField
            val CREATOR: Parcelable.Creator<DerivedFilter> = object : Parcelable.Creator<DerivedFilter> {
                override fun createFromParcel(parcel: Parcel): DerivedFilter {
                    return DerivedFilter(parcel)
                }

                override fun newArray(size: Int): Array<DerivedFilter?> {
                    return arrayOfNulls(size)
                }
            }
        }

        override fun describeContents(): Int {
            return 0
        }

    }

如何从一个可诉的类中派生

3 个答案: