Kotlin学习笔记之类与对象

类和继承

与java一样，通过关键字class声明类，但是与java不同的地方有很多：

类声明由类名、类头（指定其类型参数、主

构造函数等）和由大括号包围的类体构成。类头和类体都是可选的； 如果一个类没有类体，可以省略花括号。

例如：class Empty

构造函数

在 Kotlin 中的一个类可以有一个 主构造函数

和一个或多个 次构造函数

。主

构造函数是类头的一部分：它跟在类名（和可选的类型参数）后，可见性修饰符必须写在constructor前面。

class Person public @Inject constructor

( firstName : String )

{

}

如果主构造函数没有任何注解或者可见性修饰符，可以省略这个

constructor

关键字。

class Person ( firstName : String )

{

}

主构造函数不能包含任何的代码。初始化的代码可以放

到以

init

关键字作为前缀的 初始化块（initializer blocks）

中：

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 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

)

}

}

如果一个非抽象类没有声明任何（主或次）构造函数，它会有一个生成的

不带参数的主构造函数。构造函数的可见性是 public。如果你不希望你的类

有一个公有构造函数，你需要声明一个带有非默认可见性的空的主构造函数：

class DontCreateMe private constructor

(

)

{

}

注意

：在 JVM 上，如果主构造函数的所有的参数都有默认值，编译器会生成 一个额外的无参构造函数，它将使用默认值。这使得 Kotlin 更易于使用像 Jackson 或者 JPA 这样的通过无参构造函数创建类的实例的库。

class Customer ( val customerName : String= ""

)

创建类的实例

要创建一个类的实例，我们就像普通函数一样调用构造函数，Kotlin中没有new关键字：

val invoice=Invoice (

)

val customer=Customer (

“Joe Smith”

)

继承

在 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， 对应于

书中的

第 17 条： 要么为继承而设计，并提供文档说明，要么就禁止继承

。

覆盖方法

我们之前提到过，Kotlin 力求清晰显式。与 Java 不同，Kotlin 需要显式

标注可覆盖的成员（我们称之为

开放

）和覆盖后的成员：

open class Base {

open fun v (

)

{

}

fun nv (

)

{

}

}

class Derived (

)

: Base (

)

{

override fun v (

)

{

}

}

Derived.v() 函数上必须加上 override

标注。如果没写，编译器将会报错。 如果函数没有标注 open

如 Base.nv()

，则子类中不允许定义相同签名的函数， 不论加不加 override

。在一个 final

类中（没有用 open

标注的类），开放成员是禁止的。

标记为

override

的成员本身是开放的，也就是说，它可以在子类中覆盖。如果你想禁止再次覆盖，使用

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

=

……

}

你也可以用一个 var

属性覆盖一个 val

属性，但反之则不行。这是允许的，因为一个 val

属性本质上声明了一个 getter 方法，而将其覆盖为 var

只是在子类中额外声明一个 setter 方法。

请注意，你可以在主构造函数中使用

override

关键字作为属性声明的一部分。

interface Foo {

val count : Int

}

class Bar1 ( override val count : Int )

: Foo

class Bar2 : Foo {

override var count : Int= 0

}

调用超类实现

派生类中的代码可以使用

super

关键字调用其超类的函数与属性访问器的实现：

open class Foo {

open fun f (

)

{

println

(

“Foo.f()”

)

}

open val

x

:

Int get

(

)

=

1

}

class Bar : Foo (

)

{

override fun f (

)

{

super

. f (

)

println (

“Bar.f()”

)

}

override val x : Int get

(

)

super

. x+ 1

}

在一个内部类中访问外部类的超类，可以通过由外部类名限定的

super

关键字来实现： super@Outer

class Bar : Foo (

)

{

override fun f (

)

{

/* …… */

}

override val x : Int get

(

)

0

inner class Baz {

fun g (

)

{

super @Bar . f (

)

// 调用 Foo 实现的 f()

println ( super @Bar . x )

// 使用 Foo 实现的 x 的 getter

}

}

}

覆盖规则

在 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.f() // 调用 A.f()

super.f() // 调用 B.f()

}

}

同时继承 A

和 B

没问题，并且 a()

和 b()

也没问题因为 C

只继承了每个函数的一个实现。 但是 f()

由 C

继承了两个实现，所以我们 必须

在 C

中覆盖 f()

并且提供我们自己的实现来消除歧义。

抽象类

