Kotlin从入门到精通 | 第七章 类型进阶

本章节主要介绍Kotlin类型一些不为人知的秘密

image-20211118202509898

image-20211118202537590

构造器

构造器的基本写法

1
2
3
4
class Person(
var age: Int, // 类内全局可见
name: String // 构造器内可见(init块,属性初始化)
)

init块

init块可以有多个

1
2
3
4
5
6
7
8
9
10
11
12
13
class Person(var age: Int, name: String) {
var name: String

init {
this.name = name
}

val firstName = name.split(" ")[0]

init {
// ...
}
}

属性必须被初始化

Image

继承父类

1
2
abstract class Animal
class Person(var age: Int, var name: String) : Animal() // 调用父类构造器

副构造器

1
2
3
class Person(var age: Int, var name: String) : Animal() {
constructor(age: Int) : this(age, "unknown") // 副构造器,调用主构造器,确保构造路径唯一性
}

不定义主构造器(不推荐)

Image

主构造器默认参数

可以为主构造器定义默认参数,使用@JvmOverloads可以在Java代码中以重载的形式调用

Image

使用同名函数作为工厂函数

1
2
3
4
5
val persons = HashMap<String, Person>()
fun Person(name: String): Person {
return persons[name]
?: Person(1, name).also { persons[name] = it }
}

可见性

类的可见性

可见性类型JavaKotlin
public公开与Java相同,默认
internal模块内可见
default包内可见,默认
protected包内及子类可见类内及子类可见
private类内可见类或文件内可见

修饰对象

可见性类型顶级声明成员
public✔️✔️✔️
internal✔️,模块✔️,模块✔️,模块
protected✔️
private✔️,文件✔️,文件✔️,类

模块

直观的讲,大致可以认为是一个Jar包、一个aar

internal VS default

  • 一般由SDK或公共组件开发者用于隐藏模块内部细节实现
  • default可通过外部创建相同包名来访问,访问控制非常弱
  • default会导致不同抽象层次的类聚集到相同包之下
  • internal可方便处理内外隔离,提升模块内聚减少接口暴露
  • internal修饰的kotlin类或成员在Java当中可直接访问

类的可见性

1
2
class Person
private constructor(var age: Int, var name: String) // 构造器私有化

属性的可见性

1
2
3
4
5
6
7
class Person(var age: Int, var name: String) {
private var firstName: String = "" // 私有化属性 firstName,外部无法访问
var secondName: String = ""
private set // 私有化属性secondName的setter,外部只能读取
private get // 编译器报错,getter的可见性必须与属性可见性一致
public set // 编译器报错,setter的可见性不得大于属性的可见性
}

顶级声明的可见性

  • 顶级声明指文件内直接定义的属性、函数、类等
  • 顶级声明不支持protected
  • 顶级声明被private修饰标识文件内部可见

密封类(sealed)

  • 密封类是一种特殊的抽象类
  • 密封类的子类定义在与自身相同的文件中
  • 密封类的子类个数是有限的

Image

密封类的子类

1
2
3
4
5
6
7
8
9
10
11
12
sealed class PlayerState

object Idle : PlayerState()

class Playing(val song: Song) : PlayerState() {
fun start() {}
fun stop() {}
}

class Error(val errorInfo: ErrorInfo) : PlayerState() {
fun recover() {}
}

子类分支

子类可数,分支完备,所以不需要else分支

1
2
3
4
5
6
7
8
9
10
11
12
13
this.state = when (val state = this.state) {
Idle -> {
Playing(song).also(Playing::start)
}
is Playing -> {
state.stop()
Playing(song).also(Playing::start)
}
is Error -> {
state.recover()
Playing(song).also(Playing::start)
}
}

密封类VS枚举类

密封类枚举类
状态实现子类继承类实例化
状态可数子类可数实例可数
状态差异类型差异值差异

内联类(inline)

  • 内联类是对某一个类型的包装
  • 内联类是类似于Java装箱类型的一种类型
  • 编译器会尽可能使用被包装的类型进行优化
  • 内联类在1.3中处于公测阶段,谨慎使用

Image

内联类可以实现接口,但不能继承父类,也不能被继承

内联类的限制

  • 主构造器必须有且只有一个只读属性
  • 不能定义有backing-field的其他属性
  • 被包装类型必须不能是泛型类型
  • 不能继承父类也不能被继承
  • 内联类不能定义为其他类的内部类

内联类 VS 类型别名

typealiasinline class
类型没有新类型有包装类型产生
实例与原类型一致必要时使用包装类型
场景类型更直观优化包装类型性能