Kotlin内部类、嵌套类

1. 嵌套类

//嵌套类
class Outer1 {
    private var value = 1

    class Inner1{
        private var inValue = 2

        fun method() {
            // println(value)       //嵌套类无法直接访问外部类属性
            println(Outer1().value) //但可以通过外部类的对象访问，因为有private修饰符，普通类通过对象也无法访问
        }
    }
    fun func() {
        // println(inValue)         //外部类无法直接访问嵌套类的属性
        // method()                 //和方法
 
        // println(Inner1().inValue)//外部类无法通过嵌套类的对象访问private属性，但是可以访问public
    }
}
 
//实例化嵌套类
val inn = Outer1.Inner1()

2. 内部类

 //内部类
class Outer2 {

    private var value1 = 233

    inner class Inner2 {                //声明内部类需要使用inner关键字
        private var inValue = 666

        fun method() {
            println(value1)             //内部类可以直接访问外部类属性
            func()                      //和方法
        }
    }

    private fun func() {
        // println(inValue)             //外部类无法直接访问内部类的属性
        // println(Inner2().inValue)    //也无法通过内部类的对象访问内部类的私有域，但在Java中可以
    }
}
 
//实例化内部类，需要借助外部类对象，同Java
val out = Outer2()
val inn = out.Inner2()

3. 匿名内部类

//匿名内部类
interface DoSomething {
    fun dooo()
}
class Outer3 {
    private val value = "i am outer value"

    private val hhh = object : DoSomething {    //Kotlin中写匿名内部类需要借助object关键字
        override fun dooo() {
            println(value)                      //同样可以访问外部类的属性和方法
        }
    }
}

4. 局部内部类

//局部内部类
class Outer4 {
    private var out = 233
    fun func() {
        val value = "hhhhh"
        
        class Inner4 {
            private var inner = 666
            fun method() {
                println(value)          //可以访问外部类的属性，但必须为final 同Java
                println(out)            //可访问方法中定义的变量，亦为final
            }
        }
    }
    
    fun hhh() {                         //外部类无法访问到内部类，因为生命周期和作用域的关系
        // println(inner)
        // println(Inner4().inner)
        // println(Outer4().Inner4())
        // println(Outer4.Inner4())
    }
} 

5. 总结：

通过上面的实际演示和各类之间的表现，我们可以知道，Kotlin中的嵌套类就相当于Java中的静态内部类，inner关键字修饰的内部类相当于Java中的非静态内部类，匿名内部类和局部内部类性质都和Java类似。

其中匿名内部类有些时候可以用lambda表达式简化。