本节主要介绍kotlin的可见性与kotlin中的扩展功能的使用，包括：扩展类、扩展方法、扩展伴生对象、扩展属性等。

1、kotlin可见性

关键字：
public： 在不低kotlin进行修饰时，默认为 public。
protected ： 不能用在顶层函数或者类上面，用在修饰属性上面，子类和同一个类可以使用。
internal ： 只能在同一个模块下使用，即：整个工程（一个模块）。
private ： 私有的，只能在该文件上可用。

可见性的用法和Java类似：

open class Class {

    private val b = 3

    protected open val c = 4

    internal val d = 5

}

2、kotlin 扩展

如果要对一个类进行扩展，在Java中，我们可以使用 interface，装饰模式来达到目的，但是在kotlin专门提供了扩展的功能。

2.1、扩展类 ：

class ExtensionTest {
    fun add(a: Int, b: Int): Int = a + b
    fun subtract(a: Int, b: Int): Int = a - b
}

现在有个需求要对上面的类添加，乘法和除法功能，在kotlin我们可以直接对该类的方法进行扩展：

/**
 * 扩展类：
 */
class ExtensionTest {
    fun add(a: Int, b: Int): Int = a + b
    fun subtract(a: Int, b: Int): Int = a - b
}

/**
 * 扩展上面类的功能,扩展机制
 */
fun ExtensionTest.multiply(a: Int, b: Int): Int = a * b

fun main() {
    val extensionTest  = ExtensionTest()
    println(extensionTest.add(4,5))
    println(extensionTest.subtract(4,5))
    println(extensionTest.multiply(4,5))
}

以上代码的运行结果如下：

以上代码的运行结果

注意 ：

• 1、扩展函数的解析是静态的，该类添加了一方法，并没有插入到原来的类中，本质上没有对原有的类插入任何属性(可以使用javap工具 反编译看结果)
• 2、扩展函数的解析是静态分发的，而不是动态的，即扩展不支持多态，调用只取决于对象的谁能ing类型

•  多态：通过父类型的引用去指向一个对象，当在调用该对象时，到底是父类，还是子类，取决于真正运行期对象的方法     
  

• 3、调用是由对象的声明类型决定的，而不是由对象的实际类型决定

open class AA

class BB : AA()

// 扩展 AA
fun AA.a() = "a"

// 扩展 BB
fun BB.a() = "b"

fun myPrint(aa: AA) {
    println(aa.a())
}
fun main() {
    myPrint(AA())   // a
    myPrint(BB())   // a
}

我们可以发现上面的结果都是 定义方法中传入参数的类型。

2.2、扩展方法

• 扩展类的方法和扩展类的方法完全一样
• 在扩展方法时原来函数的优先级比较高

/**
 * 扩展类的方法和扩展类的方法完全一样
 * 在扩展方法时原来函数的优先级比较高
 */
class CC {
    fun foo() {
        println("CCC")
    }
}

fun CC.foo() {
    println("CC.foo")
}

// 扩展方法时支持方法重载
fun CC.foo(i: Int) {
    println("CC.Int $i")

}

fun main() {
    CC().foo()  // CCC
    CC().foo(5)  // CC.Int 5
}

注意： 重载可以对空类型进行扩展， 提供可空类型后就不用再次做检查。

/**
 * 重载可以对可空类型进行扩展
 * 提供可空类型后就不用再次做检查
 */
fun Any?.toString(): String {
    if (null == this) {
        return "null"
    }
    return toString()
}

2.3、扩展属性

/**
 * 扩展属性
 */
class MyExtensionProperty {

}

val MyExtensionProperty.name : String
    get() = "hello"

fun main() {
    val myExtensionProperty = MyExtensionProperty()
    println(myExtensionProperty.name) // hello
}

扩展属性后的结果如下图：

执行结果

2.4、扩展伴生对象

/**
 * 扩展伴生对象
 *
 */
class ExtensionCompanionObj {
    // 伴生对象
    companion object MyObject {
    }
}

fun ExtensionCompanionObj.MyObject.method() {
    println("hello world")
}

fun main() {
    ExtensionCompanionObj.method()  // hello world
}

代码结果如下图 ：

代码执行结果

2.5、扩展作用域

先给出结论：

• 1、扩展函数所定义在的类实例叫 分发接受者
• 2、扩展函数所扩展的类的示例叫 扩展接受者
• 3、当以上名字出现冲突时，扩展接受者的优先级比较高

示例如下：

/**
 * 扩展作用域
 *
 * 1、扩展函数所定义在的类实例叫 分发接受者
 * 2、扩展函数所扩展的类的示例叫 扩展接受者
 * 3、当以上名字出现冲突时，扩展接受者的优先级比较高
 */
class ExtendedScope {
    fun method() {
        println("ExtendedScope")
    }
}

/**
 * 扩展上面的类
 */
class ExtendedScope2 {
    fun method2() {
        println("")
    }

    // 在类中扩展另一个类
    fun ExtendedScope.hello() {
        // 可以使用扩展类中的内容，也可以调用这个类的方法
        method()
        method2()
    }

    fun world(extendedScope: ExtendedScope) {
        extendedScope.method()
    }

    // 扩展的作用域，只能在该类中使用
    fun ExtendedScope.output() {
        println(toString())
        println(this@ExtendedScope2.toString())
    }

    fun test() {
        var extendedScope = ExtendedScope()
        extendedScope.output()
    }
}

fun main() {
    // 通过扩展可以解决Java中充斥的各种辅助类问题
    val extendedScope2 = ExtendedScope2()
    extendedScope2.test()
    // 运行结果
    // com.liang.kotlin.basic.advanced.spread.ExtendedScope@3cd1a2f1
    // com.liang.kotlin.basic.advanced.spread.ExtendedScope2@2f0e140b
}

注意：
ExtendedScope并不能调用ExtendedScope2中对它扩展的方法，受到作用域限制

作用域限制