Kotlin类和对象（一）——类与继承

类

Kotlin中使用关键词class声明类。

class Invoice{
}

类的声明有类名、类头（尤其是类型参数、主构造函数等等）、类体组成，用花括号圈起。类头和类体都是可选的，如果类体为空，那么花裤OAO可以省略。

class Empty

构造器

每个类，有一个主构造函数和一个或多个次构造函数。主构造函数是类头的一部分，它在类名称（如果有类型参数）的后面。

class Person constructor(firstName: String) { 
}

如果主构造函数没有任何注解或访问修饰符，那么关键词constructor可以省略。

class Person(firstName: String) { 
}

主构造函数没有任何代码，初始化代码可以发放在用关键词init做前缀的代码块里。

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 Customer public @Inject constructor(name: String) { ... }

声明次构造函数，也需要关键词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) 
    } 
}

如果非抽象类没有声明任何构造函数（主构造函数或次构造函数），它将生成一个没有参数的主构造函数。构造函数的可见性将是公共的。如果不希望你的类有公共的构造函数，你可以声明一个非默认可见性的空主构造函数。

class DontCreateMe private constructor () { //主构造函数不可见
}

注：JVM中，如果主构造函数的所有参数都有默认的值，那么编译器将会附加生成一个无参的构造函数使用这些默认值。这样使Kotlin使用Jackson、JPA这类的库通过无参构造函数创建实例变得很容易。

class Customer(val customerName: String = "")

创建类的实例

像使用普通函数一样，调用构造函数创建实例。

val invoice = Invoice()

val customer = Customer("Joe Smith")

注：Kotlin中没有关键词new。

类成员

类包含：

• 构造函数和初始化代码块
• 函数
• 属性
• 嵌套和内部类
• 对象声明

继承

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。

重写方法

正如我们前面提到的，在kotlin中坚持做明确的事情。不同于Java，Kotlin要求显示注解可重写成员（我们称之为open）然后在重写它。

open class Base { 
    open fun v() {} //fun可以被重写
    fun nv() {} 
} 

class Derived() : Base() {
    override fun v() {} //
}

必须对Derived.v()使用override注解，若注解丢失，编译器就会报错。如果没有对函数使用open注解，像Base.nv()，那么在子类型中不管有没有使用override声明相同名称的方法是非法的。在final类中（即，该类没有open注解）,禁止开放成员。

标记被重写的成员，其本身是开放的。即，它可以在子类中被重写。如果你想禁止它被再次重写，使用关键词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 = ... 
}

通常可以把val属性重写成var属性，反之则不可以。之所以这样是因为，val本质上生成了getter方法，而重写成var属性则在子类中附加声明了setter方法。

interface Foo { 
    val count: Int 
}

class Bar1(override val count: Int) : Foo

class Bar2 : Foo { 
    override var count: Int = 0 
}

重写规则

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时候没问题的。由于C只继承了每个函数的一个实现，所以我们使用a()和b()是没有问题的。但对f()我们有C继承的两个实现，因此我们不得不在C中重写f()和提供自己的实现，消除歧义。

抽象类

一个类或它的某些成员可以被声明成abstract。一个抽象成员在他的类中不能有具体的实现。

我们没必要给抽象类使用open注解——不言而喻。

可以对非抽象的open函数重写成抽象函数。

open class Base { 
    open fun f() {} 
}

abstract class Derived : Base() { 
    override abstract fun f() 
}

伴生对象

Kotlin中，不同于Java或C#，类没有静态方法。在更多场合，要求使用包层级的函数取代。

如果你需要写一个函数调用时不需要类实例但是需要访问到类内部（如：工厂方法），你可以将它作为该类中对象声明的成员编写。

更具体地说，如果你在你的类中声明一个伴生对象，你可以只使用类名作为修饰语调用它的成员，与Java或C#调用静态方法具有相同的语法。