Kotlin 基础语法-02

类和对象

类的属性

属性定义

类的属性可以用关键字 var 声明为可变的，否则使用只读关键字 val 声明为不可变。

class Runoob {    var name: String = ……    var url: String = ……    var city: String = ……}

我们可以像使用普通函数那样使用构造函数创建类实例：

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

要使用一个属性，只要用名称引用它即可

site.name           // 使用 . 号来引用site.url

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

class Person constructor(firstName: String) {}

如果主构造器没有任何注解，也没有任何可见度修饰符，那么constructor关键字可以省略。

class Person(firstName: String) {}

getter 和 setter

属性声明的完整语法：

var [: ] [= ]    []    [] 

getter 和 setter 都是可选如果属性类型可以从初始化语句或者类的成员函数中推断出来，那就可以省去类型，val不允许设置setter函数，以为它是只读的。

var allByDefault: Int? // 错误: 需要一个初始化语句, 默认实现了 getter 和 setter 方法var initialized = 1    // 类型为 Int, 默认实现了 getter 和 setterval simple: Int?       // 类型为 Int ，默认实现 getter ，但必须在构造函数中初始化val inferredType = 1   // 类型为 Int 类型,默认实现 getter

实例

以下实例定义了一个 Person 类，包含两个可变变量 lastName 和 no，lastName 修改了 getter 方法，no 修改了 setter 方法。

