1. 类
Kotlin 中使用关键字class 声明类
class Person {
}
类声明由类名、类头（指定其类型参数、主 构造函数等）和由大括号包围的类体构成。类头和类体都是可选的； 如果一个类没有类体，可以省略花括号。
class Person
2.构造函数
在 Kotlin 中的一个类可以有一个主构造函数和一个或多个次构造函数。主构造函数是类头的一部分：它跟在类名（和可选的类型参数）后。
class Person constructor(firstName: String) {
}
如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字。
class Person(firstName: String) {
}
主构造函数不能包含任何的代码。初始化的代码可以放 到以 init 关键字作为前缀的初始化块（initializer blocks）中：
class Person ( name:String, age:Int){
constructor(firstName: String) {
init {
println("firstName is $firstName")
}
}
主构造的参数可以在初始化块中使用。它们也可以在 类体内声明的属性初始化中使用：
class Person ( name:String, age:Int){
val name:String = name
val age:Int = age
}
如果主构造函数中定义的参数使用 val 或者 var 修饰，则会创建与这个参数同名的成员变量，并使用传入的参数值初始化这个成员变量。
class Person (val name:String,val age:Int)//等价于上面的代码
如果类有一个主构造函数，每个次构造函数需要委托给主构造函数， 可以直接委托或者通过别的次构造函数间接委托。委托到同一个类的另一个构造函数用 this 关键字即可：
class Person ( name:String, age:Int){
init {
println("name is $name,age is $age")
}
constructor(name:String,age:Int,id:Int):this(name,age){
println("id is $id")
}
}
3.创建类的实例
val person= Person("mlk",28,1)//name is mlk,age is 28
//id is 1
person.age
person.name
4.属性
声明一个属性的完整语法
var <propertyName>[: <PropertyType>] [= <property_initializer>]
[<getter>]
[<setter>]
其初始器（initializer）、getter 和 setter 都是可选的。属性类型如果可以从初始器 （或者从其 getter 返回值，如下文所示）中推断出来，也可以省略。
val定义只读属性，var定义可读写属性。
我们可以编写自定义的访问器，非常像普通函数，刚好在属性声明内部。这里有一个自定义 getter 的例子:
class Person(val name: String) {
val isEmpty: Boolean //自定义访问器
get() = name.length == 0
}
val person= Person("")
println("${person.isEmpty}")//true
4.1幕后字段
首先要明确什么是字段，什么是属性，其实这一点在 C# 语言当中有更好的体现：
- 字段是实际存储在内存中的变量，并且是私有的可以直接访问的变量，通常命名前带有“_”符号
- 属性是不占用实际内存的，它提供对字段的访问方法，实际是对字段和访问方法的封装，因此属性会有只读、只写、读/写等类型
而在 Kotlin 中，属性既可以直接存储值，也可以利用字段来存储值的，但是这里字段没有显式表达出来，因此叫做幕后字段，幕后字段的产生是有条件的，必须满足下面两个条件之一：
- 属性至少有一个访问器采用默认实现
- 自定义访问器通过 field 引用幕后字段
class Person{
var name: String =""
get() = field
set(value) {
field = value //使用field引用幕后字段
}
}
幕后字段是非常重要的，因为在在属性的 get 和 set 方法中，不能直接使用该属性，否则会发生栈溢出错误，这时就只能用幕后字段来操作相应的值。
4.2幕后属性
class Person{
var _name:String = ""
var name: String
get() = this._name
set(value) {
this._name = value
}
}
4.3 编译期常量
已知值的属性可以使用 const 修饰符标记为 编译期常量。
4.4 延迟初始化属性
一般地，属性声明为非空类型必须在构造函数中初始化。 然而，这经常不方便。例如：属性可以通过依赖注入来初始化， 或者在单元测试的 setup 方法中初始化。 这种情况下，你不能在构造函数内提供一个非空初始器。 但你仍然想在类体中引用该属性时避免空检查。
为处理这种情况，你可以用 lateinit 修饰符标记该属性：
public class MyTest {
lateinit var subject: TestSubject
@SetUp fun setup() {
subject = TestSubject()
}
@Test fun test() {
subject.method() // 直接解引用
}
}
该修饰符只能用于在类体中（不是在主构造函数中）声明的 var 属性，并且仅当该属性没有自定义 getter 或 setter 时。该属性必须是非空类型，并且不能是原生类型。
在初始化前访问一个 lateinit 属性会抛出一个特定异常，该异常明确标识该属性被访问及它没有初始化的事实。
4.5 可观察属性
Delegates.observable()
接受两个参数：初始值和修改时处理程序（handler）。 每当我们给属性赋值时会调用该处理程序（在赋值后执行）。它有三个参数：被赋值的属性、旧值和新值：
package cn.malinkang.kotlin
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("<no name>") {
prop, old, new ->
println("$prop,$old,$new")
}
}
fun main(args: Array<String>) {
val user = User()
user.name = "first"
user.name = "second"
}
//输出结果
//var cn.malinkang.kotlin.User.name: kotlin.String,<no name>,first
//var cn.malinkang.kotlin.User.name: kotlin.String,first,second
4.6 把属性储存在映射中
package cn.malinkang.kotlin
class User(val map: Map<String, Any?>) {
val name: String by map
val age: Int by map
}
fun main(args: Array<String>) {
val user = User(mapOf(
"name" to "John Doe",
"age" to 25
))
println(user.name) //John Doe
println(user.age)// 25
}
4.7 代理属性
class Example {
var p: String by Delegate()
}
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
}
}
val e = Example()
println(e.p)
//输出Example@33a17727, thank you for delegating ‘p’ to me!
5.继承
open class Base(p: Int) //父类
class Derived(p: Int) : Base(p) //子类
类上的 open 标注与 Java 中 final 相反，它允许其他类从这个类继承。默认情况下，在 Kotlin 中所有的类都是 final。
如果该类有一个主构造函数，其基类型并且必须用基类型的主构造函数参数就地初始化。
如果类没有主构造函数，那么每个次构造函数必须使用 super 关键字初始化其基类型，或委托给另一个构造函数做到这一点。 注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数：
class MyView : View {
constructor(ctx: Context) : super(ctx)
constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
}
5.1.覆盖方法
我们之前提到过，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() {}
}
5.2 覆盖属性
属性覆盖与方法覆盖类似；在超类中声明然后在派生类中重新声明的属性必须以 override 开头，并且它们必须具有兼容的类型。每个声明的属性可以由具有初始化器的属性或者具有 getter 方法的属性覆盖。
open class Foo {
open val x: Int =0
}
class Bar1 : Foo() {
override val x: Int =1
}
你也可以用一个 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
}
5.3 覆盖规则
在 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 没问题，并且 a() 和 b() 也没问题因为 C 只继承了每个函数的一个实现。 但是 f() 由 C 继承了两个实现，所以我们必须在 C 中覆盖 f() 并且提供我们自己的实现来消除歧义。
6.抽象类
类和其中的某些成员可以声明为 abstract。 抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用 open 标注一个抽象类或者函数——因为这不言而喻。
我们可以用一个抽象成员覆盖一个非抽象的开放成员
open class Base {
open fun f() {}
}
abstract class Derived : Base() {
override abstract fun f()
}
7.接口
接口定义
interface MyInterface {
fun bar()
fun foo() {
// 可选的方法体
}
}
接口实现
class Child : MyInterface {
override fun bar() {
// 方法体
}
}
你可以在接口中定义属性。在接口中声明的属性要么是抽象的，要么提供访问器的实现。在接口中声明的属性不能有幕后字段（backing field），因此接口中声明的访问器不能引用它们。
interface MyInterface {
val prop: Int // 抽象的
val propertyWithImplementation: String
get() = "foo"
fun foo() {
print(prop)
}
}
class Child : MyInterface {
override val prop: Int = 29
}
8.可见性修饰符
- private：意味着只在这个类内部（包含其所有成员）可见；
- protected：这个类内部及其子类中可见。
- internal：能见到类声明的 本模块内 的任何客户端都可见其 internal 成员；
- public：能见到类声明的任何客户端都可见其 public 成员。
Kotlin 中外部类不能访问内部类的 private 成员。
如果你覆盖一个 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 也不可见
}
9.数据类
我们经常创建一些只保存数据的类。在这些类中，一些标准函数往往是从数据机械推导而来的。在 Kotlin 中，这叫做 数据类 并标记为 data
data class User(val name: String, val age: Int)
编译器自动添加如下方法：
- equals()、hashCode()方法
- toString()格式是 "User(name=John, age=42)"
- componentN()函数 按声明顺序对应于所有属性，
- copy() 函数
如果这些函数中的任何一个在类体中显式定义或继承自其基类型，则不会生成该函数。
为了确保生成的代码的一致性和有意义的行为，数据类必须满足以下要求：
- 主构造函数需要至少有一个参数；
- 主构造函数的所有参数需要标记为 val 或 var；
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)
标准库提供了 Pair 和 Triple。
10.密封类
密封类用来表示受限的类继承结构：当一个值为有限集中的类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展：枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。
要声明一个密封类，需要在类名前面添加 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 的一个额外的新功能：数据类扩展包括密封类在内的其他类的可能性。 ）
请注意，扩展密封类子类的类（间接继承者）可以放在任何位置，而无需在同一个文件中。
使用密封类的关键好处在于使用 when表达式 的时候，如果能够验证语句覆盖了所有情况，就不需要为该语句再添加一个 else
子句了
fun eval(expr: Expr): Double = when(expr) {
is Const -> expr.number
is Sum -> eval(expr.e1) + eval(expr.e2)
NotANumber -> Double.NaN
// 不再需要 `else` 子句，因为我们已经覆盖了所有的情况
}
11.嵌套类
class Outer {
private val bar: Int = 1
class Nested {
fun foo() = 2
}
}
val demo = Outer.Nested().foo() // == 2
类可以标记为 inner 以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用：
private val bar: Int = 1
inner class Inner {
fun foo() = bar
}
}
val demo = Outer().Inner().foo() // == 1
使用对象表达式创建匿名内部类实例：
window.addMouseListener(object: MouseAdapter() {
override fun mouseClicked(e: MouseEvent) {
// ……
}
override fun mouseEntered(e: MouseEvent) {
// ……
}
})
12.枚举类
enum class Direction {
NORTH, SOUTH, WEST, EAST
}
因为每一个枚举都是枚举类的实例，所以他们可以是初始化过的。
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}
枚举常量也可以声明自己的匿名类
enum class ProtocolState {
WAITING {
override fun signal() = TALKING
},
TALKING {
override fun signal() = WAITING
};
abstract fun signal(): ProtocolState
}
及相应的方法、以及覆盖基类的方法。注意，如果枚举类定义任何成员，要使用分号将成员定义中的枚举常量定义分隔开，就像在 Java 中一样。
就像在 Java 中一样，Kotlin 中的枚举类也有合成方法允许列出定义的枚举常量以及通过名称获取枚举常量。这些方法的签名如下（假设枚举类的名称是 EnumClass）：
EnumClass.valueOf(value: String): EnumClass
EnumClass.values(): Array<EnumClass>
