Kotlin基础教程-类与继承

Classes and Inheritance

类

关键字:class

class Doctorq {}

构造方法

一个类有一个主构造器，多个副构造器。主构造器是类头部的一部分，紧跟类名后面。

主构造器

class Person constructor(firstName: String) {
}

如果主构造器没有任何注解和访问修饰符，可以省略关键字constructor：

class Person(firstName: String) {
}

主构造器不能包含任何代码，如果需要在主构造器中执行代码，可以使用init关键字定义初始化代码：

class Customer(name: String) {
    init {
        logger.info("Customer initialized with value ${name}")
    }
}

其中可以在初始化代码块中使用主构造器中传入的参数，也可以在类body体中使用该参数：

class Customer(name: String) {
    val customerKey = name.toUpperCase()
}

定义类属性的简洁方式如下

class Person(val firstName: String, val lastName: String, var age: Int) {

}

主构造中的参数可以是var也可以是val。
如果主构造器含有注解或者访问修饰符，则必须加constructor:

class Customer public @Inject constructor(name: String) { ... }

副构造器

副构造器在类内部，用constructor定义：

class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    }
}

如果既有主构造器，也有副构造器，那么副构造器需要委托给主构造器，同一个类中访问其他构造器，需要使用关键字this：

class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

如果一个非抽象类没有定义任何构造器，会自动生成一个无参数的主构造器，可见性为public,如果你不想构造器可见，你可以显式定义个主构造器，访问修饰符用private：

class DontCreateMe private constructor () {
}

提示：如果主构造器的参数都有默认值，JVM编译器就会默认生成一个无参数的构造器，这会让创建对象变的很方便，无需传入参数。

class Customer(val customerName: String = "")

创建类实例

kotlin中创建实例不需要使用new关键字：

val invoice = Invoice()

val customer = Customer("Joe Smith")

类成员

• 构造器，初始化代码块
• 函数
• 属性
• 嵌套类和内部类
• object定义

继承

kotlin中的所有类都继承一个父类Any，无需声明自动继承。

Any除了含有equals()，hashCode(),toString()三个函数外，就没有任何其他成员了。

如果想显式定义个超类，在类的头部用冒号(:)+父类名：

open class Base(p: Int)

class Derived(p: Int) : Base(p)

open关键字类似java中的final的反义词，而且默认所有的类都是final的

如果子类含有主构造器，基础类也必须在此处进行初始化，将子类的主构造器中的参数传递给父类的主构造器。

如果子类没有主构造器，那么每个副构造器都要使用super关键字初始化父类，也可以调用已经初始化父类的其他的副构造器。

class MyView : View {
    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}

重写

关键字override

方法重写

open class Base {
    open fun v() {}
    fun nv() {}
}
class Derived() : Base() {
    override fun v() {}
}

上面子类重写了父类的v函数，必须使用override关键字注解，否则编译器就会报错。但是如果没有用open定义的父类函数，不可以重写，默认是final是无法被重写的。

在final定义的类中，open方法也是无法被重写的。

如果你不想被继承者重写，你也可以加上final标识

open class AnotherDerived() : Base() {
    final override fun v() {}
}

属性重写

open class Foo {
    open val x: Int get { ... }
}

class Bar1 : Foo() {
    override val x: Int = ...
}

上面的代码有点神奇的地方是val定义的属性也能被重写，神奇啊。实际上重写val的调用的是getter方法，重写var调用的是setter方法。

你也可以使用override标识主构造器中的参数。

重写规则

如果继承多个接口，而且接口中的成员函数和父类的成员函数一样，你必须重写接口中的成员函数，为了区分重写的是哪个接口或者父类的函数，需要用super<类名/接口名>，如下：

open class A {
    open fun f() { print("A") }
    fun a() { print("a") }
}

interface B {
    fun f() { print("B") } // interface members are 'open' by default
    fun b() { print("b") }
}

class C() : A(), B {
    // The compiler requires f() to be overridden:
    override fun f() {
        super<A>.f() // call to A.f()
        super<B>.f() // call to B.f()
    }
}

抽象类

含有抽象成员的类成为抽象类
抽象类中抽象成员没有具体实现，我们还可以用抽象函数来重写一个非抽象的，open的父类成员。

open class Base {
    open fun f() {}
}

abstract class Derived : Base() {
    override abstract fun f()
}

伴生对象

kotlin中没有静态成员变量的概念，如果你不想通过类实例访问某个成员，可以使用伴生对象