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

最近使用Kotlin時，發現建立的内部類居然通路不到外部類的成員，了解了一下才發現和Java有點差別

Java	普通内部類	static 修飾的内部靜态類	匿名内部類(new 實作接口)
Kotlin	inner 修飾的内部類 ([email protected]類名 通路外部類成員)	普通内部類(嵌套類)	匿名内部類(object 實作接口)([email protected]類名 通路外部類成員)
不可以通路外部類成員

敲個代碼加深了解 （為了好區分，把普通内部類 寫為嵌套類 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. 内部類 - 可以通路外部類的成員(方式： [email protected]外部類名)， 相當于Java的普通類
             */
            inner class InnerClass {
                fun innerFun() {
                    println("I am innerFun in InnerClass - can visit memberInOuterClass: ${[email protected]}")
                }
            }

            /**
             * 4. 匿名内部類 - 使用object 建立
             */
            val anonymousClass = object : TestAnonymousInterface {
                override fun anonymousFun() {
                    println("I am anonymousFun - can visit memberInOuterClass: ${[email protected]}")
                }
            }
        }

        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