kotlin中的嵌套类与内部类

Java中的内部类和静态内部类
在Java中内部类简言之就是在一个类的内部定义的另一个类。当然在如果这个内部类被static修饰符修饰，那就是一个静态内部类。

关于内部类 和静态内部类除了修饰符的区别之外，最主要的是内部类会默认持有一个外部类的引用，也正是这个原因内部类可以直接引用外部类的属性和方法，而不受制于外部类中属性和方法的修饰符。而静态内部类不持有外部类的应用，所以基本跟一个外部类没有什么区别。

下面用代码来说明一下上面的规则。
Java代码

package ja;

//外部类
public class OutClass {
    private int count = 0;

    private void add(){
        count++;
    }

    //内部类
    class InnerClass{
        public int getSomething(){
            //直接可以调用外部类的方法
            add();
            return count;
        }
    }

    public static class StaticInnerClass{
        public int getValue(){
            //不持有外部类的引用，所以必须通过外部类的对象来访问
            OutClass outClass = new OutClass();
            outClass.add();
            return outClass.count;
        }
    }
}



package ja;

public class Main {
    public static void main(String[] args) {
        //必须现new出外部类的对象，才能new出内部类的对象
        OutClass.InnerClass innerClass = new  OutClass().new InnerClass();
        int res = innerClass.getSomething();
        System.out.println(res);

        //静态内部类直接可以new出内部类的对象
        OutClass.StaticInnerClass staticInnerClass = new OutClass.StaticInnerClass();
        int value = staticInnerClass.getValue();
        System.out.println(value);
    }
}

可以看出最主要的差别就是内部类会隐式持有一个外部类的引用。

Kotlin中的内部类和嵌套类
在Kotlin中的内部类也是指在一个类的内部声明另一个类，但是和Java中的规则有些差异。

在Kotlin中的内部类和Java中的内部类相似，都会持有一个外部类的引用，但是在Kotlin中内部类的声明方式变化了，必须要使用inner修饰符。

在Kotlin中，没有静态内部类一说，Java中的静态内部类在Kotlin中称为嵌套类。而且默认就是嵌套类，也就是内部类不写任何修饰符就是嵌套类。

同样的，内部类会持有一个外部类的引用，嵌套类不持有外部类的引用。

下面通过代码来说明一下。

Kotlin代码

package kt

//外部类
class OutClass{
    var count = 0
    fun add(){
        count++
    }

    //内部类
    inner class InnerClass{
        fun getSomething(): Int{
            //默认持有外部类的引用，直接访问外部类的方法属性
            add()
            this@OutClass.add()
            return this@OutClass.count
        }
    }

    //嵌套类
    class NestedClass{
        fun getValue(): Int{
            //嵌套类不持有外部类的引用，必须通过外部类的对象访问
            val outClass = OutClass()
            outClass.add()
            return outClass.count
        }
    }
}

package kt

fun main(args: Array<String>){
    val outClass = OutClass()
    val innerClass = outClass.InnerClass()
    val res = innerClass.getSomething()
    println(res)

    val nestedClass = OutClass.NestedClass()
    val value =  nestedClass.getValue()
    println(value)
}

上面的代码是使用Kotlin来实现了一下前面Java的代码，你会发现还是有很多相似之处的。
当然在Koltlin内部类中，可以使用this@OutClass去访问外部类的属性和方法。

下面我们通过表格来对比一下Java和Kotlin中的内部类。

 

类A在另一个类B中声明	在Java中	在Kotlin中
嵌套类(不存储外部类的引用)	static class A	class A
内部类(存储外部类的引用)	class A	inner class A

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　不管是哪个语言，嵌套类都可以直接声明，内部类要被一个外部类的“实例”声明