嵌套类是在另一个类中创建的类。 在Kotlin中，嵌套类默认是静态的，因此可以在不创建类对象的情况下访问其数据成员和成员函数。 嵌套类无法访问外部类的数据成员。

class outerClass{  
   //outer class code  
    class nestedClass{  
      //nested class code  
    }  
}

Kotlin嵌套类示例

class outerClass{
    private var name: String = "Ashu"
    class nestedClass{
        var description: String = "code inside nested class"
        private var id: Int = 101
        fun foo(){
            //  print("name is ${name}") // cannot access the outer class member
            println("Id is ${id}")
        }
    }
}
fun main(args: Array<String>){
// nested class must be initialize
    println(outerClass.nestedClass().description) // accessing property
    var obj = outerClass.nestedClass() // object creation
    obj.foo() // access member function
}

执行上面示例代码，得到以下结果 -

code inside nested class
Id is 101

Kotlin内部类

内部类是一个使用关键字inner在一个类中创建的类。 换句话说，可以说标记为inner的嵌套类称为内部类。

内部类不能在接口或非内部嵌套类中声明。

class outerClass{  
   //outer class code  
    inner class innerClass{  
      //nested class code  
    }  
}

内部类优于嵌套类的优点是，即使它是私有的，它也能够访问外部类的成员。 内部类保持对外部类的对象的引用。

Kotlin内部类示例

class outerClass{
    private  var name: String = "Maxsu"
    inner class  innerClass{
        var description: String = "code inside inner class"
        private var id: Int = 10010
        fun foo(){
            println("姓名：${name}") // access the outer class member even private
            println("编号：${id}")
        }
    }
}
fun main(args: Array<String>){
    println(outerClass().innerClass().description) // accessing property
    var obj = outerClass().innerClass() // object creation
    obj.foo() // access member function

}

执行上面示例代码，得到以下结果 -

code inside inner class
姓名：Maxsu
编号：10010