Kotlin 朱涛-2 面向对象 类 继承 构造 嵌套类 数据类
目录
02 | 面向对象
类
class Person(val name: String, var age: Int)
Kotlin 定义的类,以及类中的方法、属性,默认都是
public final
的
抽象类
Kotlin 中的抽象类同样也不能直接用来创建对象。
abstract class Person(val name: String) { // 抽象类
abstract fun walk() // 抽象方法
}
接口
Kotlin 中的接口,除了具有 Java 中接口的特性外,同时还拥有了部分抽象类
的特性。
interface Behavior { // 通过关键字 interface 定义接口
fun run()
val canWalk: Boolean // 接口中可以有属性(本质上是一个普通的接口方法)
fun walk() {} // 也可以有默认实现的方法(本质上是静态内部类中的一个静态方法)
}
class Person(val name: String): Behavior { // 实现接口法和继承类的语法一致
override val canWalk: Boolean // 重写接口的属性
get() = true
override fun run() {} // 重写接口的方法
}
Kotlin 接口中的这些特性,不是基于 Java 1.8 实现的,而是基于编译器
做的一些转换来实现的。
继承
- Kotlin 中使用
:
表示继承或实现,使用关键字override
表示重写 - 和 Java 一样,只能继承自一个类,可以同时实现多个接口。但是继承和实现的先后顺序不做要求
class MainActivity : OnClickListener, AppCompatActivity() {
override fun onCreate() {}
}
Kotlin 的设计思想
Kotlin 定义的类,以及类中的方法、属性,默认都是 public final
的
- Kotlin 中的类,默认是不允许被继承的,只有被标记为
open
的类才可以被继承 - Kotlin 类内部的方法和属性,默认是不允许被重写的,除非它们也被
open
修饰
Java 的规则是:被
final
修饰的类不可以被继承,被final
修饰的成员不可以被重写。
open class A { // 只有被标记为 open 的【类】才可以被继承
open var i = 1 // 只有被标记为 open 的【属性】才可以被重写
open fun test() = 1 // 只有被标记为 open 的【方法】才可以被重写
}
class B : A() {
override var i = 2
override fun test() = 2
}
目的:防止出现 Java 中继承被过度使用的问题。
构造函数
主构造函数 和 次构造函数
Kotlin 中构造函数分为主构造函数
(Primary constructor)和次构造函数
(Secondary constructor)。
- 可以在
类头
中声明主构造函数
,主构造函数中不包含任何代码 - 可以在类中使用
constructor
关键字创建一个或多个次构造函数
- 如果
既没有
主构造函数,也没有
次构造函数,则在编译期会自动添加一个无参构造函数
init 代码块
用于在构造函数之后执行额外的初始化逻辑,相当于是构造函数的扩展- 如果有主构造函数,次构造函数中必须用
this
直接或间接调用主构造函数 - 可以没有主构造函数
- 没有主构造函数时,
次构造函数
必须显示调用super
- 没有主构造函数,但同时
有次构造函数
时,默认的无参构造函数
就没有了
- 没有主构造函数时,
class Person constructor(var name: String, var age: Int) {} // 声明主构造函数
class Person(var name: String = "bqt") {} // constructor 可以省略,可以指定默认值
主构造函数中参数的 val/var
Kotlin 主构造函数中的参数可以使用 var/val
修饰,也可以不加修饰。
- 使用 var:可以在类中使用,相当于在该类中定义了一个 var 的成员变量
- 使用 val:可以在类中使用,相当于在该类中定义了一个 val 的成员变量
- 什么都不加:不可以在该类中使用,这个参数的作用仅仅是
传递给父类的构造方法
的
注意:次构造函数 或 普通函数 中的参数,不可以使用
var/val
修饰
案例一
class Person(private val name: String = "bqt") { // 主构造函数
private var age = 0
private var tag = ""
constructor(name: String, age: Int) : this(name) { this.age = age } // 次构造函数,直接调用主构造函数
constructor(n: String, a: Int, t: String) : this(n, a) { this.tag = t } // 次构造函数,间接调用主构造函数
init { tag = tag.ifEmpty { "xx" } } // init 代码块,用于在构造函数【之后】执行额外的初始化逻辑
}
案例二
open class Person(val name: String = "bqt")
class Person0 : Person() // 前面的小括号可以省略
class Person1() : Person() // 父类有主构造函数时,后面的小括号不可以省略
class Person2 : Person("P2") // 没有任何构造函数时,会自动添加一个无参构造函数
class P3(n: String): Person(n) { // 子类需要显示调用父类的构造函数
constructor() : this("P3") // 有主构造函数时,次构造函数必须显示通过 this 调用主构造函数
}
class Person4 : Person { // 只要有构造函数,默认的无参构造函数就没有了
// 此时会提示:Secondary constructor should be converted to a primary one
constructor(n: String) : super(n) // 没有主构造函数时,次构造函数必须通过 super 调用父类的构造函数
constructor(i: Int) : this("$i") // 当然,也可以通过 this 间接调用父类的构造函数
}
属性
Kotlin 编译器会自动给类中的属性生成 getter 和 setter 方法
- 用
val
修饰的变量,对应 Java 中的final
变量,只有 getter 没有 setter - 用
var
修饰的变量,既有 getter 也有 setter
自定义 set
class Person(val name: String) {
var age: Int = 0
set(i) {
field = i + 100 // 这里的 field 代表的就是属性 age
}
var sex = 0
private set // 可以给 set 方法加上可见性修饰符
// 但是 get 的可见性修饰符必须和属性的保持一致
}
自定义 get
如果希望给 Person 类增加一个功能,根据年龄判断是不是成年人
- 按照 Java 的思维,我们会增加一个新的方法
isAdult()
- 按照 Kotlin 的思维,我们可以借助 Kotlin 属性的自定义 getter,将
isAdult
定义成类的属性。
class Person(val name: String, var age: Int) {
fun isAdult() = age >= 18 // Java 思维:增加一个新的方法
val isAdult // Kotlin 思维:增加一个新的属性
get() = age >= 18 // 通过自定义 get 方法改变属性的返回值
}
Kotlin 的设计思想:
- 从
语法层面
来看,isAdult 本来就是属于人身上的一种属性
,而非一个行为
,所以定义成一个属性更为合适。 - 从
实现层面
来看,isAdult 仍然还是个方法。- Kotlin 编译器能够分析出,isAdult 这个属性,实际上是根据 age 来做逻辑判断的
- 所以 Kotlin 编译器可以在 JVM 层面,将其优化为一个方法
通过以上两点,我们就成功在语法层面
有了一个 isAdult 属性,但在实现层面
仍然是个方法。
以上两种方式,反编译后的 Java 代码完全一样。
嵌套类
和 Java 类似,Kotlin 中也有(非静态)内部类、静态内部类的概念
默认是静态内部类
和 Java 相反,Kotlin 中的普通嵌套类,本质上是静态内部类,而非普通内部类
class A {
val name: String = ""
fun foo() = 1
class B { // 对应 Java 中的【静态内部类】
val a = name // 报错,无法在静态内部类 B 中访问外部类 A 中的属性
val b = foo() // 报错,无法在静态内部类 B 中访问外部类 A 中的方法
}
}
普通内部类 inner
如果想在 Kotlin 中定义一个普通的内部类,需要在嵌套类前加 inner
关键字
class A {
val name: String = ""
fun foo() = 1
inner class C { // 对应 Java 当中的【普通内部类】
val a = name // 通过
val b = foo() // 通过
}
}
Kotlin 的设计思想
- Java 中的(非静态)内部类会持有外部类的引用,导致非常容易出现
内存泄漏
问题 - 大部分 Java 开发者之所以犯这样的错误,往往只是因为忘记了加
static
关键字 - Kotlin 这样的设计,就将开发者默认犯错的风险完全抹掉了
数据类 data
数据类就是用于存放数据的类。
Kotlin 中引入数据类的目的,是为了解决广泛存在、代码冗余的 Java Bean 问题。
定义:只需要在普通的类前面加上一个关键字 data
即可。
注意,数据类是 final 的,不能被继承:Modifier 'open' is incompatible with 'data'
编译器会自动为数据类生成一些有用的方法:
copy()
toString()
- equals()
- hashCode()
- componentN()
- copy$default()
data class Person(val name: String, val age: Int) // 数据类中最少要有一个属性
val tom = Person("Tom", 18)
println(tom.copy(age = 6)) // 创建一份拷贝的同时,修改某个属性
println(tom.toString()) // Person(name=Tom, age=18)
val (name, age) = tom // 数据类的解构声明:通过数据类创建一连串的变量
println("$name, $age") // Tom, 18
枚举类 enum
和 Java 类似,Kotlin 中的枚举类也用来表示一组有限数量的值。
每一个枚举的值,在内存当中始终都是同一个对象的引用。
enum class Human { MAN, WOMAN }
fun main() {
println(Human.MAN == Human.MAN) // true,结构相等
println(Human.MAN === Human.MAN) // true,引用相等
println(Human.values().toList()) // [MAN, WOMAN]
println("${Human.MAN} - ${Human.MAN.name}") // MAN - MAN
println(Human.valueOf("MAN")) // MAN,注意:valueOf() 是用于解析枚举变量名称
println(Human.valueOf("xxx")) // IllegalArgumentException: No enum constant Human.xxx
}
在 when 表达式当中使用枚举时,不需要 else 分支,编译器可自动推导逻辑是否完备
fun isMan(data: Human) = when (data) {
Human.MAN -> true
Human.WOMAN -> false
}
密封类 sealed
密封类是枚举和对象的结合体,是更强大的枚举类。
每一个枚举的值,在内存当中始终都是同一个对象引用。而使用密封类,就可以让枚举的值拥有不一样的对象引用。
可定义一组有限数量的值
密封类其实是对枚举的一种补充,枚举类能做的事情,密封类也能做到,比如用来定义一组有限数量的值。
enum class Human { MAN, WOMAN }
sealed class Human {
object MAN : Human() // object 单例
object WOMAN : Human()
}
使用枚举或者密封类的时候,一定要慎重使用 else 分支,否则,当枚举类扩展后,可能引发不易察觉的问题。
可定义一组有限数量的子类
密封类更多的是和 data 一起使用,用来定义一组有限数量的子类
。 可以针对同一子类,可以创建不同的对象。
不一定非得是 data class,也可以是普通的 class,也可以和 object 等共同使用。
唯一的要求是:不管是 object 值,还是 class,都需要继承自密封类。
sealed class Result<out R> { // 用于封装网络请求所有可能的结果
data class Success<out T>(val data: T) : Result<T>() // 代表成功的数据类
data class Error(val e: Exception) : Result<Nothing>() // 代表失败的数据类
data class Loading(val time: Long) : Result<Nothing>() // 代表请求中的数据类
}
- 首先,我们使用
sealed
定义了一个密封类 Result,这个密封类用于封装网络请求所有可能的结果 - 然后,在密封类中使用
data
定义了三个数据类,代表网络请求有限的三类结果:成功、失败、请求中
这样,网络请求结束后的 UI 展示逻辑就变得非常简单,就是三个非常清晰的逻辑分支:成功、失败、进行中
fun display(result: Result<String>) = when (result) { // 使用 when 表达式处理网络请求的结果
is Result.Success -> displaySuccessUI(result.data) // 如果是 Success,就展示成功的数据
is Result.Error -> showErrorMsg(result.e) // 如果是 Error,就展示错误提示框
is Result.Loading -> showLoading(result.time) // 如果是 Loading,就展示进度条
}
使用密封类的优势
- 由于密封类只有有限的几种情况,所以使用
when
表达式时不需要 else 分支 - 如果哪天扩充了密封类的子类数量,那么所有密封类的使用处都会智能检测到,并且给出报错
- 扩充子类型以后,IDE 可以帮我们快速补充分支类型
注意:前提是是使用了
when
表达式,并且没有使用else
分支!
小结
- Kotlin 的类,默认是 public 的,默认是对继承封闭的,类中的成员和方法,默认也是无法被重写的
- Kotlin 接口可以有成员属性,方法可以有默认实现
- Kotlin 的嵌套类默认是静态的,这种设计可以防止我们无意中出现内存泄漏问题
- Kotlin 的密封类,作为枚举和对象的结合体,支持 when 表达式完备性
2018-05-10
本文来自博客园,作者:白乾涛,转载请注明原文链接:https://www.cnblogs.com/baiqiantao/p/9020619.html