面向对象

包与类的定义

同 Java 类似, 一个类的完整路径包含包名, 比如:

app.kt

import com.test.Test
fun main(args: Array<String>) {
    var test = Test()
    test.foo()
}

注意创建类的实例不需要使用 new 关键字

test.kt

package com.test
class Test() {
    fun foo() { print("Test") }
}

如果没有指定包,默认为 default 包。

默认导入

有多个包会默认导入到每个 Kotlin 文件中:

kotlin.*
kotlin.annotation.*
kotlin.collections.*
kotlin.comparisons.*
kotlin.io.*
kotlin.ranges.*
kotlin.sequences.*
kotlin.text.*

类的属性及实例方法

一个基本的类的定义示例:

test.kt

package com.test
class Person constructor(firstName: String, lastName: String) {
    private var name: String = ""
    val type: String = "Animal"
    var age: Int = 22
    init {
        this.name = firstName + lastName
        println("My name is ${firstName + lastName}")
    }
    fun foo() { println("${this.name}") } // 成员函数
}

app.kt

import com.test.*
fun main(args: Array<String>) {
    var person = Person("Quan", "Zaiyu")
    person.foo() // Test
    println(person.type) // Animal
    println(person.age) // 22
//    print(person.name) // Error
}

成员属性

  • 使用关键字 var 声明为可变的
  • 使用关键字 val 声明为不可变

访问权限修饰符(accessModifier)

  • private 仅在同一个文件中可见
  • protected 同一个文件中或子类可见
  • public 所有调用的地方都可见
  • internal 同一个模块中可见

类属性修饰符(classModifier)

  • abstract 抽象类
  • final 类不可继承,默认属性
  • enum 枚举类
  • open 类可继承,类默认是final的
  • annotation 注解类

构造函数

主构造器

class Person constructor(firstName: String, lastName: String) {
    var name: String = ""
    init {
        this.name = firstName + lastName
        println("My name is ${this.name}")
    }
}

次构造函数

class Person {
    var name: String = ""
    constructor(firstName: String, lastName: String) {
        this.name = firstName + lastName
        println("My name is ${this.name}")
    }
}

多个构造器

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

class Person constructor(name: String) {
    init {
        println("My name is: ${name}")
    }
    // 次构造函数
    constructor (name: String, age: Int) : this(name) {
        println("My age is $age")
    }
    constructor (name: String, sex: String) : this(name) {
        println("My sex is $sex")
    }
}
fun main(args: Array<String>) {
    Person("Xiaoyu") // My name is: Xiaoyu
    Person("Xiaoyu", 23) // My name is: Xiaoyu      My age is 23
    Person("Xiaoyu", "男") // My name is: Xiaoyu     My sex is 男
}

继承

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<String>) {
    val s =  Student("Runoob", 18, "S12346", 89)
    println("学生名: ${s.name}")
    println("年龄: ${s.age}")
    println("学生号: ${s.no}")
    println("成绩: ${s.score}")
}

子类没有主构造函数

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

/**用户基类**/
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<String>) {
    var s =  Student("Runoob", 18, "S12345", 89)
}

注意

子类继承父类时,不能有跟父类同名的变量,除非父类中该变量为 private,或者父类中该变量为 open 并且子类用 override 关键字重写

重写

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

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

如果有多个相同的方法(继承或者实现自其他类,如A、B类),则必须要重写该方法,重写使用 override 关键字,使用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<A>.f()//调用 A.f()
        super<B>.f()//调用 B.f()
    }
}
fun main(args: Array<String>) {
    val c =  C()
    c.f() // AB
    c.a() // a
    c.b() // b
}

接口

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

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

接口中的属性

接口中的属性只能是抽象的,不允许初始化值,接口不会保存属性值,实现接口时,必须重写属性, 且必须具有兼容类型:

interface Foo {
    val count: Int // count 属性, 抽象的
}
class Bar : Foo {
    override var count: Int = 0 //重写属性
}

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

注意

子类不能用 val 重写父类中的 var

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

interface Foo {
    val count: Int
}
class Bar(override val count: Int) : Foo

Getter 和 Setter

属性声明的完整语法:

var <propertyName>[: <PropertyType>] [= <property_initializer>]
    [<getter>]
    [<setter>]

getter 和 setter 都是可选

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

Kotlin 中类不能有字段。提供了 Backing Fields(后端变量) 机制,备用字段使用field关键字声明,field 关键词只能用于属性的访问器。

fun main(args: Array<String>) {
    var person: Person = Person()
    person.lastName = "wang"
    println("lastName:${person.lastName}")
    person.no = 9
    println("no:${person.no}")
    person.no = 20
    println("no:${person.no}")
}
class Person {
    var lastName: String = "zhang"
        get() = field.toUpperCase()   // 将变量赋值后转换为大写
        set
    var no: Int = 100
        get() = field                 // 后端变量
        set(value) {
            if (value < 10) {         // 如果传入的值小于 10 返回该值
                field = value
            } else {
                field = -1            // 如果传入的值大于等于 10 返回 -1
            }
        }
    var height: Float = 145.4f
        private set
}

MIT Licensed | Copyright © 2018-present 滇ICP备16006294号

Design by Quanzaiyu | Power by VuePress