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

最新推荐文章于 2024-04-01 00:40:19 发布

原创最新推荐文章于 2024-04-01 00:40:19 发布 · 557 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Kotlin #inner #内部类 #外部类 #成员

Kotlin 专栏收录该内容

32 篇文章

订阅专栏

本文深入探讨Kotlin中内部类和嵌套类的区别，通过代码示例展示了如何创建及使用这两种类型的类，重点讲解了它们访问外部类成员的能力。与Java相比，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