Kotlin 类

什么是类

在 Kotlin 中，变量类型都是类，像我们常见的Int、String等等，都是类。

为什么要分类？其实原因很多，就像有些时候，只要提起猫，你的脑海中立马浮现出猫捉老鼠、猫吃鱼······至少不是汪汪叫的猫。有了猫这一类别，我们就能很容易地将其与它所拥有的行为、特点联系起来。还有些情况，像是一个巨大的图书馆，如果各种书都没有一定规律地堆放在一起，我们很难去找到我们想要的书。

在 Kotlin 中，使用class去定义一个类：

class 类名 { 属性/方法 }

我们能够像描述一只猫一样去定义一个类，这样就足够了：

class Cat

类名首字母需要大写，而一般情况下变量和函数采用驼峰命名（首个单词小写，后面如果有其他单词，首字母大写）：

class MyClass

val myVariable = "变量"

fun myFun() {}

类的属性

属性，例如一只猫是什么颜色的？有多高？喜欢吃什么？就是用于描述类状态的一系列变量。直接将其定义于类中即可：

class Cat {
	val name: String = "小橘"
}

类的方法（行为）

方法，或者叫函数，可定义该类所具有的行为：

class Fish

class Cat {
	fun eat(fish: Fish) {}
}

构造函数

构造函数可以让我们在初始化类对象（将猫这一类具体到某一只猫上）时传入参数，或者直接在构造函数中声明类的属性。

主构造

可以在类名后加一个小括号，并写入对应的参数、属性。这与函数类似：

class 类名([[val|var] 属性名: 类型], [参数名: 类型], ...) { 属性/方法 }

我们可以给猫定义一些属性：

class Cat(var name: String, val color: String)

也可以给它们设置默认值：

class Cat(var name: String, val color: String = "橘色")

我们也可以使用lateinit var将其定义于类中，并使用init和参数将其初始化，constructor可省：

class Cat constructor(var name: String, colorParam: String) {
	lateinit var color: String

	init {
		color = colorParam
	}
}

或者是直接将color赋值为colorParam：

class Cat(var name: String, colorParam: String) {
	val color = colorParam
}

Note：Kotlin 中可以使用lateinit关键字修饰可变变量，这样变量就可以暂时不用赋值。但是在使用时如果还未赋值，就会抛出异常：kotlin.UninitializedPropertyAccessException。lateinit不支持基本类型（Primitive Types，包含数字、字符）和可空类型。

// 这些是不被允许的
// 数字
lateinit var byte: Byte
lateinit var short: Short
lateinit var int: Int
lateinit var long: Long
lateinit var float: Float
lateinit var double: Double
lateinit var boolean: Boolean
// 字符
lateinit var char: Char
// 任何可空类型
lateinit var nullableAny: Any?

次构造

很多时候主构造并不能满足我们的需求，我们可以再定义次构造。次构造使用constructor声明，必须基于主构造，使用this()调用主构造。

class Cat(val name: String, val color: String) {
    constructor(name: String): this(name, "橘色") {}
}

fun main() {
    val myCat = Cat("小橘")
    println("${myCat.name} 是 ${myCat.color} 的")
}

小橘 是 橘色 的

类的实例化（对象）

可以像调用函数一样调用它，生成Cat对象，使用.即可访问对象的属性或方法（行为）：

class Cat(val name: String, val color: String)

fun main() {
	val myCat = Cat("小橘", "橘色")
	print("${myCat.name} 是 ${myCat.color} 的")
}

小橘 是 橘色 的

伴生对象

对象实例化后，每个对象都拥有自己的属性值（例如两个Cat对象可能有不同的color）。如果我们要声明一些该类所有对象都共有的，并且是不受对象影响的属性或方法，可以借助companion object来定义：

class Cat {
    companion object {
        const val FAMILY = "猫科"
    }
}

Note：在定义不可变的顶层变量（文件中的最外面）或对象变量（object）时，如果该变量为基本类型（Primitive Types，包含数字、字符）或String，则建议使用const关键字修饰。特别地，如果该变量为对象变量，IDEA会提示需要将变量名改为全大写：

object Object {
	const val NAME = "一个单词直接全大写"
	const val A_MULTI_WORDS_NAME = "多个单词需要加下划线分割"
}

我们可以通过以下两种方式来访问该属性（通常采用Cat.FAMILY）：

fun main() {
    println(Cat.FAMILY)
    print(Cat.Companion.FAMILY)
}

猫科
猫科

本质上是定义一个对象object（默认名称为Companion），我们可以指定该对象的名称，这并不影响我们使用它：

class Cat {
    companion object CatCompanion {
        const val FAMILY = "猫科"
    }
}


fun main() {
    println(Cat.CatCompanion.FAMILY)
    print(Cat.FAMILY)
}

猫科
猫科

甚至可以继承（Kotlin 中使用: 被继承类()表示继承，这将在后续文章提到）：

class Cat {
    companion object CatCompanion: Base() {
        const val FAMILY = "猫科"
    }
}


open class Base

Kotlin 并不支持使用对象来访问伴生对象的属性或方法：

fun main() {
    val cat = Cat()
    // cat.FAMILY 这是错误的
}

this

Kotlin 类中可以使用this指定类中的属性或方法，这在很多时候是可以省略的。如果有时候出现混淆，可以通过使用this避免这一情况：

class Cat(var name: String) {
    fun changeName(name: String) {
        // 函数参数的 name 与 Cat 的 name 并不是同一个
        // 使用 this.name 指定 Cat 的 name
        // 如果不指定，默认会访问到最小范围内的 name
        // 这里的最小范围是函数作用域中的 name
        this.name = name
    }
}

伴生对象中的this只能访问到伴生对象的属性或变量，因为它是独立于类对象的：

class Cat(var name: String) {
    companion object {
        const val FAMILY = "猫科"

        fun test() {
            this.FAMILY
            // this.name 错误的
        }
    }
}

在扩展函数中使用：

class Cat(var name: String)

fun Cat.speck() {
    print("${this.name}: 喵喵喵")
}

fun main() {
    Cat("小橘").speck()
}

小橘: 喵喵喵