类
Kotlin中使用关键词class
声明类。
class Invoice{
}
类的声明有类名、类头(尤其是类型参数、主构造函数等等)、类体组成,用花括号圈起。类头和类体都是可选的,如果类体为空,那么花裤OAO可以省略。
class Empty
构造器
每个类,有一个主构造函数和一个或多个次构造函数。主构造函数是类头的一部分,它在类名称(如果有类型参数)的后面。
class Person constructor(firstName: String) {
}
如果主构造函数没有任何注解或访问修饰符,那么关键词constructor
可以省略。
class Person(firstName: String) {
}
主构造函数没有任何代码,初始化代码可以发放在用关键词init
做前缀的代码块里。
class Customer(name: String) {
init {
logger.info("Customer initialized with value ${name}")
}
}
主构造函数的参数可以在初始化代码块中使用,它们也可以用在类体中,声明的属性初始化赋值时。
class Customer(name: String) {
val customerKey = name.toUpperCase()
}
实际上,针对在主构造函数中声明类属性并初始化他们,Kotlin提供了更简洁的句法:
class Person(val firstName: String, val lastName: String, var age: Int) {
// ...
}
与普通属性大致相同的是,声明在主构造函数中的属性,可以是变量(var
)也可以是常量(val
)
如果构造器有注解或者修饰符,关键词constructor
要求放在修饰符前面。
class Customer public @Inject constructor(name: String) { ... }
声明次构造函数,也需要关键词constructor
做前缀,且不可省略。
class Person {
constructor(parent: Person) {
parent.children.add(this)
}
}
如果类有一个主构造函数,那么每个次构造函数都需要委托给主构造函数,不管是直接委托还是通过其他次构造函数简介委托。同一个类中,委托给其他构造器,需要关键词this
。
class Person(val name: String) {
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
}
}
如果非抽象类没有声明任何构造函数(主构造函数或次构造函数),它将生成一个没有参数的主构造函数。构造函数的可见性将是公共的。如果不希望你的类有公共的构造函数,你可以声明一个非默认可见性的空主构造函数。
class DontCreateMe private constructor () { //主构造函数不可见
}
注:JVM中,如果主构造函数的所有参数都有默认的值,那么编译器将会附加生成一个无参的构造函数使用这些默认值。这样使Kotlin使用Jackson、JPA这类的库通过无参构造函数创建实例变得很容易。
class Customer(val customerName: String = "")
创建类的实例
像使用普通函数一样,调用构造函数创建实例。
val invoice = Invoice()
val customer = Customer("Joe Smith")
注:Kotlin中没有关键词new
。
类成员
类包含:
- 构造函数和初始化代码块
- 函数
- 属性
- 嵌套和内部类
- 对象声明
继承
Kotlin中所有的类都有一个公共父类Any
,这是没有声明父类的类的默认父类。
class Example // 隐式集成Any类
Any
不是java.lang.Object
,特别是他没有除equals()
、hashCode()
和toString()
以外的成员。
在类头部的冒号后,显示声明一个父类型:
//定义父类
open class Base(p: Int)
//继承父类
class Derived(p: Int) : Base(p)
如果该类有主构造函数,父类型必须使用主构造函数的参数在这里初始化。
如果该类没有主构造函数,那么每个次构造函数都需要使用关键词super
初始化父类型,或者委托给其他次构造函数。注意的是,不同的次构造函数可以调用不同的父类型的构造函数。
class MyView : View {
constructor(ctx: Context) : super(ctx)
constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}
open
注解的作用和Java中的final
相反:它允许其他类继承这个类,Kotlin中所有类默认是final。
重写方法
正如我们前面提到的,在kotlin中坚持做明确的事情。不同于Java,Kotlin要求显示注解可重写成员(我们称之为open
)然后在重写它。
open class Base {
open fun v() {} //fun可以被重写
fun nv() {}
}
class Derived() : Base() {
override fun v() {} //
}
必须对Derived.v()
使用override
注解,若注解丢失,编译器就会报错。如果没有对函数使用open
注解,像Base.nv()
,那么在子类型中不管有没有使用override
声明相同名称的方法是非法的。在final类中(即,该类没有open
注解),禁止开放成员。
标记被重写的成员,其本身是开放的。即,它可以在子类中被重写。如果你想禁止它被再次重写,使用关键词final
。
open class AnotherDerived() : Base() {
final override fun v() {}
}
重写属性
属性重写的工作原理同方法重写的工作原理一致;在父类型中声明的属性在派生类型中声明时需要在其前面添加override
,而且他们必须有一致的类型。每个声明的属性都可以被有初始值的属性或有getter方法赋值的属性重写。
open class Foo {
open val x: Int get { ... }
}
class Bar1 : Foo() {
override val x: Int = ...
}
通常可以把val
属性重写成var
属性,反之则不可以。之所以这样是因为,val
本质上生成了getter方法,而重写成var
属性则在子类中附加声明了setter方法。
interface Foo {
val count: Int
}
class Bar1(override val count: Int) : Foo
class Bar2 : Foo {
override var count: Int = 0
}
重写规则
Kotlin中,实现继承,需要遵循如下规则:如果一个类继承超类相同成员的很多实现,必须重写改成员并提供自己的实现(也许使用继承的某一个)。为了表示使用继承实现中的哪个父类型,使用super
限定尖括号中的父类型名称。即:super<Base>
:
open class A {
open fun f() {
print("A")
}
fun a() {
print("a")
}
}
interface B {
fun f() { print("B") } // 接口的成员默认使用open
fun b() { print("b") } }
class C() : A(), B { // 编译器要求f()被重写:
override fun f() {
super<A>.f() // 调用 A.f()
super<B>.f() // 调用 B.f()
}
}
这样继承
A
和B
时候没问题的。由于C
只继承了每个函数的一个实现,所以我们使用a()
和b()
是没有问题的。但对f()
我们有C
继承的两个实现,因此我们不得不在C
中重写f()
和提供自己的实现,消除歧义。
抽象类
一个类或它的某些成员可以被声明成abstract
。一个抽象成员在他的类中不能有具体的实现。
我们没必要给抽象类使用
open
注解——不言而喻。
可以对非抽象的open函数重写成抽象函数。
open class Base {
open fun f() {}
}
abstract class Derived : Base() {
override abstract fun f()
}
伴生对象
Kotlin中,不同于Java或C#,类没有静态方法。在更多场合,要求使用包层级的函数取代。
如果你需要写一个函数调用时不需要类实例但是需要访问到类内部(如:工厂方法),你可以将它作为该类中对象声明的成员编写。
更具体地说,如果你在你的类中声明一个伴生对象,你可以只使用类名作为修饰语调用它的成员,与Java或C#调用静态方法具有相同的语法。