嵌套类(Nested Class)

类可以嵌套在其他类中：
示例代码1.

package com.leofight.kotlin3

class OuterClass {

    private val str: String = "hello world"

    class NestedClass {
        fun nestedMethod() = "welcome"
    }
}

fun main(args: Array<String>) {
    println(OuterClass.NestedClass().nestedMethod())
}

输出

welcome

示例代码2:

package com.leofight.kotlin3

class OuterClass4 {
    class NestedClass4 {
        init {
            println("NestedClass4构造块执行")
        }
    }
}

fun main(args: Array<String>) {
    val nestedClass4: OuterClass4.NestedClass4 = OuterClass4.NestedClass4();
}

输出

NestedClass4构造块执行

内部类(Inner Class)

类可以标记为 inner 以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用：

示例代码1

package com.leofight.kotlin3

class OuterClass2 {

    private var str: String = "hello world"

    inner class InnerClass {
        fun innerMethod() = this@OuterClass2.str
    }

    //局部嵌套类
    fun getName(): String {
        class LocalNestedClass {
            val name: String = "mytest"
        }

        val localNestedClass = LocalNestedClass()
        return localNestedClass.name
    }
}

fun main(args: Array<String>) {
    println(OuterClass2().InnerClass().innerMethod())

    println(OuterClass2().getName())
}

输出

hello world
mytest

示例代码2

package com.leofight.kotlin3

class Person(val name: String, var age: Int) {

    private val str: String = "Person属性"

    private inner class PersonFeature(var height: Int, var weight: Int) {
        private val str: String = "PersonFeature属性"
        fun getPersonFeature() {
            val str: String = "局部变量"
            println("身高：$height,体重：$weight")

            println("${this@Person.str}")
            println("${this.str}")
            println(str)

            this@Person.method()
        }
    }

    private fun method() {
        println("执行了Person的method方法")
    }

    fun getPerson() {
        val personFeature = PersonFeature(120, 180)
        personFeature.getPersonFeature()
    }
}

fun main(args: Array<String>) {
    val person = Person("张三", 20)
    person.getPerson()
}

输出

身高：120,体重：180
Person属性
PersonFeature属性
局部变量
执行了Person的method方法

Kotlin访问外部类变量的方式：this@OuterClass.str
Java访问外部类变量的方式：OuterClass.this.str

示例代码3

package com.leofight.kotlin3

class OuterClass5 {
    inner class InnerClass5(str: String) {
        init {
            println(str)
        }
    }
}

fun main(args: Array<String>) {
    val innerClass5: OuterClass5.InnerClass5 = OuterClass5().InnerClass5("hello world");
}

输出

hello world

关于嵌套类与内部类之间的区别与联系

1.嵌套类：对应于Java的静态内部类（即有static关键字修饰的内部类），只要在一个类的内部定义了另外一个类，那么这个类就叫做嵌套类，相当于Java当中有static关键字修饰的内部类。**
2.内部类：对应于Java中的非静态内部类（即没有static关键字修复的内部类），使用inner关键字在一个类的内部所定义的另外一个类叫做内部类，相当于Java当中没有static关键字修饰的内部类。**