类和其中的某些成员可以声明为

abstract

。 抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用 open

标注一个抽象类或者函数——因为这不言而喻

我们可以用一个抽象成员覆盖一个非抽象的开放成员

open class Base {

open fun f() {}

}

abstract class Derived : Base() {

override abstract fun f()

}

属性和字段

声明属性

Kotlin的类可以有属性。 属性可以用关键字

var

声明为可变的，否则使用只读关键字

val

。

class Address {

var name : String=……

var street : String=……

var city : String=……

var state : String?=……

var zip : String=……

}

要使用一个属性，只要用名称引用它即可，就像 Java 中的字段：

fun copyAddress ( address : Address )

: Address {

val result=Address (

)

// Kotlin 中没有“new”关键字

result . name=address . name // 将调用访问器

result . street=address . street

// ……

return result

}

声明一个属性的完整语法是

var [

: ]

[ =<property_initializer> ]

[ ]

[ ]

其初始器（initializer）、getter 和 setter 都是可选的。属性类型如果可以从初始器 （或者从其 getter 返回值，如下文所示）中推断出来，也可以省略。

var allByDefault : Int? // 错误：需要显式初始化器，隐含默认 getter 和 setter

var initialized= 1

// 类型 Int、默认getter 和 setter

我们可以编写自定义的访问器，非常像普通函数，刚好在属性声明内部。这里有一个自定义 getter 的例子:

val isEmpty : Boolean

get

(

)

this

. size== 0

自定义的 setter：

var stringRepresentation : String

get

(

)

this

. toString (

)

set

( value )

{

setDataFromString ( value )

// 解析字符串并赋值给其他属性

}

按照惯例，setter 参数的名称是 value

，但是如果你喜欢你可以选择一个不同的名称

自 Kotlin 1.1 起，如果可以从 getter 推断出属性类型，则可以省略它：

val isEmpty get

(

)

this

. size== 0

// 具有类型 Boolean

如果你需要改变一个访问器的可见性或者对其注解，但是不需要改变默认的实现， 你可以定义访问器而不定义其实现:

v ar setterVisibility : String= “abc”

private set

// 此 setter 是私有的并且有默认实现

var setterWithAnnotation : Any?= null

@Inject set

// 用 Inject 注解此 setter

幕后字段

Kotlin 中类不能有字段。然而，当使用自定义访问器时，有时有一个幕后字段（backing field）有时是必要的。为此 Kotlin 提供

一个自动幕后字段，它可通过使用 field

标识符访问。

var counter= 0

// 此初始器值直接写入到幕后字段

set

( value )

{

if

( value>= 0

)

field =value

}

field

标识符只能用在属性的访问器内

如果属性至少一个访问器使用默认实现，或者自定义访问器通过 field

引用幕后字段，将会为该属性生成一个幕后字段。

例如，下面的情况下， 就没有幕后字段：

val isEmpty : Boolean

get

(

)

this

. size== 0

幕后属性

如果你的需求不符合这套“隐式的幕后字段”方案，那么总可以使用

幕后属性（backing property）

：

private var _table : Map<String , Int>?= null

public val table : Map<String , Int>

get

(

)

{

if

( _table== null

)

{

_table=HashMap (

)

// 类型参数已推断出

}

return _table? : throw AssertionError (

“Set to null by another thread”

)

}

从各方面看，这正是与 Java 相同的方式。因为通过默认 getter 和 setter 访问私有属性会被优化，所以不会引入函数调用开销。

编译期常量

已知值的属性可以使用 const

修饰符标记为

编译期常量

。 这些属性需要满足以下要求：

• 位于顶层或者是 object 的一个成员，用 String 或原生类型 值初始化，没有自定义 getter。

这些属性可以用在注解中：

const val SUBSYSTEM_DEPRECATED : String= “This subsystem is deprecated”

@Deprecated ( SUBSYSTEM_DEPRECATED ) fun foo (

)

{ …… }

延迟初始化属性

一般地，属性声明为非空类型必须在构造函数中初始化。 然而，这经常不方便。例如：属性可以通过依赖注入来初始化， 或者在单元测试的 setup 方法中初始化。 这种情况下，你不能在构造函数内提供一个非空初始器。 但你仍然想在类体中引用该属性时避免空检查。

为处理这种情况，你可以用 lateinit

修饰符标记该属性：

