Kotlin学习笔记2_面向对象

1. 类的定义

Kotlin中用class关键字定义一个类。

• 在Kotlin中，一个类可以有primary构造方法， 以及一个或多个secondary构造方法
• primary 构造方法是类头（class header）的一部分，它位于类名后面，可以拥有若干参数
• 如果 primary构造方法没有任何注解或是可见性关键字修饰， 那么constructor关键字可以省略
• 如果构造方法有注解或者可见性修饰符，那么constructor关键字是不能省略的，并且它位于修饰符后面

//定义一个空类
class EmptyClass
//在Kotlin中，一个类可以有primary构造方法， 以及一个或多个secondary构造方法
//primary 构造方法是类头（class header）的一部分，它位于类名后面，可以拥有若干参数
//如果 primary构造方法没有任何注解或是可见性关键字修饰， 那么constructor关键字可以省略
class MyClass constructor(username: String) {

    private var username: String = username.toUpperCase()

    private var age: Int = 20

    //初始化代码块，给成员变量赋初值
    init {
        this.username = username
        this.age = 30
        println("primary constructor: username $username , age : $age")
    }

    /**
     * 定义和方法体放在一起了
     * 对于secondary构造方法的调用，一定会直接或间接的调用primary构造方法
     */
    constructor(username: String, age: Int) : this(username) {
        this.username = username
        this.age = age
        println("second constructor: username: $username, age: $age")
    }
}

fun main(args: Array<String>) {
    //实例化一个对象，注意没有new关键字
    MyClass("zhangsan")
    MyClass("lisi", 50)

}

输出结果：

primary constructor: username zhangsan , age : 30
primary constructor: username lisi , age : 30
second constructor: username: lisi, age: 50

可以看出，通过secondary构造方法实例化对象时，primary构造方法会首先得到调用，其次调用secondary构造方法。

声明一个类的属性可以直接在primary构造方法参数中定义，更为简洁：

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

    fun printInfo() {
        println("Person info: $firstName, $age, $lastName")
    }
}

在JVM上，如果一个类的primary构造方法的所有参数都包含默认值，那么Kotlin编译器就会自动生成一个默认的不带参数的构造方法，该方法会使用这些参数的默认值，目的在于跟spring等框架更好的集成。如下程序可以正常运行:

class Person(private val firstName: String = "Deng",
             private val age: Int = 25,
             private val lastName: String = "Changjian") {

    fun printInfo() {
        println("Person info: $firstName, $age, $lastName")
    }
}
fun main(args: Array<String>) {
    var person = Person() //默认无参的构造方法
    person.printInfo()
}

2. 类的继承

• 所有的类默认都是final的，无法被继承。如果要想被继承需要用open关键字修饰。
• 方法被重写，必须添加override修饰符，并且父类的对应方法也必须被open修饰。

代码示例：

/**
 * 一个类要想被继承，必须被open关键字修饰
 */
open class Fruit {

    open val name: String get() = "Fruit"

    //被重写的方法加上open关键字
    open fun name() {
        println(name)
    }

    fun expirationDate() {
        println("1 month before")
    }
}

注意继承这里的()不能省略
open class Apple constructor() : Fruit() {

    private var color: String

    init {
        this.color = "default color"
    }

    constructor(color: String) : this() {
        this.color = color
    }

    //方法被重写，必须添加override修饰符，并且父类的对应方法也必须被open修饰
    //已经被重写的方法可以继续被子类重写
    //如果该方法不想被子类重写，可以添加final关键字修饰
    override fun name() {
        println("$name and Apple")
    }

    open fun getColor() {
        println("color is $color")
    }
}

//注意继承这里的()不能省略,在构造方法调用时会调用父类的构造方法
class RedApple : Apple("red color") {

    //关于属性重写：
    //1. val 可以 override val
    //2. var 可以 override var
    //3. val 无法 override var
    // 本质上，val相当于get方法，var 相当于get 和 set 方法
    override val name: String get() = super.name + " and RedApple"

    override fun name() {
        println(name)
    }
}

fun main(args: Array<String>) {
    var apple = Apple()
    apple.name()  //->  color is default color
    apple.getColor()

    val redApple = RedApple()
    redApple.name()
    redApple.getColor()  //-> color is red color

}

3. 接口实现

用 interface 关键字定义一个接口。
接口可以定义抽象方法，也可以定义接口实现。

interface A {

    //与JDK8 类似，接口可以定义接口实现
    fun method() {
        println("A")
    }

    fun method1()
}

open class B {
    open fun method() {
        println("B")
    }
}

class C : A, B() {
    override fun method1() {
        println("abstract method1 implement ")
    }

    override fun method() {
        //调用接口A 的方法
        super<A>.method()
        //调用接口A 的方法
        super<B>.method()
    }
}

fun main(args: Array<String>) {
    var c = C()
    c.method()
    c.method1()
}

super.method()， 该语法可以指定具体调用哪个接口的方法。