[移动开发]Kotlin学习——类与对象（一）

类与继承

构造函数

在Kotlin中一个类可以有一个主构造函数以及一个或多个次构造函数。主构造函数是类头的一部分：它跟在类名（与可选的类型参数）后

class Person constructor(firstName : String){ /*...*/}

//如果主构造函数没有任何注解或者可见性修饰符，可以省略这个 constructor 关键字
class Person(firstNane: String){/*....*/}

主构造函数不能包含任何的代码。初始化的代码可以放到以 init 关键字作为前缀的初始化块（initializer blocks）中。在实例初始化期间，初始化块按照它们出现在类中的顺序执行，与属性初始化器交织在一起：

class InitOrderDemo(name: String){
    val firstProperty = "First property: $name".also(::println)
    
    init{
        println("First init ${name}")
    }
    
    init{
        println("Second init ${name.length})
    }
}

次构造函数

类也可以声明前缀有 constructor 的次构造函数

class Person{
    var children: MutableList<Person> = mutableListOf<Person>();
    constructor(parent: Person){
        parent.children.add(this)
    }


//如果类有一个主构造函数，每个次构造函数需要委托给主构造函数，
//可以直接委托或者通过别的次构造函数间接委托。
//委托到同一个类的另一个构造函数用 this 关键字即可
    constructor(name: String, parent: Person): this(name){
        parent.children.add(this)
    }
}

初始化块中的代码实际上会成为主构造函数的一部分。委托给主构造函数会作为次构造函数的第一条语句，因此所有初始化块中的代码都会在次构造函数体之前执行。

创建类的实例

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

val invoice = Invoice()
val customer = Customer("Cindy")

继承

在Kotlin中所有类都有一个共同的超类Any，这对于没有超类型声明的类是默认超类

Any有三个方法：equals()、hashCode()、与toString()。因此，所有的Kotlin类都定义了这些方法

class Example //从 Any 隐式继承

//如需声明一个显式的超类型，需在类头中把超类型放到冒号之后：
open class Base(p: Int)

class Derived(p: Int) : Base(p)

//如果派生类有一个主构造函数，其基类可以（并且必须）用派生类主构造函数的参数就地初始化
//如果派生类没有主构造函数，那么每个次构造函数必须使用 super 关键字初始化其基类类型，或委托给另一个构造函数做到这一点。在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数

class MyView : View{
    constructor(ctx: Context) : super(ctx)
}

覆盖方法

对于可覆盖的成员以及覆盖后的成员需要显式修饰符；标记为 override 的成员本身是开放的，如果想禁止再次覆盖，使用 final 关键字

open class Shape{
    open fun draw(){/*...*/}
}

class Circle(): Shape(){
   override fun draw(){ /*...*/}
}

open class Rectangle() : Shape(){
    final override fun draw(){ /*...*/}
}

调用超类实现

派生类中的代码可以使用 super 关键字调用其超类的函数与属性访问器的实现

在一个内部类中访问外部类的超类，可以通过由外部类名限定的 super 关键字来实现： super@Outer

属性与字段

Kotlin类中的属性既可以用关键字var声明为可变的，也可以用关键字val声明为只读的

幕后字段

在Kotlin类中不能直接声明字段。然而，当一个属性需要一个幕后字段时，Kotlin会自动提供。这个幕后字段可以使用 field 标识符在访问器中引用

var counter = 0 //注意：这个初始器直接为幕后字段赋值
    set(value){
        if(value >= 0) field = value
    }

field 标识符只能用在属性的访问器内。如果属性至少一个访问器使用默认实现，或者自定义访问器通过 field 引用幕后字段，将会为该属性生成一个幕后字段

接口的覆盖冲突

实现多个接口时，可能会遇到同一个方法继承多个实现的问题，在下面的代码中，接口A和B都定义了foo() 和bar()，两者都实现了foo()，但是只有B实现了bar()（bar()在A中没有标记为抽象，因为没有方法体时默认为抽象）。因为C是一个实现了A的具体类，所以必须要重写bar() 并实现这个抽象方法。然而如果我们从A和B派生D，我们需要实现从多个接口继承的所有方法，并指明D应该如何实现他们。这一规则即适用于继承单个实现的方法（bar()）也适用于继承多个实现的方法（foo()）。

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()
    }
}

可见性修饰符

对于类内部声明的成员：

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

可见性修饰符 internal 意味着该成员只在相同模块内可见，更具体的说一个模块是编译在一起的一套Kotlin文件