Kotlin基础教程之类和继承

1. 类的定义

在Kotlin中，用class关键字定义一个类，类名要符合驼峰命名规则。下面是一个示例：

class Animal {
    // 类的属性
    var name: String = ""

    // 类的方法
    fun sleep() {
        println("$name is sleeping.")
    }
}

2. 继承

在Kotlin中，用:实现继承，可以继承一个类或者抽象类。下面是一个继承示例：

// 基类
open class Animal {
    // 类的属性
    var name: String = ""

    // 类的方法
    open fun sleep() {
        println("$name is sleeping.")
    }
}

// 子类
class Cat : Animal() {
    // 子类方法重写基类方法
    override fun sleep() {
        println("$name is sleeping silently.")
    }
}

// 另一个子类
class Dog : Animal() {
    // 子类方法重写基类方法
    override fun sleep() {
        println("$name is sleeping beside the owner.")
    }
}

在上面的示例中，Cat和Dog都继承自Animal，并重写了sleep方法。

3. 类的初始化

Kotlin中可以使用主构造函数和次构造函数来初始化类。主构造函数使用关键字constructor定义，次构造函数使用constructor关键字和this关键字定义。下面是一个示例：

class Person constructor(firstName:String, lastName:String) {
    // 属性初始化方式一
    val fullName = "$firstName $lastName"

    // 属性初始化方式二
    var age: Int

    init {
        age = 0
    }

    // 次构造函数
    constructor(firstName:String, lastName:String, age:Int) : this(firstName, lastName) {
        this.age = age
    }
}

在上面的示例中，主构造函数使用constructor(firstName:String, lastName:String)定义，初始化属性fullName，age属性使用init块初始化；次构造函数使用constructor(firstName:String, lastName:String, age:Int) : this(firstName, lastName)定义，使用this关键字代表调用主构造函数。

4. 对象表达式和对象声明

1. 对象表达式：可以用来创建一个临时的类的实例对象，用object关键字定义：

val animal = object {
    var name: String = ""
    fun sleep() {
        println("$name is sleeping.")
    }
}

animal.name = "Tom"
animal.sleep()

在上面的示例中，使用object定义一个没有类名的类的实例对象，使用name和sleep属性来定义和操作对象。

1. 对象声明：可以用来创建一个单例对象，用object关键字定义：

object Singleton {
    init {
        println("Singleton object initialized.")
    }

    fun doSomething() {
        println("Singleton do something.")
    }
}

在上面的示例中，使用object定义了一个名为Singleton的单例对象，可以使用Singleton.doSomething()调用对象中的方法。首次访问时，对象初始化将被执行，且仅会执行一次。

示例1：猫和动物园

下面是一个结合了上面的类的定义、继承和初始化知识的示例：

open class Animal(val name: String) {
    open fun sleep() {
        println("$name is sleeping.")
    }
}

class Cat(name:String, val age:Int) : Animal(name) {
    override fun sleep() {
        println("$name is sleeping silently.")
    }

    fun meow() {
        println("$name is meowing.")
    }
}

fun main(args: Array<String>) {
    val cat1 = Cat("Tom", 2)
    cat1.sleep()
    cat1.meow()

    val cat2 = Cat("Lulu", 1)
    cat2.sleep()

    val zoo = object {
        val animals = listOf(cat1, cat2)
        fun animalSleep() {
            animals.forEach { it.sleep() }
        }
    }

    zoo.animalSleep()
}

在上面的示例中，定义Animal类，Cat继承Animal并重写了sleep方法和定义了自己的方法meow，定义zoo为动物园对象，其包含了动物们的信息和animalSleep方法可用来让动物们睡觉。在main方法中，定义了两个Cat的实例对象，然后将它们放在zoo内调用animalSleep方法。

示例2：单例对象计数

下面是一个结合了上面的对象声明知识的示例：

object SingletonCounter {
    private var count: Int = 0

    init {
        println("Singleton object initialized.")
    }

    fun getCount(): Int {
        return count
    }

    fun incrementCount() {
        count++
    }
}

fun main(args: Array<String>) {
    println("Count: ${SingletonCounter.getCount()}")
    SingletonCounter.incrementCount()
    println("Count: ${SingletonCounter.getCount()}")
    SingletonCounter.incrementCount()
    println("Count: ${SingletonCounter.getCount()}")
}

在上面的示例中，定义了一个对象声明SingletonCounter，其包含计数器属性count和用于读写count的函数，main方法中使用SingletonCounter对象实现计数器的功能，控制台打印出了计数器的值。