feintkotlin

以下内容皆有feint进行翻译，不定期进行更新。翻译若有不正确的地方，欢迎在评论中指出。

属性和字段

声明属性

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

}

Getters and Setters

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

var <propertyName>[: <PropertyType>] [= <property_initializer>]

[<getter>]

[<setter>]

初始化器， getter 和 setter 都是可选的. 如果可以从初始化器推断的话，那么属性的类型也是可选的 (或是像下面一样，从getter的返回类型中获取).

例如：

var allByDefault: Int? // 错误：需要显示的初始化器,getter 和 setter 默认是隐式的。

var initialized = 1 // 类型为 Int，默认的 getter 和 setter

声明只读属性的完整语法和可修改属性有以下两方面不同: 它以 val 开始而不是 var 并且不允许拥有 setter：

val simple: Int? // Int类型， 默认的 getter， 必须在构造函数中初始化

val inferredType = 1 // Int类型和一个默认的 getter

我们可以在属性声明的内部自定义属性访问器，和普通的函数十分相似。 这儿有一个自定义 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 类型

如果你想改变一个属性的可见性，或是为它添加注解， 但是不需要改变默认的实现， 你可以定义访问器时不去定义它的主体部分：

var setterVisibility: String = "abc"

private set //setter 是私有的并且拥有默认的实现

var setterWithAnnotation: Any? = null

@Inject set // 使用 Inject setter 标注

辅助字段（backing fields）

Kotlin中的类不能拥有字段。 然而，有时候当我们使用一个属性访问器时必须有一个辅助字段。因为这些原因， Kotlin提供了一个自动生成的辅助字段，并可以使用 field 标识进行访问：

var counter = 0 // 初始化的值被直接写入到 field 中

set(value) {

if (value >= 0) field = value

}

field 标识仅仅能在属性访问器中使用。

如有有一个访问器使用了默认的实现，属性就会生成一个辅助字段，或是有一个自定义的访问器通过 field 标识引用它。

例如，下面这种情况就没有辅助字段：

val isEmpty: Boolean

get() = this.size == 0

辅助属性

如果你想做的事不符合这条 "隐式辅助字段" 的规则，你可以退一步使用 辅助字段:

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 进行修饰。这种属性需要完全满足一下几种要求：

• 位于顶层或是一个对象的成员

• 使用String 或者原声类型的值进行初始化

• 没有自定义 getter

属性也可在注解中进行使用：

const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated"

@Deprecated(SUBSYSTEM_DEPRECATED) fun foo() { ... }

延迟初始化属性

一般来说， 属性声明后必须在构造函数中初始化一个非空类型。 然而，公平的说这样子往往是很不方便的。 举个例子， 属性可以通过独立的注入进行初始化， 或是通过 unit test 中的 setup 方法。在这些情况下， 你无法在构造函数中提供非空构造器， 但是你仍然想引用类内部的属性和防止空值检验。

为了解决这种情况，你可以使用 lateinit 修饰符标记那个属性：

public class MyTest {

lateinit var subject: TestSubject

@SetUp fun setup() {

subject = TestSubject()

}

@Test fun test() {

subject.method()// 直接使用

}

}

这个修饰符只能用在类体内部使用 var 声明的属性 (不在主构造器中)， 并且不能有自定义的 getter 和 setter。 属性的类型必须是非空的，它还不能是原生类型。

在被初始化之前访问一个 lateinit 属性会抛出一个特定的以异常：" clearly identifies the property being accessed and the fact that it hasn't been initialized"（属性在未被初始化的情形下被访问）。

属性继承

参照 属性重载

属性委托

绝大多数公有类型的属性都是简单的从一个辅助字段中读取（或写入。另一方面，通过自定义 getters and setters 可以实现属性的任意行为。介于两者之间的，属性可能有一些公共的工作模式。例如： lazy values、通过一个给定的 key 从 map 中读取、访问一个数据库、访问时通知监听器等等。

这些公有的行为可以通过使用 属性委托 实现成库

接口

Kotlin中的接口和Java8非常相似。他们包含抽象方法的声明， 以及方法的实现。和抽象类不同之处在于接口不能保存状态。它们可以拥有属性，但必须是抽象的或是提供访问器的实现。

使用interface关键字来定义一个接口：

interface MyInterface {

fun bar()

fun foo() {

// optional body

}

}

接口实现

一个类或对象可以实现一个或多个接口。

class Child : MyInterface {

override fun bar() {

// body

}

}

接口中的属性

