Kotlin编程之父类和继承父类

川长思鸟来 2022-06-15 10:20 287阅读 0赞

**Kotlin编程相关知识点介绍**：

*  [Kotlin编程之使用Intellij IED和了解源文件（.kt）][Kotlin_Intellij IED_.kt]
 *  [Kotlin编程之类的介绍和使用][Kotlin]
 *  [Kotlin编程之类的属性][Kotlin 1]
 *  [Kotlin编程之方法][Kotlin 2]

--------------------

### **1. 默认继承Any超类**： ###

在Kotlin编程中，Any类是超类.

public open class Any {
    
        public open operator fun equals(other: Any?): Boolean
    
        public open fun hashCode(): Int
    
        /**
         * 返回对象的字符串形式.
         */
        public open fun toString(): String
    }

通常我们声明一个类：

class Test{ //隐式继承Any
    
    }

有没有感觉和Java很像呀，在Java中每个类都是默认继承Object的哦。

### **2. 继承自定义的父类**： ###

--------------------

在一个源文件中，编写以下代码：

package com.xingen.kotlin
    
    fun main(str: Array<String>) {
    
        var instance: BaseTest<String>
        instance = Test<String>("本类是")
        //父类对象调用子类对象的方法
        instance.test()
    
        instance.closeTest()
    
    }
    
    /** * 继承自定义的BaseTest父类 * 覆盖属性t * 复写test（） */
    class Test<T> constructor(override var t: T) : BaseTest<T>(t) {
        /** * 复写父类中的方法 */
        override fun test() {
            println("${t} Test子类 ")
        }
    }
    /** * open关键字： * 1. 修饰父类:open class BaseTest * 2. 主构造方法中声明的属性:open val t: T * 3. 修饰方法:open fun test(){ } * * 默认情况下，Kotlin中的类，属性，方法都是被final修饰的，不允许继承或者覆盖重写。 */
    open class BaseTest<T>( open val t: T) {
        open fun test() {
            println("${t} BaseTest父类 ")
        }
       fun closeTest(){
            println("父类中不能被子类重新复写的方法")
        }
    }

结果输出：

本类是 Test子类 
    父类中不能被子类重新复写的方法

**可知**：

*  默认情况下，Kotlin中的类都是final标注（可省略），这意味着不允许被继承。添加`open`标注才可以使父类被子类继承。
 *  默认情况下，Kotlin中类的属性和方法都是被final标注（可省略)的，不允许被子类重写覆盖。添加`open`标注后的属性或者方法才能被重写覆盖，但是都必须添加`override`修饰。
 *  继承父类：在子类的类头后面 加上`:`和父类。实际上这里有三种表现形式 ：
    
     *  当父类无构造函数时候，表现为`:父类名()` ;
     *  当父类有主构造方法时候，表现形式为`:父类名(传递的参数)`
     *  当父类中只有二级构造函数时候，表现形式为`：父类名`;
 *  若是父类有主构造方法，子类在继承父类时候，父类的构造函数中的参数必需立即初始化，也就是传递参数过去。例如：`class Test<T> constructor(override var t: T) : BaseTest<T>(t)`
 *  若是父类中无主构造方法，有二级构造方法，在子类继承父类的时候，在子类的二级构造方法中调用`super()`进行初始化。
    
        class Test<T> : BaseTest<T>{
        
          var t :T?=null
        
          constructor(t:T)  :super(t) {
              this.t=t
          }
          /** * 复写父类中的方法 */
          override fun test() {
               println("$t Test子类 ")
               super.test()
          }
        }
        /** * 自定义父类 */
        open class BaseTest<T> {
          private  var  t:T?=null
          constructor(t:T){
              this.t=t
          }
          open fun test() {
             println("$t BaseTest父类 ")
          }
         fun closeTest(){
            println("父类中不能被子类重新复写的方法")
         }
        }

[Kotlin_Intellij IED_.kt]: http://blog.csdn.net/hexingen/article/details/72820445
[Kotlin]: http://blog.csdn.net/hexingen/article/details/72820822
[Kotlin 1]: http://blog.csdn.net/hexingen/article/details/72820984
[Kotlin 2]: http://blog.csdn.net/hexingen/article/details/72821113