kotlin嵌套类、内部类、匿名内部类

fun main(args: Array<String>) {
    /**
     * 调用嵌套类中的方法
     */
//输出：类可以嵌套其他类中
    Test.Nested().nestedTest()

    /**
     *     调用内部类中的方法
     */
//输出：内部类可以引用外部类的成员，例如：成员属性
    Test().Inner().innerTest()
    /**
     * 采用对象表达式来创建接口对象，即匿名内部类的实例。
     */
    instance.setInterFace(object : TestInterFace {
        override fun test() {
            println("对象表达式创建匿名内部类的实例")
        }
    })
}
class Test {
    var v = "成员属性"

    /**
     * 一个在类中嵌套的类
     * 引用不到外层嵌套类的成员
     */
//嵌套类
    class Nested {
        fun nestedTest() {
            println("类可以嵌套其他类中")
        }
    }
    /**
     * inner标记一个类是内部类
     * 可以引用外部类的成员
     * 采用this@类名方式，获取到外部类的this对象
     */
//内部类
    inner class Inner {
        fun innerTest() {
            var t = this@Test //获取外部类的成员变量
            println("内部类可以引用外部类的成员，例如：" + t.v)
        }
    }
    fun setInterFace(test: TestInterFace) {
        test.test()
    }
}
/**
 * 定义接口
 */
interface TestInterFace {
    fun test()
}

伴生对象

Kotlin中的对象指的是使用object关键字定义的类型声明，一般用作单例模式和伴生对象。

object让创建单例变得十分简单：

object Resource{
    val name="sanshi"

    fun say(){
        println("Hello")
    }
}

Kotlin允许在类中使用companion object创建伴生对象，用伴生对象的成员来代替静态成员：

class Person(val name:String){
    companion object {
        val anonymousPerson=Person("sanshi")
        fun sayHello(){
            println("Hello")
        }
    }

    var age=0
    fun sayName(){
        println("My name is $name")
    }
}

使用伴生对象实际上是在这个类内部创建了一个名为Companion的静态单例内部类，伴生对象中定义的属性会直接编译为外部类的静态字段，而函数会被编译为伴生对象的方法。

fun main(args: Array<String>) {
    Person.anonymousPerson
    Person.sayHello()
    val person = Person("sanshi")
    person.sayName()
}