Kotlin-Anko学习(6)Kotlin语法-修饰符、扩展

本系列文章来学习 Kotlin 和 Anko 插件通过 Kotlin 开发一个 Android 项目。

Kotlin-Anko学习(1) Kotlin、Anko 介绍
 Kotlin-Anko学习(2) Kotlin 语法基础-基本类型
 Kotlin-Anko学习(3) Kotlin 语法基础-关键字 package、Import、if、when、for、while、return、break、continue
Kotlin-Anko学习(4) Kotlin语法-类、继承、抽象类
 Kotlin-Anko学习(5) Kotlin语法-属性、字段、接口
 Kotlin-Anko学习(6) Kotlin语法-修饰符、扩展

修饰符

在 Kotlin 中有这四个可见性修饰符：private、 protected、 internal 和 public。如果没有显式指定修饰符的话，默认可见性是 public。其中internal 修饰符的可见性是同一模块，在java 中是没有的。

修饰符的修饰对象：类、对象、接口、构造函数、方法、属性和它们的 setter 都可以有可见性修饰符。（getter 总是与属性有着相同的可见性。）

模块概念

在 Kotlin 中模块指编译在一起的一套 Kotlin 文件：

一个 IntelliJ IDEA 模块
一个 Maven 项目
一个 Gradle 源集
一次＜kotlinc＞ Ant 任务执行所编译的一套文件

顶层声明

在Kotlin 中，可以在包下直接声明函数、属性和类、对象和接口，他们称为顶层声明，尤其是顶层函数、顶层属性、顶层对象是java中不允许的。

顶层声明中的修饰符使用规则：

不指定任何可见性修饰符，默认为public，这意味着你的声明将随处可见
如果你声明为 private，它只会在声明它的文件内可见
如果你声明为 internal，它会在相同模块内随处可见
protected不适用于顶层声明

普通声明

在 Kotlin 中类和接口内部的成员声明与java一样可以可见性修饰

类中修饰符的使用规则：

private ——在这个类内部（包含其所有成员）可见；
protected—— 和 private一样 + 在子类中可见。
internal —— 能见到类声明的本模块内的任何客户端都可见其 internal 成员；
public —— 能见到类声明的任何客户端都可见其 public 成员
内部类—— 外部类不能访问内部类的 private 成员（与java不同）
派生类——子类覆盖一个父类的protected 成员，如果没有指定可见性，那么它在子类中也是protected。

这里可见性的基本使用规则就讲完了。接下来学习扩展的概念

扩展

扩展顾名思义就是增加代码的扩展性，java中我们可以通过继承、装饰者模式来增加类的功能，在Kotlin 中可以通过一个特殊的声明，实现功能的扩展，Kotlin 中有扩展函数和扩展属性。

扩展函数

Kotlin 中，扩展函数写法：" fun 接收者类型. 函数名() "也就是被扩展的类型来作为扩展函数的前缀。

扩展是静态解析的：扩展的方法并没有在类中增加新的成员，只是通过"."表达式来调用这个新函数（即：调用的扩展函数是由函数调用所在的表达式的类型来决定的，而不是由表达式运行时求值结果决定的）

open class C

class D: C()
//C 的扩展函数
fun C.foo() = "c"
//D 的扩展函数
fun D.foo() = "d"
//输入参数的类型 C
fun printFoo(c: C) {
    println(c.foo())
}

fun main(args: Array<String>) {
  printFoo(D())
}

输出结果：

扩展函数可以与类的成员函数同名，优先调用成员函数，如果是成员函数的重载，可以被调用。

class C {
    //成员函数
    fun foo() { println("member") }
}
//扩展同名函数
fun C.foo() { println("extension") }
//扩展同名函数重载
fun C.foo(str:String){
    println(str)
}

fun main(args: Array<String>) {
    var c = C()
    c.foo()
    c.foo("override foo")
}

输出结果：

member
override foo

扩展函数可以定义可空（null）接收者，即可空的接受者类型的扩展函数，在不改变类中函数的情况下，支持可空的类型，空类型的判断在扩展函数内部。

class C {
    fun foo(d :D?){ 
        d.doo()
    }
}
class D {
    fun doo(){
        println("正常输出1")
    }
}
//可空的 doo 扩展函数
fun D?.doo() {
   if(this==null){
       println("为null时输出")
   }else{
       println("正常输出2")
   }
}
fun main(args: Array<String>) {
    var c = C()
    c.foo(null)
    c.foo(D())
}

输出结果：

为null时输出
正常输出2

从上面可以看出，如果D类型为空，调用 d.doo() 的方法就会报错，我们可以定义可空的 doo() 扩展函数解决。Any.toString()就采用此方法来解决接受可空的类型。

扩展属性

扩展属性与扩展函数用法相同，没有实际的将成员插入类中，所以对幕后字段无效的，即：扩展属性不能有初始化器，只能定义显示的get、set方法。

伴生对象扩展

如果类中定义了伴生对象，我们可以扩展伴生对象的函数和属性。

扩展的作用域

对于顶层扩展，在别的包，可以通过导入调用

扩展声明为成员

在一个类内部你可以为另一个类声明扩展。如果存在有多个隐式接收者 —— 其中的对象成员可以无需通过限定符访问。扩展声明所在的类的实例称为分发接收者，扩展方法调用所在的接收者类型的实例称为扩展接收者。分发接收者和扩展接收者的成员名字冲突的情况，扩展接收者优先。也可以通过限定符来指定访问

class D {
    fun bar() { println("d bar") }
}

class C {
    fun baz() { println("c bar") }

    fun D.foo() {
        //限定符指定访问
        this@C.baz()
        //扩展接受者
        bar()   // 调用 D.bar
        //分发接收者
        baz()   // 调用 C.baz
    }

    fun caller(d: D) {
        d.foo()   // 调用扩展函数
    }
}


fun main(args: Array<String>) {
    var c = C()
    c.caller(D())
   
}

输出结果：

c bar
d bar
c bar

动机

动机的理解是优化代码的写法，通过扩展写出更忧的代码。

例如java 中Collections工具类：

// Java
Collections.swap(list, Collections.binarySearch(list, Collections.max(otherList)), Collections.max(list));
// java 通过静态导入包来优化
swap(list, binarySearch(list, max(otherList)), max(list));
// kotlin 扩展优化 
list.swap(list.binarySearch(otherList.max()), list.max());

这里我们介绍完扩展有关的概念，扩展的加入，使得在解决日常问题中，可以更好的处理代码的扩展性。

参考

官方网址：https://www.kotlincn.net