你可以在接口中声明属性。 接口中声明的属性可以是抽象的， 或是提供访问器的实现。 接口中声明的属性没有辅助（backing）字段， 所以不能在接口中声明的访问器里引用它们。

interface MyInterface {

val prop: Int // 抽象

val propertyWithImplementation: String

get() = "foo"

fun foo() {

print(prop)

}

}

class Child : MyInterface {

override val prop: Int = 29

}

解决重载冲突

当我们在父类型列表中声明了很多类型时， 可能会发生继承的同一种方法却拥有不只一种实现的状况。 例如：

interface A {

fun foo() { print("A") }

fun bar()

}

interface B {

fun foo() { print("B") }

fun bar() { print("bar") }

}

class C : A {

override fun bar() { print("bar") }

}

class D : A, B {

override fun foo() {

super<A>.foo()

super<B>.foo()

}

override fun bar() {

super<B>.bar()

}

}

接口 A 和 B 都声明了函数 foo() 和 bar()。 它们都实现了 foo()，但仅仅只有 B 实现了 bar() (bar() 在 接口 A 中没有标记为抽象， 因为这在接口中是默认的， 前提是该函数没有函数体)。 现在，如果我们从 A 派生一个实体类 C， 显而易见的，我们需要虫子 bar() 函数并且提供一个实现。

然而， 如果我们从 A 和 B 派生出 D ， 我们需要实现从多个接口继承的所有方法。 这条规则适用于我们继承的单一实现的 (bar()) 方法和多实现的 (foo()) 方法。

可见性修饰符

类、对象、接口、构造函数、函数、属性和它们的setter都能拥有 可见性修饰符。（getter 的可见性一般和属性是一样的。）在Kotlin中一共有四种可见性修饰符： private, protected, internal 和 public。在没有任何显示的修饰符的时候，默认的可见性是 public.

接下来，请找出它们对于不同类型声明的作用域的详细说明。

包

函数、属性和类、对象和接口都能在“顶级”声明，也就是说直接在一个包里面声明：

// file name: example.kt

package foo

fun baz() {}

class Bar {}

• 如果你没有明确任何可见性修饰符，默认是使用 public ， 这意味这个声明到处都是可见的；

• 如果你将某个声明标记为 private， 他只能在包含这个声明的文件内部可见；

• 如果你将他标记为 internal， 它在同一个 模块的任何地方都是可见的；

• protected 不适合顶级声明。

举个例子：

// file name: example.kt

package foo

private fun foo() {} // 在example.kt内部可见

public var bar: Int = 5 // 该属性到处可见

private set // setter在example.kt内部可见

internal val baz = 6// 在同一个模块内部可见

类和接口

类的内部成员的声明：

• private — 意味着仅仅在类内部可见 (包括它的所有成员)；

• protected — 在 private 的基础上加上子类也可见；

• internal — 在同一模块内部 能看见类的声明，也就能看见 internal 成员;

• public — 在任何类可见的地方，其 public 成员也都可见。

注意： Java的使用者： Kotlin中内部类的私有成员对于外部类是不可见的。

如果你重载了一个 protected 成员并且没有显示的标明可见性，重载的成员的可见性依旧是 protected 。

举个例子：

open class Outer {

private val a = 1

protected open val b = 2

internal val c = 3

val d = 4// 默认是public

protected class Nested {

public val e: Int = 5

}

}

class Subclass : Outer() {

// a 不可见

// b, c 和 d 可见

// Nested 和 e 可见

override val b = 5 // 'b' 是 protected

}

class Unrelated(o: Outer) {

// o.a, o.b 不可见

// o.c 和 o.d 是可见的 (同一个模块)

// Outer.Nested 是不可见的， 并且 Nested::e 同样不可见

}

构造函数

想要确定一个类的主构造函数的可见性，请使用以下语法（注意：你需要显示的添加constructor关键字）：

class C private constructor(a: Int) { ... }

这个构造函数的私有的。 默认情况下，所有构造函数都是 public， 只要是类可见的地方它也同样可见 (也就是说，一个 internal 类的构造函数只在同一个模块内可见 )。

局部声明

局部变量、函数和类都没有可见性修饰符

模块

internal 可见性修饰符意味着，在同一个模块内的成员可见。 更加具体点，一个模块是经过编译了的Kotlin文件的集合：

• 一个 IntelliJ IDEA 模块；

• 一个 Maven 工程；

• 一个 Gradle 源码集合；

• 一个 Ant 任务编译的文件集合。