public class MyTest {

lateinit var subject : TestSubject

@SetUp fun setup (

)

{

subject=TestSubject (

)

}

@Test fun test (

)

{

subject . method (

)

// 直接解引用

}

}

该修饰符只能用于在类体中（不是在主构造函数中）声明的 var

属性，并且仅

当该属性没有自定义 getter 或 setter 时。该属性必须是非空类型，并且不能是

原生类型。

在初始化前访问一个 lateinit

属性会抛出一个特定异常，该异常明确标识该属性

被访问及它没有初始化的事实。

该修饰符只能用于在类体中（不是在主构造函数中）声明的 var

属性，并且仅

当该属性没有自定义 getter 或 setter 时。该属性必须是非空类型，并且不能是

原生类型。

在初始化前访问一个 lateinit

属性会抛出一个特定异常，该异常明确标识该属性

被访问及它没有初始化的事实。

接口

Kotlin 的接口与 Java 8 类似，既包含抽象方法的声明，也包含

实现。与抽象类不同的是，接口无法保存状态。它可以有

属性但必须声明为抽象或提供访问器实现， 在接口中声明的属性不能有幕后字段（backing field），因此接口中声明的访问器

不能引用它们 。

interface MyInterface {

fun bar (

)// 默认的访问器

fun foo (

)

{

// 可选的方法体

}

}

interface MyInterface {

val prop : Int // 抽象的

val propertyWithImplementation : String

get

(

)

“foo”

fun foo (

)

{

print ( prop )

}

}

class Child : MyInterface {

override val prop : Int= 29

}

包

函数、属性和类、对象和接口可以在顶层声明，即直接在包内：

// 文件名：example.kt

package foo

fun baz (

)

{

}

class Bar {

}

• 如果你不指定任何可见性修饰符，默认为 public ，这意味着你的声明将随处可见，如果你声明为 private ，它只会在声明它的文件内可见，如果你声明为 internal ，它会在相同 内随处可见， protected 不适用于顶层声明。

类和接口

对于类内部声明的成员：

• private 意味着只在这个类内部（包含其所有成员）可见；
• protected —— 和 private 一样 + 在子类中可见。
• internal —— 能见到类声明的 本模块内 的任何客户端都可见其 internal 成员；
• public —— 能见到类声明的任何客户端都可见其 public 成员。

注意 对于Java用户：Kotlin 中外部类不能访问内部类的 private 成员。

如果你覆盖一个 protected 成员并且没有显式指定其可见性，该成员还会是 protected 可见性。

扩展

Kotlin 同 C# 和 Gosu 类似，能够扩展一个类的新功能而无需继承该类或使用像装饰者这样的任何类型的设计模式。 这通过叫做

扩展

的特殊声明完成。Kotlin 支持

扩展函数

和

扩展属性

。

扩展函数

声明一个扩展函数，我们需要用一个

接收者类型

也就是被扩展的类型来作为他的前缀。 下面代码为 MutableList<Int>

添加一个 swap

函数：

fun MutableList . swap ( index1 : Int , index2 : Int )

{

val tmp= this

[ index1 ]

// “this”对应该列表

this

[ index1 ]

this

[ index2 ]

this

[ index2 ] =tmp

}

这个

this

关键字在扩展函数内部对应到接收者对象（传过来的在点符号前的对象） 现在，我们对任意 MutableList<Int>

调用该函数了：

val l=mutableListOf (

1

,

2

,

3

)

l . swap (

0

,

2

)

// “swap()”内部的“this”得到“l”的值

当然，这个函数对任何 MutableList<T>

起作用，我们可以泛化它：

fun MutableList . swap ( index1 : Int , index2 : Int )

{

val tmp= this

[ index1 ]

// “this”对应该列表

this

[ index1 ]

this

[ index2 ]

this

[ index2 ] =tmp

}

扩展是静态解析的

扩展不能真正的修改他们所扩展的类。通过定义一个扩展，你并没有在一个类中插入新成员， 仅仅是可以通过该类型的变量用点表达式去调用这个新函数。

我们想强调的是扩展函数是静态分发的，即他们不是根据接收者类型的虚方法。 这意味着调用的扩展函数是由函数调用所在的表达式的类型来决定的， 而不是由表达式运行时求值结果决定的。例如：

open class C

class D : C (

)

fun C . foo (

)

“c”

fun D . foo (

)

“d”

fun printFoo ( c : C )

{

println ( c . foo (

)

)

} printFoo ( D (

)

)

