Kotlin_嵌套类、内部类和匿名内部类

最近使用Kotlin时，发现创建的内部类居然访问不到外部类的成员，了解了一下才发现和Java有点区别

Java	普通内部类	static 修饰的内部静态类	匿名内部类(new 实现接口)
Kotlin	inner 修饰的内部类 (this@类名 访问外部类成员)	普通内部类(嵌套类)	匿名内部类(object 实现接口)(this@类名 访问外部类成员)
		不可以访问外部类成员

 

敲个代码加深理解 （为了好区分，把普通内部类 写为嵌套类 Nested）

class NestedAndInnerClassTest {
    companion object{
        @JvmStatic
        fun main(args: Array<String>){
            println("Hello NestedAndInnerClassTest")
            testNestedAndInnerClass()
        }

        private fun testNestedAndInnerClass() {
            //1. 创建内部类
            var outerClass = OuterClass()
            //2. 通过外部类名.内部类名， 创建嵌套类
            var nestedClass = OuterClass.NestedClass()
            nestedClass.nestedFun()

            //3. 通过外部类对象 创建内部类
            var innerClass = outerClass.InnerClass()
            innerClass.innerFun()

            //4. 匿名内部类 - 通过object 创建并实现接口，不用单独创建一个类，实在太方便了
            outerClass.anonymousClass.anonymousFun()
        }

        /**
         * 1. 外部类
         */
        class OuterClass {
            //外部类的成员变量
            var memberInOuterClass = "memberInOuterClass"

            /**
             * 2. 嵌套类 - 不可以访问外部类的成员， 相当于Java的静态内部类
             */
            class NestedClass {
                fun nestedFun() {
                    println("I am nestedFun in Nested Class - can not visit memberInOuterClass")
                }
            }


            /**
             * 3. 内部类 - 可以访问外部类的成员(方式： this@外部类名)， 相当于Java的普通类
             */
            inner class InnerClass {
                fun innerFun() {
                    println("I am innerFun in InnerClass - can visit memberInOuterClass: ${this@OuterClass.memberInOuterClass}")
                }
            }

            /**
             * 4. 匿名内部类 - 使用object 创建
             */
            val anonymousClass = object : TestAnonymousInterface {
                override fun anonymousFun() {
                    println("I am anonymousFun - can visit memberInOuterClass: ${this@OuterClass.memberInOuterClass}")
                }
            }
        }

        interface TestAnonymousInterface{
            fun anonymousFun()
        }
    }
}

输出：

I am nestedFun in Nested Class - can not visit memberInOuterClass
I am innerFun in InnerClass - can visit memberInOuterClass: memberInOuterClass
I am anonymousFun - can visit memberInOuterClass: memberInOuterClass