- 开发环境:IntelliJ IEDA
- 个人博客:http://blog.csdn.net/IInmy
- 项目源码:https://github.com/Rushro2m/KotlinForOfficial
- 官方文档中文版:https://www.kotlincn.net/docs/reference/classes.html
1、类
Kotlin中使用关键字class
声明类
class Invoice{
//代码块
}
类声明由类名、类头(指定其类型参数、主构造函数等)和由大括号包围的类体构成。
比如,下面这个类中:
关键字:class
类名:Person
类头:(name:String)
类体:{fun zoo(){}}
class Person(name:String){
fun zoo(){
}
}
类头和类体都是可选的,如果一个类没有类体,可以省略花括号。
class Empty
2、构造函数
在Kotlin中一个类可以有一个主构造函数和一个或者多个次构造函数。主构造函数是类头的一部分:它跟在类名后。
class Person constructor(firstName: String) {
}
如果主构造函数没有任何注解或者可见性修饰符,可以省略这个constructor
关键字。
class Person(firstName: String) {
}
主构造函数不能包含任何的代码。初始化的代码可以放到以关键字init
关键字作为前缀的初始化代码块中:
class Customer(var name: String) {
init {
name = "张三"
}
}
主构造的参数可以在初始化块中使用。它们也可以在类体内声明的属性初始化器中使用:
class People(name:String){
val nameKey = name.toUpperCase()
}
3、次构造函数
类也可以声明前缀有constructor
的次构造函数:
class Dog{
constructor(parent: Dog) {
parent.children.add(this)
}
}
如果类有一个主构造函数,每个次构造函数需要委托给主构造函数,可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用this
关键字即可:
class Pig(val name:String){
constructor(name: String,parent: Pig):this(name){
parent.children.add(this)
}
}
4、创建类的实例
要创建一个类的实例,我们就像普通函数一样调用构造函数,Kotlin没有new
关键字:
val invoice = Invoice()
val customer = Customer("张三")
5、类成员
类可以包含:
- 构造函数和初始化块
- 函数
- 属性
- 嵌套类和内部类
- 对象声明
6、继承
在Kotlin中所有类都有一个共同的超类Any
,它是对没有超类型声明的类的默认超类。
//从Any隐式继承
class Example
class Example1:Any()
要声明一个显式的超类型,我们把类型方法类头的冒号之后:
open class Base(p: Int)
class Derived(p: Int) : Base(p)
如果该类有一个主构造函数,基类型可以用主构造函数就地初始化。如果类没有主构造函数,那么每个次构造函数必须使用super
关键字初始化其基类型,或者委托给另一个构造函数做到这一点。在这种情况下,不同的次构造函数可以调用基类型的不同的构造函数:
class MyView:View{
constructor(ctx:Context):super(ctx)
constructor(ctx:Context,attr:AttributeSet):super(ctx,attr)
}
类上的open标注与Java中final相反,它允许其它类从这个类继承。默认情下,在Kotlin中所有的类都是final。
7、覆盖方法
Kotlin需要显式标注可覆盖的成员和覆盖后的成员,通过关键字open
关键字来标注其可以覆盖:
open class Father{
//open标注可以被覆盖
open fun v(){}
fun nv(){}
}
open class Son():Father(){
//override标注覆盖方法
override fun v() {}
}
如果一个类没有被open标注,那么它是不可以被继承的。如果一个方法没有被open标注,子类中不能被覆盖的,并且不允许定义相同签名的函数。
open class Father{
fun zoo(){}
}
class Son():Father(){
//这里会报错,不允许覆盖
override fun zoo(){
}
}
标记为override的成员本身是开放的,也就是说,它可以在子类中覆盖。如果你想禁止再次覆盖,使用final
关键字:
open class Daugther() : Father() {
final override fun v() {}
}
8、覆盖属性
属性覆盖与方法覆盖类似;在超类中声明然后在派生类中重新声明的属性必须以override
开头,并且它们必须具有兼容的类型。每个声明的属性可以由具有初始化器的属性或者具有getter方法的属性覆盖。
open class Foo {
open val x: Int
get() {
return 11
}
}
class Bar1 : Foo() {
override val x: Int
get() = super.x
}
可以在主构造函数中使用override
关键字作为属性声明的一部分。
open interface Zoo {
val count: Int
}
class Bar(override val count: Int) : Zoo
class Bar2 : Zoo {
override val count: Int = 0
}
9、覆盖规则
在Kotlin中如果一个类从它的直接超类继承相同成员的多个实现,它必须覆盖这个成员并提供其自己的实现。为了表示从哪个超类型继承的实现,我们使用由尖括号中超类型名限定的super
,如super<Base>
:
open class A {
open fun f() {
print("A")
}
fun a() {
print("a")
}
}
//接口成员默认的是open所有不需要用open标注
interface B {
fun f() {
print("B")
}
fun b() {
print("b")
}
}
class C() : A(), B {
override fun f() {
super<A>.f()//调用A.f()
super<B>.f()//调用B.f()
}
}
同时继承A
和B
没有问题,并且a()
和b()
也没有问题,因为C
只继承了每个函数的一个实现。但是f()
由C
继承了两个实现,所以我们必须在C
中覆盖f()
并且提供我们自己的实现来消除歧义。
10、抽象类
类和其中的某些成员可以声明为abstract
。抽象成员在本类中可以不同实现。需要注意的是,并需要用open
标注一个抽象类或者函数。
我们可以用一个抽象成员覆盖一个非抽象的开放成员
open class BaseOne {
open fun f() {}
}
abstract class One : BaseOne() {
override abstract fun f()
}