如何从一个可以分类的类中派生出来

Question

在Android中使用koltin，有一个基类Filters，这是一个Parceable。它工作得很好。现在需要有一个派生类DerivedFilter，它覆盖了getIGenericHandler()的功能。

如果不实现自己的parceable部分，则将反序列化函数反序列化。

但是当实现它的parcelable部分时，它得到了编译器错误："Primary constructor call expected" at

   constructor(parcel: Parcel) : super(parcel)

为什么它不能称为super(parcel)？

尝试了一些非他们工作（在代码中显示注释）。

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

尝试与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扩展程序

1. 我的gradle的配置如下：

Build.gradle // app

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
        }

    }