Kotlin 四 接口

时间  2019-11-13
标签 kotlin 接口 繁體版
原文   原文链接

一 接口

 

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

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

　

实现接口

一个类或者对象能够实现一个或多个接口。后端

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

　　

接口中的属性

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

　

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

　

函数重写

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

　

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

　　

实例中接口 A 和 B 都定义了方法 foo() 和 bar()， 二者都实现了 foo(), B 实现了 bar()。由于 C 是一个实现了 A 的具体类，因此必需要重写 bar() 并实现这个抽象方法。this

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

 

二 扩展

Kotlin 能够对一个类的属性和方法进行扩展，且不须要继承或使用 Decorator 模式。设计

扩展是一种静态行为，对被扩展的类代码自己不会形成任何影响。code

 

扩展函数

扩展函数能够在已有类中添加新的方法，不会对原类作修改，扩展函数定义形式：component

fun receiverType.functionName(params){
    body
}
  • receiverType：表示函数的接收者，也就是函数扩展的对象
  • functionName：扩展函数的名称
  • params：扩展函数的参数，能够为NULL

如下实例扩展 User 类 ：对象

　　

class User(var name:String)

/**扩展函数**/
fun User.Print(){
    print("用户名 $name")
}

fun main(arg:Array<String>){
    var user = User("Runoob")
    user.Print()
}

　　

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

// 扩展函数 swap,调换不一样位置的值
fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1]     //  this 对应该列表
    this[index1] = this[index2]
    this[index2] = tmp
}

fun main(args: Array<String>) {

    val l = mutableListOf(1, 2, 3)
    // 位置 0 和 2 的值作了互换
    l.swap(0, 2) // 'swap()' 函数内的 'this' 将指向 'l' 的值

    println(l.toString())
}

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

扩展函数是静态解析的

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

open class C

class D: C()

fun C.foo() = "c"   // 扩展函数 foo

fun D.foo() = "d"   // 扩展函数 foo

fun printFoo(c: C) {
    println(c.foo())  // 类型是 C 类
}

fun main(arg:Array<String>){
    printFoo(D()) //c
}

　　

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

class C {
    fun foo() { println("成员函数") }
}

fun C.foo() { println("扩展函数") }

fun main(arg:Array<String>){
    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<String>){
    var t = null
    println(t.toString())
}

　>扩展属性

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

val <T> List<T>.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() = 10

fun main(args: Array<String>) {
    println("no:${MyClass.no}")
    MyClass.foo()
}

　　

扩展的做用域

一般扩展函数或属性定义在顶级包下:

package foo.bar

fun Baz.goo() { …… }

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

　

package com.example.usage

import 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<String>) {
    val c: C = C()
    val d: D = D()
    c.caller(d)

}

　　

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

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

以成员的形式定义的扩展函数, 能够声明为 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<String>) {
    C().caller(D())   // 输出 "D.foo in C"
    C1().caller(D())  // 输出 "D.foo in C1" —— 分发接收者虚拟解析
    C().caller(D1())  // 输出 "D.foo in C" —— 扩展接收者静态解析

}

　　

三 数据类和密封类

数据类

Kotlin 能够建立一个只包含数据的类，关键字为 data：

data class User(val name: String, val age: Int)

　

编译器会自动的从主构造函数中根据全部声明的属性提取如下函数：

  • equals() / hashCode()
  • toString() 格式如 "User(name=John, age=42)"
  • componentN() functions 对应于属性，按声明顺序排列
  • copy() 函数

若是这些函数在类中已经被明肯定义了，或者从超类中继承而来，就再也不会生成。

为了保证生成代码的一致性以及有意义，数据类须要知足如下条件：

  • 主构造函数至少包含一个参数。

  • 全部的主构造函数的参数必须标识为val 或者 var ;

  • 数据类不能够声明为 abstract, open, sealed 或者 inner;

  • 数据类不能继承其余类 (可是能够实现接口)。

复制

复制使用 copy() 函数，咱们可使用该函数复制对象并修改部分属性, 对于上文的 User 类，其实现会相似下面这样：

fun copy(name: String = this.name, age: Int = this.age) = User(name, age)

　

实例

使用 copy 类复制 User 数据类，并修改 age 属性:

data class User(val name: String, val age: Int)

fun main(args: Array<String>) {
    val jack = User(name = "Jack", age = 1)
    val olderJack = jack.copy(age = 2)
    println(jack)
    println(olderJack)

}

数据类以及解构声明

组件函数容许数据类在解构声明中使用：

val jane = User("Jane", 35)
val (name, age) = jane
println("$name, $age years of age") // prints "Jane, 35 years of age"

标准数据类

标准库提供了 Pair 和 Triple 。在大多数情形中，命名数据类是更好的设计选择，由于这样代码可读性更强并且提供了有意义的名字和属性。

　　

　　

密封类

密封类用来表示受限的类继承结构：当一个值为有限几种的类型, 而不能有任何其余类型时。在某种意义上，他们是枚举类的扩展：枚举类型的值集合 也是受限的，但每一个枚举常量只存在一个实例，而密封类 的一个子类能够有可包含状态的多个实例。

声明一个密封类，使用 sealed 修饰类，密封类能够有子类，可是全部的子类都必需要内嵌在密封类中。

sealed 不能修饰 interface ,abstract class(会报 warning,可是不会出现编译错误)

　

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

fun eval(expr: Expr): Double = when (expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
 // 再也不须要 `else` 子句，由于咱们已经覆盖了全部的状况
}

　使用密封类的关键好处在于使用 when 表达式 的时候，若是可以 验证语句覆盖了全部状况，就不须要为该语句再添加一个 else 子句了。　

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程