class Person {    var lastName: String = "zhang"        get() = field.toUpperCase()   // 将变量赋值后转换为大写        set    var no: Int = 100        get() = field                // 后端变量        set(value) {            if (value 

主构造器

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

class Person constructor(firstName: String) {    init {        System.out.print("FirstName is $firstName")    }}

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

class People(val firstName: String, val lastName: String) {    //...}

如果构造器有注解，或者有可见度修饰符，这时constructor关键字是必须的，注解和修饰符要放在它之前。

实例

创建一个 Runoob类，并通过构造函数传入网站名：

class Runoob  constructor(name: String) {  // 类名为 Runoob    // 大括号内是类体构成    var url: String = "http://www.runoob.com"    var country: String = "CN"    var siteName = name    init {        println("初始化网站名: ${name}")    }    fun printTest() {        println("我是类的函数")    }}fun main(args: Array) {    val runoob =  Runoob("菜鸟教程")    println(runoob.siteName)    println(runoob.url)    println(runoob.country)    runoob.printTest()}

输出结果为：

初始化网站名: 菜鸟教程菜鸟教程http://www.runoob.comCN我是类的函数

---

次构造函数

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

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

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

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

如果一个非抽象类没有声明构造函数(主构造函数或次构造函数)，它会产生一个没有参数的构造函数。构造函数是 public 。如果你不想你的类有公共的构造函数，你就得声明一个空的主构造函数：

class DontCreateMe private constructor () {}

注意：在 JVM 虚拟机中，如果主构造函数的所有参数都有默认值，编译器会生成一个附加的无参的构造函数，这个构造函数会直接使用默认值。这使得 Kotlin 可以更简单的使用像 Jackson 或者 JPA 这样使用无参构造函数来创建类实例的库。

class Customer(val customerName: String = "")

实例

class Runoob  constructor(name: String) {  // 类名为 Runoob    // 大括号内是类体构成    var url: String = "http://www.runoob.com"    var country: String = "CN"    var siteName = name    init {        println("初始化网站名: ${name}")    }    // 次构造函数    constructor (name: String, alexa: Int) : this(name) {        println("Alexa 排名 $alexa")    }    fun printTest() {        println("我是类的函数")    }}fun main(args: Array) {    val runoob =  Runoob("菜鸟教程", 10000)    println(runoob.siteName)    println(runoob.url)    println(runoob.country)    runoob.printTest()}

输出结果为：

初始化网站名: 菜鸟教程Alexa 排名 10000菜鸟教程http://www.runoob.comCN我是类的函数

---

抽象类

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

注意：无需对抽象类或抽象成员标注open注解。

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

---

嵌套类

我们可以把类嵌套在其他类中，看以下实例：

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 Outer {    private val bar: Int = 1    var v = "成员属性"    /**嵌套内部类**/    inner class Inner {        fun foo() = bar  // 访问外部类成员        fun innerTest() {            var o = this@Outer //获取外部类的成员变量            println("内部类可以引用外部类的成员，例如：" + o.v)        }    }}fun main(args: Array) {    val demo = Outer().Inner().foo()    println(demo) //   1    val demo2 = Outer().Inner().innerTest()       println(demo2)   // 内部类可以引用外部类的成员，例如：成员属性}

为了消除歧义，要访问来自外部作用域的 this，我们使用this@label，其中 @label 是一个 代指 this 来源的标签。

---

匿名内部类

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

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   // 同一个模块中可见

实例

// 文件名：example.ktpackage fooprivate fun foo() {} // 在 example.kt 内可见public var bar: Int = 5 // 该属性随处可见internal val baz = 6    // 相同模块内可见

Kotlin 继承

Kotlin 中所有类都继承该 Any 类，它是所有类的超类，对于没有超类型声明的类是默认超类：

class Example // 从 Any 隐式继承

Any 默认提供了三个函数：

equals()hashCode()toString()

注意：Any 不是 java.lang.Object。

如果一个类要被继承，可以使用 open 关键字进行修饰。

open class Base(p: Int)           // 定义基类class Derived(p: Int) : Base(p)

---

构造函数

子类有主构造函数

如果子类有主构造函数， 则基类必须在主构造函数中立即初始化。

open class Person(var name : String, var age : Int){// 基类}class Student(name : String, age : Int, var no : String, var score : Int) : Person(name, age) {}// 测试fun main(args: Array) {    val s =  Student("Runoob", 18, "S12346", 89)    println("学生名： ${s.name}")    println("年龄： ${s.age}")    println("学生号： ${s.no}")    println("成绩： ${s.score}")}

输出结果：

学生名： Runoob年龄： 18学生号： S12346成绩： 89

子类没有主构造函数

如果子类没有主构造函数，则必须在每一个二级构造函数中用 super 关键字初始化基类，或者在代理另一个构造函数。初始化基类时，可以调用基类的不同构造方法。

calss Student : Person {    constructor(ctx: Context) : super(ctx) {    }     constructor(ctx: Context, attrs: AttributeSet) : super(ctx,attrs) {    }}

实例

/**用户基类**/open class Person(name:String){    /**次级构造函数**/    constructor(name:String,age:Int):this(name){        //初始化        println("-------基类次级构造函数---------")    }}/**子类继承 Person 类**/class Student:Person{    /**次级构造函数**/    constructor(name:String,age:Int,no:String,score:Int):super(name,age){        println("-------继承类次级构造函数---------")        println("学生名： ${name}")        println("年龄： ${age}")        println("学生号： ${no}")        println("成绩： ${score}")    }}fun main(args: Array) {    var s =  Student("Runoob", 18, "S12345", 89)}

输出结果：

-------基类次级构造函数----------------继承类次级构造函数---------学生名： Runoob年龄： 18学生号： S12345成绩： 89

---

重写

在基类中，使用fun声明函数时，此函数默认为final修饰，不能被子类重写。如果允许子类重写该函数，那么就要手动添加 open 修饰它, 子类重写方法使用 override 关键词：

/**用户基类**/open class Person{    open fun study(){       // 允许子类重写        println("我毕业了")    }}/**子类继承 Person 类**/class Student : Person() {    override fun study(){    // 重写方法        println("我在读大学")    }}fun main(args: Array) {    val s =  Student()    s.study();}

输出结果为:

我在读大学

如果有多个相同的方法（继承或者实现自其他类，如A、B类），则必须要重写该方法，使用super范型去选择性地调用父类的实现。

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{    override fun f() {        super.f()//调用 A.f()        super.f()//调用 B.f()    }}fun main(args: Array) {    val c =  C()    c.f();}

C 继承自 a() 或 b(), C 不仅可以从 A 或则 B 中继承函数，而且 C 可以继承 A()、B() 中共有的函数。此时该函数在中只有一个实现，为了消除歧义，该函数必须调用A()和B()中该函数的实现，并提供自己的实现。

输出结果为:

AB

* * *## 属性重写属性重写使用 override 关键字，属性必须具有兼容类型，每一个声明的属性都可以通过初始化程序或者getter方法被重写：

open class Foo {    open val x: Int get { …… }}class Bar1 : Foo() {    override val x: Int = ……}

你可以用一个var属性重写一个val属性，但是反过来不行。因为val属性本身定义了getter方法，重写为var属性会在衍生类中额外声明一个setter方法

你可以在主构造函数中使用 override 关键字作为属性声明的一部分:

interface Foo {    val count: Int}class Bar1(override val count: Int) : Fooclass Bar2 : Foo {    override var count: Int = 0}

Kotlin 接口

Kotlin 接口与 Java 8 类似，使用 interface 关键字定义接口，允许方法有默认实现：

interface MyInterface {    fun bar()    // 未实现    fun foo() {  //已实现      // 可选的方法体      println("foo")    }}

实现接口

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

class Child : MyInterface {    override fun bar() {        // 方法体    }}

实例

interface MyInterface {    fun bar()    fun foo() {        // 可选的方法体        println("foo")    }}class Child : MyInterface {    override fun bar() {        // 方法体        println("bar")    }}fun main(args: Array<String>) {    val c =  Child()    c.foo();    c.bar();}输出结果为：foobar

接口中的属性

接口中的属性只能是抽象的，不允许初始化值，接口不会保存属性值，实现接口时，必须重写属性：

interface MyInterface{    var name:String //name 属性, 抽象的}class MyImpl:MyInterface{    override var name: String = "runoob" //重载属性}

实例

interface MyInterface {    var name:String //name 属性, 抽象的    fun bar()    fun foo() {        // 可选的方法体        println("foo")    }}class Child : MyInterface {    override var name: String = "runoob" //重载属性    override fun bar() {        // 方法体        println("bar")    }}fun main(args: Array<String>) {    val c =  Child()    c.foo();    c.bar();    println(c.name)}输出结果为：foobarrunoob

函数重写

实现多个接口时，可能会遇到同一方法继承多个实现的问题。例如:
实例

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()    }}fun main(args: Array<String>) {    val d =  D()    d.foo();    d.bar();}输出结果为：ABbar

实例中接口 A 和 B 都定义了方法 foo() 和 bar()， 两者都实现了 foo(), B 实现了 bar()。因为 C 是一个实现了 A 的具体类，所以必须要重写 bar() 并实现这个抽象方法。

然而，如果我们从 A 和 B 派生 D，我们需要实现多个接口继承的所有方法，并指明 D 应该如何实现它们。这一规则 既适用于继承单个实现（bar()）的方法也适用于继承多个实现（foo()）的方法。

Kotlin 扩展

Kotlin 可以对一个类的属性和方法进行扩展，且不需要继承或使用 Decorator 模式。

扩展是一种静态行为，对被扩展的类代码本身不会造成任何影响。

---

扩展函数

扩展函数可以在已有类中添加新的方法，不会对原类做修改，扩展函数定义形式：

fun receiverType.functionName(params){    body}

• receiverType：表示函数的接收者，也就是函数扩展的对象
• functionName：扩展函数的名称
• params：扩展函数的参数，可以为NULL

以下实例扩展 User 类 ：

class User(var name:String)/**扩展函数**/fun User.Print(){    print("用户名 $name")}fun main(arg:Array){    var user = User("Runoob")    user.Print()}

实例执行输出结果为：

用户名 Runoob

下面代码为 MutableList 添加一个swap 函数：

// 扩展函数 swap,调换不同位置的值fun MutableList.swap(index1: Int, index2: Int) {    val tmp = this[index1]     //  this 对应该列表    this[index1] = this[index2]    this[index2] = tmp}fun main(args: Array) {    val l = mutableListOf(1, 2, 3)    // 位置 0 和 2 的值做了互换    l.swap(0, 2) // 'swap()' 函数内的 'this' 将指向 'l' 的值    println(l.toString())}

实例执行输出结果为：

[3, 2, 1]

this关键字指代接收者对象(receiver object)(也就是调用扩展函数时, 在点号之前指定的对象实例)。

---

扩展函数是静态解析的

扩展函数是静态解析的，并不是接收者类型的虚拟成员，在调用扩展函数时，具体被调用的的是哪一个函数，由调用函数的的对象表达式来决定的，而不是动态的类型决定的:

open class Cclass D: C()fun C.foo() = "c"   // 扩展函数 foofun D.foo() = "d"   // 扩展函数 foofun printFoo(c: C) {    println(c.foo())  // 类型是 C 类}fun main(arg:Array){    printFoo(D())}

实例执行输出结果为：

c

若扩展函数和成员函数一致，则使用该函数时，会优先使用成员函数。

class C {    fun foo() { println("成员函数") }}fun C.foo() { println("扩展函数") }fun main(arg:Array){    var c = C()    c.foo()}

实例执行输出结果为：

成员函数

扩展一个空对象

在扩展函数内， 可以通过 this 来判断接收者是否为 NULL,这样，即使接收者为 NULL,也可以调用扩展函数。例如:

fun Any?.toString(): String {    if (this == null) return "null"    // 空检测之后，“this”会自动转换为非空类型，所以下面的 toString()    // 解析为 Any 类的成员函数    return toString()}fun main(arg:Array){    var t = null    println(t.toString())}

实例执行输出结果为：

null

---

扩展属性

除了函数，Kotlin 也支持属性对属性进行扩展:

val  List.lastIndex: Int    get() = size - 1 

扩展属性允许定义在类或者kotlin文件中，不允许定义在函数中。初始化属性因为属性没有后端字段（backing field），所以不允许被初始化，只能由显式提供的 getter/setter 定义。

val Foo.bar = 1 // 错误：扩展属性不能有初始化器

扩展属性只能被声明为 val。

---

伴生对象的扩展

如果一个类定义有一个伴生对象 ，你也可以为伴生对象定义扩展函数和属性。

伴生对象通过”类名.”形式调用伴生对象，伴生对象声明的扩展函数，通过用类名限定符来调用：

class MyClass {    companion object { }  // 将被称为 "Companion"}fun MyClass.Companion.foo() {    println("伴随对象的扩展函数")}val MyClass.Companion.no: Int    get() = 10fun main(args: Array) {    println("no:${MyClass.no}")    MyClass.foo()}

实例执行输出结果为：

no:10伴随对象的扩展函数

---

扩展的作用域

通常扩展函数或属性定义在顶级包下:

package foo.barfun Baz.goo() { …… } 

要使用所定义包之外的一个扩展, 通过import导入扩展的函数名进行使用:

package com.example.usageimport foo.bar.goo // 导入所有名为 goo 的扩展                   // 或者import foo.bar.*   // 从 foo.bar 导入一切fun usage(baz: Baz) {    baz.goo()}

---

扩展声明为成员

在一个类内部你可以为另一个类声明扩展。

在这个扩展中，有个多个隐含的接受者，其中扩展方法定义所在类的实例称为分发接受者，而扩展方法的目标类型的实例称为扩展接受者。

class D {    fun bar() { println("D bar") }}class C {    fun baz() { println("C baz") }    fun D.foo() {        bar()   // 调用 D.bar        baz()   // 调用 C.baz    }    fun caller(d: D) {        d.foo()   // 调用扩展函数    }}fun main(args: Array) {    val c: C = C()    val d: D = D()    c.caller(d)}

实例执行输出结果为：

D barC baz

在 C 类内，创建了 D 类的扩展。此时，C 被成为分发接受者，而 D 为扩展接受者。从上例中，可以清楚的看到，在扩展函数中，可以调用派发接收者的成员函数。

假如在调用某一个函数，而该函数在分发接受者和扩展接受者均存在，则以扩展接收者优先，要引用分发接收者的成员你可以使用限定的 this 语法。

class D {    fun bar() { println("D bar") }}class C {    fun bar() { println("C bar") }  // 与 D 类 的 bar 同名    fun D.foo() {        bar()         // 调用 D.bar()，扩展接收者优先        [e-mail]()  // 调用 C.bar()    }    fun caller(d: D) {        d.foo()   // 调用扩展函数    }}fun main(args: Array) {    val c: C = C()    val d: D = D()    c.caller(d)}

实例执行输出结果为：

D barC bar

以成员的形式定义的扩展函数, 可以声明为 open , 而且可以在子类中覆盖. 也就是说, 在这类扩展函数的派 发过程中, 针对分发接受者是虚拟的(virtual), 但针对扩展接受者仍然是静态的。

open class D {}class D1 : D() {}open class C {    open fun D.foo() {        println("D.foo in C")    }    open fun D1.foo() {        println("D1.foo in C")    }    fun caller(d: D) {        d.foo()   // 调用扩展函数    }}class C1 : C() {    override fun D.foo() {        println("D.foo in C1")    }    override fun D1.foo() {        println("D1.foo in C1")    }}fun main(args: Array) {    C().caller(D())   // 输出 "D.foo in C"    C1().caller(D())  // 输出 "D.foo in C1" —— 分发接收者虚拟解析    C().caller(D1())  // 输出 "D.foo in C" —— 扩展接收者静态解析}

实例执行输出结果为：

D.foo in CD.foo in C1D.foo in C