博客

内部类

class NestedDemo {
    var mNested = "NestedDemo"
    fun funNested(){
        println("funNested（）")
    }

    class Outer {
        private val zero = 0
        val one = 1

        fun outerFun():Int{
            return 1
        }

        class InnerrrClasses {
            fun getTwo() = 2
            var innerValue= 2

            inner class ChildClasses{
                val three = 3
                fun getThreeValue():Int{
                    println("试试获取外部变量：innerValue==$innerValue")
                    return 3
                }	
            }
        }
    }
}

在kotlin里面，被关键字“inner”修饰的类即为内部类。

然后在其他类里面的用法：

var mNested = NestedDemo().mNested
NestedDemo().funNested()

var outerOne = NestedDemo.Outer().one
var outerFun = NestedDemo.Outer().outerFun()

var innerTwo = NestedDemo.Outer.InnerrrClasses().getTwo()

var childThree = NestedDemo.Outer.InnerrrClasses().ChildClasses().three
var threeValue = NestedDemo.Outer.InnerrrClasses().ChildClasses().getThreeValue()

println("mNested===$mNested, outerOne===$outerOne, outerFun===$outerFun, 
		 innerTwo===$innerTwo, childThree===$childThree, threeValue===$threeValue")

“NestedDemo .kt”内部的变量和类，以及内部类的访问规则：

1、调用普通类（NestedDemo.kt）里面的变量和方法是通过“该类的对象实例.方法/变量”的思维去调用，就比如上面我们调用NestedDemo类里面的变量“mNested”以及“funNested()”方法；

var mNested = NestedDemo().mNested
NestedDemo().funNested()

2、调用调用普通类（NestedDemo.kt）里面的未经“inner”关键字修饰的内部类，则是直接使用“类名.xxx”的格式调用，就如上面我们调用NestedDemo类里面未经inner关键字修饰的“Outer.kt”内部类：

NestedDemo.Outer()

3、调用调用普通类（NestedDemo.kt）里面的有“inner”关键字修饰的内部类的变量或方法，则是：

外部类类名.inner修饰的内部类的对象实例.方法/变量。比如：

var childThree = NestedDemo.Outer.InnerrrClasses().ChildClasses().three
var threeValue = NestedDemo.Outer.InnerrrClasses().ChildClasses().getThreeValue()

匿名内部类

fun main(args: Array<String>) {	   
    var obj = object : Runnable,Executor{
    override fun run() {
        println("object : Runnable---->>>run()")
    }

    override fun execute(command: Runnable) {
        println("object : Cloneable---->>>execute(command: Runnable)")
    }

	obj.run()
	obj.execute(obj)
}

上面的obj其实是Runnable接口和Executor接口的复合体。

kotlin里面的匿名内部类支持同时实现两个接口的匿名内部类，并分别实现方法。比如上面obj 实例实现了Runnable接口和Executor接口两个接口，并同时实现了他们的方法：

run()和execute(command: Runnable)

然后我们在后面分别调用执行：

obj.run()调用的是Runnable接口的run方法。

obj.execute(obj)调用的是Executor接口的execute(command: Runnable)方法。