这个例子会输出 “c”，因为调用的扩展函数只取决于

参数 c

的声明类型，该类型是 C

类。

如果一个类定义有一个成员函数和一个扩展函数，而这两个函数又有相同的接收者类型、相同的名字

并且都适用给定的参数，这种情况 总是取成员函数

。 例如：

class C {

fun foo (

)

{ println (

“member”

)

}

}

fun C . foo (

)

{ println (

“extension”

)

}

如果我们调用 C

类型 c

的 c.foo()

，它将输出“member”，而不是“extension”。

当然，扩展函数重载同样名字但不同签名成员函数也完全可以：

class C {

fun foo (

)

{ println (

“member”

)

}

}

fun C . foo ( i : Int )

{ println (

“extension”

)

}

调用 C().foo(1)

将输出 “extension”。

可空接收者

注意可以为可空的接收者类型定义扩展。这样的扩展可以在对象变量上调用， 即使其值为 null，并且可以在函数体内检测 this == null

，这能让你

在没有检测 null 的时候调用 Kotlin 中的toString()：检测发生在扩展函数的内部。

fun Any? . toString (

)

: String {

if

( this

null

) return

“null”

// 空检测之后，“this”会自动转换为非空类型，所以下面的 toString()

// 解析为 Any 类的成员函数

return toString (

)

}

扩展属性

和函数类似，Kotlin 支持扩展属性：

val List . lastIndex : Int

get

(

) =size- 1

注意：由于扩展没有实际的将成员插入类中，因此对扩展属性来说

是无效的。这就是为什么 扩展属性不能有初始化器

。他们的行为只能由显式提供的 getters/setters 定义。

val Foo . bar= 1

// 错误：扩展属性不能有初始化器

var Outer.index : Int

get() = 1

set(value) {

index = value

}

伴生对象的扩展

如果一个类定义有一个

，你也可以为伴生对象定义

扩展函数和属性：

class MyClass {

companion object

{

}

// 将被称为 “Companion”

}

fun MyClass . Companion . foo (

)

{

// ……

}

就像伴生对象的其他普通成员，只需用类名作为限定符去调用他们

MyClass . foo (

)

扩展声明为成员

在一个类内部你可以为另一个类声明扩展。在这样的扩展内部，有多个

隐式接收者

—— 其中的对象成员可以无需通过限定符访问。扩展声明所在的类的实例称为

分发接收者

，扩展方法调用所在的接收者类型的实例称为

扩展接收者

。

class D {

fun bar (

)

{ …… }

}

class C {

fun baz (

)

{ …… }

fun D . foo (

)

{

bar (

)

// 调用 D.bar

baz (

)

// 调用 C.baz

}

fun

caller

(

d

:

D

)

{

d

.

foo

(

)

// 调用扩展函数

}

}

对于分发接收者和扩展接收者的成员名字冲突的情况，扩展接收者

优先。要引用分发接收者的成员你可以使用

。

