Kotlin笔记（类和对象）

类定义

Kotlin类可以包含：构造函数和初始化代码块、函数、属性、内部类、对象声明。

class Runoob {  // 类名为 Runoob
    // 大括号内是类体构成
}

空类：

class Empty

类的属性

使用构造函数创建类实例：

val site = Runoob() // Kotlin 中没有 new 关键字

Kotlin的类可以有一个主构造器，以及一个或者多个次构造器，主构造器是类头部的一部分，位于类名称之后：

class Person constructor(firstName: String) {}

非空属性必须在定义的时候初始化，Kotlin提供了一种可以延迟初始化的方案，使用lateinit关键字描述属性；

主构造器

主构造器中不能包含任何代码，初始化代码可以放在初始化代码段中，初始化代码段使用init关键字作为前缀。

注意：主构造器的参数可以在初始化代码段中使用，也可以在类主体n定义的属性初始化代码中使用。一种简洁语法，可以通过主构造器来定义属性并初始化属性值（可以是var或val）;

次构造函数

类也可以有二级构造器，需要加前缀constructor:

class Person { 
    constructor(parent: Person) {
        parent.children.add(this) 
    }
}

如果类有主构造函数，每个次构造函数都要，或直接或间接通过另一个次构造函数代理主构造函数。在同一个类中代理另一个构造函数使用this关键字：

class Person(val name: String) {
    constructor (name: String, age:Int) : this(name) {
        // 初始化...
    }
}

抽象类

抽象类是面向对象编程的特征之一，类本身，或类中的部分成员，都可以声明为abstract的，抽象成员在类中不存在具体的实现。无需对抽象类或抽象成员标注open注解。

嵌套类

可以把类嵌套在其他类中：

class Outer {                  // 外部类
    private val bar: Int = 1
    class Nested {             // 嵌套类
        fun foo() = 2
    }
}

fun main(args: Array) {
    val demo = Outer.Nested().foo() // 调用格式：外部类.嵌套类.嵌套类方法/属性
    println(demo)    // == 2
}

内部类

内部类使用inner关键字来表示。

内部类会带一个对外部类的对象的引用，所以内部类可以访问外部类成员属性和成员函数。

匿名内部类

使用对象表达式来创建匿名内部类；

class Test {
    var v = "成员属性"

    fun setInterFace(test: TestInterFace) {
        test.test()
    }
}

/**
 * 定义接口
 */
interface TestInterFace {
    fun test()
}

fun main(args: Array) {
    var test = Test()

    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例。
     */
    test.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })
}

类的修饰符

类的修饰符包括classModifier和_accessModifier_:

classModifier:类属性修饰符，标示类本身特性。

abstract      //抽象类

final         //类不可继承，默认属性

enum    //枚举类

open     //类可继承，类默认是final的

annotation    //注解类

accessModifier:访问权限修饰符

private   //仅在同一个文件中可见

protected   //同一个文件中或子类可见

public   //所有调用的地方都可见

internal    //同一个模块中可见