Kotlin系列之内部类和嵌套类

今天我们再来看看Kotlin中的内部类和嵌套类。

还是一样的套路,我们要和Java进行对比学习。

Java中的内部类和静态内部类

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
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代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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

写在最后

通过Java和Kotlin的对比,可以看出为了Kotlin与Java良好的互操作性,两种语言还是有很多相似之处的。

如果博客对您有帮助,不妨请我喝杯咖啡...