class C {

fun D . foo (

)

{

toString (

)

// 调用 D.toString()

this @C . toString (

)

// 调用 C.toString()

}

声明为成员的扩展可以声明为 open

并在子类中覆盖。这意味着这些函数的分发

对于分发接收者类型是虚拟的，但对于扩展接收者类型是静态的。

open class D {

}

class D1 : D (

)

{

}

open class C {

open fun D . foo (

)

{

println (

“D.foo in C”

)

}

open fun D1 . foo (

)

{

println (

“D1.foo in C”

)

}

fun caller ( d : D )

{

d . foo (

)

// 调用扩展函数

}

}

class C1 : C (

)

{

override fun D . foo (

)

{

println (

“D.foo in C1”

)

}

override fun D1 . foo (

)

{

println (

“D1.foo in C1”

)

}

}

C (

)

. caller ( D (

)

)

// 输出 “D.foo in C”

C1 (

)

. caller ( D (

)

)

// 输出 “D.foo in C1”

—— 分发接收者虚拟解析

C

(

)

.

caller

(

D1

(

)

)

// 输出 “D.foo in C” —— 扩展接收者静态解析

数据类

我们经常创建一些只保存数据的类。 在这些类中，一些标准函数往往是从

数据机械推导而来的。在 Kotlin 中，这叫做

数据类

并标记为 data

：

data class User ( val name : String , val age : Int )

编译器自动从主构造函数中声明的所有属性导出以下成员：

equals()

/ hashCode()

对

toString()

格式是 "User(name=John, age=42)"

；

按声明顺序对应于所有属性；

copy()

函数（见下文）

为了确保生成的代码的一致性和有意义的行为，数据类必须满足以下要求：

主构造函数需要至少有一个参数

主构造函数的所有参数需要标记为 val

或 var

数据类不能是抽象、开放、密封或者内部的

（在1.1之前）数据类只能实现接口

此外，成员生成遵循关于成员继承的这些规则：

如果在数据类体中有显式实现 equals()

、 hashCode()

或者 toString()

，或者这些函数在父类中有

final

实现，那么不会生成这些函数，而会使用现有

函数；

如果超类型具有

open

的 componentN()

函数并且返回兼容的类型， 那么会为数据类生成相应的函数，并覆盖超类的实现。如果超类型的这些函数

由于签名不兼容或者是 final 而导致无法覆盖，那么会报错

不允许为 componentN()

以及 copy()

函数提供显式实现

在 JVM 中，如果生成的类需要含有一个无参的构造函数，则所有的属性必须指定默认值。

data class User ( val name : String= ""

, val age : Int= 0

)

复制

在很多情况下，我们需要复制一个对象改变它的一些属性，但其余部分保持不变。 copy()

函数就是为此而生成。对于上文的 User

类，其实现会类似下面这样：

fun copy ( name : String= this

. name , age : Int= this

. age ) =User ( name , age )

这让我们可以写：

val jack=User ( name= “Jack”

, age= 1

)

val olderJack=jack . copy ( age= 2

)

数据类和解构声明

为数据类生成的

Component 函数

使它们可在

中使用：

val jane=User (

“Jane”

,

35

)

val

( name , age ) =jane

println (

“$name, $age years of age”

)

// 输出 “Jane, 35 years of age”

标准数据类

标准库提供了 Pair

和 Triple

。尽管在很多情况下命名数据类是更好的设计选择， 因为它们通过为属性提供有意义的名称使代码更具可读性。

密封类

密封类用来表示受限的类继承结构：当一个值为有限集中的类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展：枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。

要声明一个密封类，需要在类名前面添加 sealed 修饰符。虽然密封类也可以有子类，但是所有子类都必须在与密封类自身相同的文件中声明。（在 Kotlin 1.1 之前， 该规则更加严格：子类必须嵌套在密封类声明的内部）。

sealed class Expr

data class Const ( val number : Double )

: Expr (

)

data class Sum ( val e1 : Expr , val e2 : Expr )

: Expr (

)

object NotANumber : Expr (

)

（上文示例使用了 Kotlin 1.1 的一个额外的新功能：数据类扩展包括密封类在内的其他类的可能性。 ）

一个密封类是自身

，它不能直接实例化并可以有抽象（

abstract

）成员。

密封类不允许有非-

private

构造函数（其构造函数默认为

private

）。

请注意，扩展密封类子类的类（间接继承者）可以放在任何位置，而无需在

同一个文件中。

使用密封类的关键好处在于使用

的时候，如果能够

验证语句覆盖了所有情况，就不需要为该语句再添加一个 else

子句了。当然，这只有当你用 when

作为表达式（使用结果）而不是作为语句时才有用。

fun eval ( expr : Expr )

: Double= when

( expr )

{

is Const->expr . number

is Sum->eval ( expr . e1 ) +eval ( expr . e2 )

NotANumber->Double . NaN

// 不再需要 else 子句，因为我们已经覆盖了所有的情况

}

泛型

与 Java 类似，Kotlin 中的类也可以有类型参数， 一般来说，要创建这样类的实例，我们需要提供类型参数 ：

class Box ( t : T )

{

var value=t

}

val box : Box=Box (

1

)

但是如果类型参数可以推断出来，例如从构造函数的参数或者从其他途径，允许省略类型参数：

val box=Box (

1

)

// 1 具有类型 Int，所以编译器知道我们说的是 Box。

声明处型变

假设有一个泛型接口 Source<T>

，该接口中不存在任何以 T

作为参数的方法，只是方法返回 T

类型值：

// Java

interface Source {

TnextT (

)

;

}

那么，在 Source <Object>

类型的变量中存储 Source <String>

实例的引用是极为安全的——没有消费者-方法可以调用。但是 Java 并不知道这一点，并且仍然禁止这样操作：

// Java

voiddemo ( Sourcestrs )

{

Source