【Kotlin精简】第3章 类与接口
1 简介
Kotlin类的声明和Java没有什么区别，Kotlin中，类的声明也使用class关键字，如果只是声明一个空类，Kotlin和Java没有任何区别，不过定义类的其他成员会有一些区别。实例化类不用写new，类被继承或者重写必须加上 open 关键字，构造器可以写在类后面。类的基本结构：构造函数，属性，方法。
Kotlin接口和Java的抽象类基本类似，可以有抽象方法，也可以有方法体。但override作为关键字使用，而不是注解。
2 类的构造器
构造器也叫构造方法，是类创建的必要元素。构造函数可以用关键词constructor声明，
在Kotlin中，类允许定义一个主构造器，和若干个第二构造器。
主构造器是类头的一部分，紧跟在类名的后面，参数是可选的。
2.1 主构造器
如下代码定义了一个类，并指定了一个主构造器。
class Person constructor(name: String) {
}
// 如果主构造器没有任何注解，任何修饰，constructor可以省略
class Person(name: String) {
}
// 如果是主构造器，需要在init代码块中进行初始化主构造器
// 注：主构造器中的参数不仅可以在init代码块中使用，还可以对类的属性进行初始化。
// var和val也可以修饰主构造器参数:
// 如果使用var，表示参数对于构造器来说是变量，在构造器内部可以对其进行操作和改变(在主构造器中修改值后，不会把修改后的值传到对象外面)
// 如果使用val，表示该参数是常量，在构造器中不能修改它的值。
class Person(var name: String) {
val myName = name
init {
println(name)
}
}
主构造函数不能包含代码块，它只能作为一个纯粹的参数列表声明，如果我们需要初始化逻辑，用关键词init可以声明一个局部作用域，它会在实例化时被调用。事实上所有init block都会被编译为主构造函数的一部分，然后按照声明顺序执行
2.2 第二构造器
Kotlin的类中，除了可以声明一个主构造器之外，还可以声明若干个第二构造器，第二构造器必须在类中声明，前面必须加constructor关键字。
class Person(var name: String) {
init {
name = "hello"+ name
println(name)
}
constructor(age: Int) : this("js") {
println(name + " " + age)
}
constructor(sex : Byte) :this(20){
println(name +" "+ sex)
}
}
注意：
- 主构造器中可以使用var和val修饰参数，但第二构造器中不能使用，也就意味着
第二构造器中的参数都是只读的。 - 由于
nit block本质上是主构造函数的一部分，而次构造函数需要委托主构造函数，所以所有的init block要优先于次构造函数执行， 类级别的属性在init block之前，主构造函数后执行。
2.3 单例模式
Kotlin 中的单例模式，需要理解一个特殊的类型，这个类型叫做object，这个object可不是Java中所有类的父类（Object），这个object 就是创建单例用的，我们都知道，Java中单例有懒汉式、饿汉式，双重检查锁等几种单例变种，但是在Kotlin中除了可以使用这几种，还有object的单例实现方式，实际上该方式也是饿汉式的实现，只是Kotlin的语法糖使写法不一样而已。
2.3.1 饿汉式
object Singleton {
}
2.3.2 懒汉式
Kotlin的写法比较多，可以直接从java翻译，还有一种写法就有点复杂了，私有构造函数，我们也用到了他的get()方法。注意：companion object 修饰为伴生对象,伴生对象在类中只能存在一个，类似于java中的静态方法 Java 中使用类访问静态成员，静态方法。
class Singleton2 private constructor(){
companion object {
private var singleton2 : Singleton2? = null
get() {
if (field == null)
field = Singleton2()
return field;
}
fun get() : Singleton2? {
return singleton2
}
}
}
class Singleton3 private constructor(){
companion object {
val Instance by lazy(mode = LazyThreadSafetyMode.NONE) {
Singleton3()
}
}
}
2.3.3 线程安全的懒汉式
Kotlin直接声明@Synchronized为同步就行
class Singleton4 private constructor(){
companion object {
private var singleton4 : Singleton4? = null
get() {
if (field == null)
field = Singleton4()
return field;
}
@Synchronized
fun get() : Singleton4? {
return singleton4
}
}
}
2.3.4 线程安全双重校验
LazyThreadSafetyMode.SYNCHRONIZED即锁的意思
class Singleton5 private constructor(){
companion object {
val Instance by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
Singleton5()
}
}
}
2.3.5 静态内部类
class Singleton6 private constructor(){
companion object {
fun getInstance() = SingletonHolder.ins
}
private object SingletonHolder{
var ins = Singleton6()
}
}
由于Kotlin自身语法简洁的优势，写单例模式也就一两行的代码，这里没有深究一些高级用法，比如Lazy，属于Kotlin延迟属性的委托，有兴趣的可以自己研究下。
3 类的属性
Kotlin中类的属性通过基本关键词val, var来声明，可以像Java一样直接声明在类体中，也可以通过语法糖直接写在主构造函数中。如果属性声明了默认值，根据类型推导规则可以省略类型声明
Kotlin中类的属性必须被初始化，或者声明为abstract。初始化有两种方式，一种是添加默认值，一种是延迟初始化，使用后者需要用lateinit修饰属性，表示我希望该属性在运行时动态加载，并且我信任自己的代码不会在它没有初始化之前就使用它（如果这么干，空指针crash）， lateinit 延迟初始化 的属性 , 在使用前可以执行::属性名称.isInitialized检查 , 查看该属性是否进行了初始化操作。
lazy 惰性初始化 的 属性初始化操作 是 提前定义好的 , 在 调用之前 自动进行初始化操作 , 如果不调用 , 则不进行初始化 ;
lateinit 延迟初始化 的 属性初始化操作 , 需要 手动进行初始化 , 如果忘了初始化直接调用就会报错 ;
Kotlin的属性提供了getter/setter语法。一般情况下不需要手动重写get/set方法，下面例子是两种常见的重写case。
const val VERSION = "1.0"
class Person(
val age: Int,
val address: String = "Asia"
) {
var country = "China"
// 惰性初始化，使用的时候自动初始化
val name by lazy { initName() }
private fun initName(): String {
return "Tom"
}
// lateinit延迟初始化
lateinit var phone: String
init{
initPhone()
}
private fun initPhone(){
// isInitialized检测lateinit延迟初始化的属性是否已经初始化
if(!::phone.isInitialized) {
phone = "138****1111"
}
}
// 这里的`field`关键字是字面量的含义，可以粗略理解为它是当前变量在内存中的指针
var size = 1
get() = field
set(value) {
// 提供特殊的过滤逻辑
field = if (value < 10) value else 10
}
private var _number = "000"
var number
// 对外仅仅暴露get方法，这里只是演示，真实情况_number一般用val声明
get() = _number
set(value) {
_number = value
}
}
Kotlin的类还存在编译时常量的概念，用const修饰，和Java的final概念基本一致
4 接口
接口本质上也是类，是特殊的类。Kotlin的接口在Java接口基础上扩充了能力，允许直接实现方法体，也允许声明属性(类似Java的抽象类)。但是需要注意的是接口中的属性要么是abstract的，要么提供了get方法，但是接口的属性不存在backing fields，无法用field关键字获取真实值。
接口可以继承多个接口，多个接口也可以被一个类继承。继承规则和上面的类继承基本一致。
继承多个接口遇到同名方法时，解决冲突方法如下：
interface A {
fun foo() { print("A") }
fun bar()
}
interface B {
fun foo() { print("B") }
fun bar() { print("bar") }
}
class C : A {
override fun bar() { print("bar") }
}
class D : A, B {
override fun foo() {
super<A>.foo()
super<B>.foo()
}
override fun bar() {
super<B>.bar()
}
}
但是事实上，几乎不会有人把两个接口的方法命名相同
Kotlin还支持一种特殊的语法糖，当接口中有且只有一个abstract方法时，可以进行如下简写
fun interface IntPredicate {
fun accept(i: Int): Boolean
}
//传统写法
val isEven = object : IntPredicate {
override fun accept(i: Int): Boolean {
return i % 2 == 0
}
}
//语法糖
val isEven = IntPredicate { it % 2 == 0 }
5 类的继承
Kotlin的继承和Java的继承一样都是单继承，区别在于Kotlin用:来代替了extends，Kotlin中所有类都有一个共同的超类 Any，这对于没有继承其他父类的超类型声明的类是默认超类
class Example // 从 Any 隐式继承
Any 有三个方法：equals()、 hashCode() 与 toString()。因此，为所有 Kotlin 类都定义了这些方法。
默认情况下，Kotlin 类是最终（final）的：它们不能被继承。 要使一个类可继承，请用 open 关键字标记它。
继承需要涉及到一些关键词：
5.1 重写方法
open class Shape {
//父类有一个带有形参的构造器
constructor(name: String?) {
}
//父类有一个带有形参的构造器
constructor() {
}
open fun draw() { /*……*/ }
fun fill() { /*……*/ }
}
open class Circle(name: String?) : Shape(name) {
constructor() : this(null) {//子类次构造器委托调用子类主构造器，间接委托调用父类构造器
}
// 父类和其中的draw()方法都是open修饰，因此可以继承并重写，但需要加override 关键词
// 重写draw()方法后，如果不想被Circle子类再重写，可以加final修饰
final override fun draw() { /*……*/ }
}
重写方法遵循“两同、两小、一大”原则：
- 两同：方法名相同、形参列表相同
- 两小：返回值类型比父类返回值类型小或相等、抛出异常类型比父类小或相等。
- 一大：访问权限比父类大或相等
5.2 重写属性
属性覆盖与方法覆盖类似；在超类中声明然后在派生类中重新声明的属性必须以 override 开头，重写的子类属性的类型必须与父类属性类型兼容（变量类型）。每个声明的属性可以由具有初始化器的属性或者具有 get 方法的属性覆盖。
open class Father {
open var a : Float = 1.1f
protected open var b : Float = 1.1f
protected open val c : Float = 1.1f
}
class Son : Father() {
override var a : Float = 2.2f
// 子类属性访问权限必须大于等于父类类型
public override var b : Float = 2.2f
// 只读属性（val）可被重写成读写属性（var），读写属性（var）不能被重写成只读属性（val）
// 因为一个 val 属性本质上声明了一个 get 方法， 而将其覆盖为 var 只是在子类中额外声明一个 set 方法。
public override var c : Float = 2.2f
}
5.3 强制重写
当子类同时继承多个超类（只能继承一个类，但可以实现多个接口）时，如果超类成员（属性/方法）名称一样时，子类需强制重写该成员。
子类想调用父类该成员（函数与属性），需通过super<父类名>.成员的方式调用。
interface FatherInterfs {
var a: Float
fun method() {
println("执行父接口里面该方法 a的值为：$a")//2.2
}
}
open class Father {
protected open val a: Float = 1.1f
open fun method() {
println("执行父类该方法 $a")//2.2
}
}
class Son : Father(), FatherInterfs {
override var a: Float = 2.2f
override fun method() {
super<FatherInterfs>.method()
super<Father>.method()
println("执行子类该方法 $a")//2.2
println("父接口a的值为 ${super<Father>.a}")//1.1
}
}
在一个内部类中访问外部类的超类，可以通过由外部类名限定的 super 关键字来实现：super@Outer：
class FilledRectangle: Rectangle() {
override fun draw() {
val filler = Filler()
filler.drawAndFill()
}
inner class Filler {
fun fill() { println("Filling") }
fun drawAndFill() {
super@FilledRectangle.draw() // 调用 Rectangle 的 draw() 实现
fill()
println("Drawn a filled rectangle with color ${super@FilledRectangle.borderColor}") // 使用 Rectangle 所实现的 borderColor 的 get()
}
}
}
6 其他
6.1 数据类 Data class
Kotlin新增的关键词data，修饰类名变成数据类。在Java开发中经常需要解析一个json文件到内存中，这时需要写一个Java Bean类，定义好对应的属性和get/set方法，然后用诸如GSON的解析库解析。这里的Java Bean作为数据的容器。Kotlin的数据类就可以替代这一功能。例如
//帐号信息
{
"username": "somebody",
"id": "18239048190234891032",
"basic_info": {
"age": 10,
"level": 2
}
}
//data class
data class User(
val username: String = "unknown",
val id: String = "unknown",
val basicInfo: BasicInfo = BasicInfo()
)
data class BasicInfo(
val age: Int = 0,
var level: Int = 0
)
形如上述例子，数据类基本语法规则有如下几条：
- 主构造函数至少要有一个参数
- 主构造函数中的所有参数必须声明val/var，也就是把它们作为属性而声明
- data class不能用abstract, open, sealed, inner来修饰
如何理解这三条约束，需要考虑data class背后都干了些什么。所有声明在主构造函数中的属性都会自动生成如下方法
equals() hashCode() 用来判断两个对象是否相等
toString() 形如"User(param1 = value1, param2 = value2)"
componentN() 用于解构的语法糖
copy() “拷贝构造函数"
其中第一点需要强调，因为一般意义上我们可以用hashCode来区分两个对象（虽然这并不保险），但data class的这一特性使得下例中的风险很容易发生
因为data class类体中声明的属性不参与hashCode的计算，所以只要主构造函数的参数列表一致，两个对象的hashCode就相等，虽然它们在内存中是独立的两个对象
data class Person(val name: String) {
var age: Int = 0
}
fun main() {
val person1 = Person("John")
val person2 = Person("John")
person1.age = 10
person2.age = 20
println("person1 == person2: ${person1 == person2}")
println("person1 with age ${person1.age}: ${person1}")
println("person2 with age ${person2.age}: ${person2}")
}
//result
person1 == person2: true
person1 with age 10: Person(name=John)
person2 with age 20: Person(name=John)
关于第三点所说的解构语法，则是一种语法糖，在很多语言中都存在，最常见的例子如下
这里的(key,value)就是解构语法糖
val numbersMap = mutableMapOf<String, String>().apply {
this["one"] = "1"
this["two"] = "2"
}
for ((key, value) in numbersMap) {
println(key + ' ' + value)
}
而data class会自动声明componetN方法，也就意味着我们可以对它的对象使用这种语法糖
data class User(val age: Int = 0, val name: String = "someone")
val (age, name) = User(10, "Alice")
关于第四点的拷贝函数，一个简单的例子是，假设某个人的帐号level信息改变了，其他都不变，那么你可以这么写
val someOne = User("Alice", "123345", BasicInfo(10, 2))
val copyOne = someOne.copy(
basicInfo = someOne.basicInfo.copy(
level = 3
)
)
关于数据类最后一点是，kotlin标准库中的Pair和Triple都是data class，所以它们才能使用解构语法
另外，kotlin 1.1后， data class是可以继承自普通类或者接口的，但事实上data class的继承很少使用，暂且不提
6.2 密封类 Sealed Class
Kotlin新增关键字sealed，修饰类名变成密封类。某种意义上，它可以被认为是对枚举类的增强。因为它有以下特点
- 密封类的所有直接子类在编译期就被唯一确定
- 密封类的子类可以拥有多个实例
- 密封类和它的直接子类必须声明在同一个package下
- 密封类本身是abstract的，必须通过子类来实例化
- 密封类的构造器只能是protect或者private
其中第三点关于密封类及子类的位置，一般是把子类作为嵌套类放在密封类内部，也可以把它们拆分成多个文件放在同一个package下。但需要注意，必须是严格的相同package，不能有如下情况
packageA {
sealed class Parent
packageB {
class child: Parent
}
}
//子类放在密封类所在package的子package中也是不合法的
关于密封类的其他4点，其实共同做了一件事情：“保证密封类只有有限的几种已知子类”。这样和枚举类型就非常相似，枚举类型的实例只能是一些基本类型，作为flag使用。而密封类的子类可以包含属性、方法，同时也能作为flag，是枚举类型的增强。
考虑如下的例子。假设我希望根据屏幕的亮度来自适应调整软件主题，可以设计这样一个Theme的工具类，这里的Dark, Normal两个子类就是对主题类型的枚举，同时内部也包含一定逻辑
fun main() {
println(Theme.getThemeByBrightNess(234).toString())
//Theme$Dark@7a07c5b4
}
sealed class Theme {
companion object {
const val NORMAL_MAX_BRIGHTNESS = 1000f
fun getThemeByBrightNess(brightness: Int): Theme = when {
Dark.isThisTheme(brightness) -> Dark
Normal.isThisTheme(brightness) -> Normal
else -> Normal
}
}
abstract fun isThisTheme(brightness: Int): Boolean
object Dark : Theme() {
private val darkBrightRange = (0.1 * NORMAL_MAX_BRIGHTNESS).toInt() .. (0.3 * NORMAL_MAX_BRIGHTNESS).toInt()
override fun isThisTheme(brightness: Int): Boolean = brightness in darkBrightRange
}
object Normal : Theme() {
private val normalBrightRange = (0.3 * NORMAL_MAX_BRIGHTNESS).toInt() .. NORMAL_MAX_BRIGHTNESS.toInt()
override fun isThisTheme(brightness: Int): Boolean = brightness in normalBrightRange
}
}
关于密封类的其他细节，参见官方文档
6.3 嵌套类 Nested class
Kotlin并没有关键字nested，嵌套类形如下例，可以视为外部类的一个成员，通过点操作符调用，常见的例子是Adapter里嵌套ViewHolder的声明
interface OuterInterface {
class InnerClass
interface InnerInterface
}
class OuterClass {
class InnerClass
interface InnerInterface
}
需要注意的是，嵌套类并不持有外部类的引用，把它们嵌套纯粹是符合人类逻辑上的收敛
6.4 内部类 inner class
Kotlin用关键字inner修饰一个嵌套类，被称为内部类。二者唯一的变化就是内部类持有了外部类的引用，可以访问外部类的成员
class Outer {
private val bar: Int = 1
fun foo(): Int{
return 666
}
inner class Inner {
fun foo() = bar
}
}
val demo = Outer().Inner().foo() // 1
很显然的，内部类有两个潜在问题：
- this指针，如果遇到同名方法或属性，需要使用this@receiver的语法指定当前this指向哪一个作用域
- 内部类天然存在循环引用问题，可能会导致内存泄漏
6.5 枚举类 enum class
Kotlin用enum修饰类成为枚举类，最常用的两种case如下。都是作为flag使用，只不过带不带参数
enum class Direction {
NORTH, SOUTH, WEST, EAST
}
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}
但事实上，enum class可以实现接口，自定义方法，来实现很多逻辑，例如
enum class ItemType {
A,
B,
c;
fun getTypeForMob(): String {
return when (this) {
A -> "aa"
B -> "bb"
C -> "cc"
}
}
}
Kotlin官方库还有一些关于枚举类型的工具函数，用来罗列或查询枚举类型的成员，例如
fun main(args: Array<String>) {
//罗列
var directions = Direction.values()
for (d in directions){
println(d)
}
for (direction in enumValues<Direction>()) {
println(direction)
}
//查找
println(Direction.valueOf("WEST")) //创建枚举类对象用这样的方式
val west = enumValueOf<Direction>("WEST")
}
6.6 内联类 value class
在Kotlin1.5之前，内联类使用inline 修饰类名，和内联函数共用一个修饰符。但1.5之后内联类改用value修饰符。之所以有这个改动，需要理解为什么要有内联类。
简单来说，jvm对Kotlin中的基本类型，如String等做了很多优化，比如将其内存分配从堆上分配改为栈上分配，这些优化能大幅提高代码性能。但是我们开发者有时候会对基本类型做一些封装（装饰者模式），装饰后的类就无法享受jvm的优化了。鱼与熊掌不可兼得
作为成熟的开发者，我们当然选择全部都要。使用如下的内联类语法即可
value class Password(private val s: String)
Kotlin为了实现这一功能，对内联类做了很多限制，主要的几点如下
有且仅有一个包含单个基本类型参数的构造器
内联类可以有成员和方法，但没有字面量（也就是在堆中无法分配内存），只能对构造器中的参数做一些简单处理
内联类可以实现接口，但不能继承其他类，也不能被其他类继承
在某种意义上，内联类和类型别名有些相似，它们之间的核心区别在于内联类声明了一个新的类型，不能与基本类型互相赋值，而类型别名可以
6.7 对象表达式 object expression
Kotlin用object关键字声明一个对象表达式，这个说法可能有些奇怪，但如果改成匿名内部类就觉得非常熟悉了。object就是对匿名内部类的优化，结合Kotlin的lambda语法糖，可以让代码写得极度简洁
最通常的写法如下
window.addMouseListener(object : MouseAdapter() {
override fun mouseClicked(e: MouseEvent) { /*...*/ }
override fun mouseEntered(e: MouseEvent) { /*...*/ }
})
关于它的一些其他细节
对象表达式可以实现多个接口
对象表达式持有外部类的引用，可以访问外部作用域的成员（比如当前函数作用域）
注意，object关键字除了声明对象表达式，还可以声明单例和伴生对象