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) {
  printFoo(D())
}

输出结果:

c
  • 扩展函数可以与类的成员函数同名,优先调用成员函数,如果是成员函数的重载,可以被调用。
class C {
    //成员函数
    fun foo() { println("member") }
}
//扩展同名函数
fun C.foo() { println("extension") }
//扩展同名函数重载
fun C.foo(str:String){
    println(str)
}

fun main(args: Array) {
    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) {
    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() {
        //限定符指定访问
        [email protected]()
        //扩展接受者
        bar()   // 调用 D.bar
        //分发接收者
        baz()   // 调用 C.baz
    }

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


fun main(args: Array) {
    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

你可能感兴趣的:(Kotlin-Anko学习(6)Kotlin语法-修饰符、扩展)