inner
我们都知道在Java中，非静态内部类持有外部类的引用，内部类可以访问外部类的属性，静态内部类不持有外部类的引用。
首先，咱们在Kotlin中创建一个内部类。
class Outer {
private val bar = 1
class Nested {
fun foo() {
}
}
}
Outer.Nested().foo()
内部类和内部类方法的调用方式如上，反编译之后的Java代码如下
public final class Outer {
private final int bar = 1;
public static final class Nested {
public final void foo() {
}
}
}
可以看到Nested成为了Outer的一个静态内部类，所以在Kotlin中内部类默认就是静态内部类，那想创建一个非静态内部类应该怎么做呢？
需要给内部类添加inner修饰。
class Outer {
private val bar = 1
inner class Nested {
fun foo() {
println("$bar")
}
}
}
Outer().Nested().foo()
我们给Nested方法添加inner修饰之后，调用方法发生了变化，并且它可以直接访问外部类的属性，查看反编译之后的Java代码，可以看到，它是一个非静态内部类。
public final class Outer {
private final int bar = 1;
public final class Nested {
public final void foo() {
String var1 = String.valueOf(Outer.this.bar);
System.out.println(var1);
}
}
}
inline
我们都知道JVM有方法栈的概念，函数在调用过程中会入栈和出栈，产生一定的时间和空间开销，如果被调用函数体量不大，但调用频繁，会导致较大的时间和空间损耗。
使用函数或Lambda表达式作为参数的函数称为高阶函数，高级函数在执行过程中就会调用作为参数传入的函数或Lambda表达式，这个过程就会存在上边提到的问题，为了解决这个问题我们需要使用inline关键字。
inline的作用：在编译时期，把调用函数的地方用函数的方法体进行替换。
class Inline {
fun map(size: Int, fn: (Int) -> Int) {
println("${fn(size)}")
}
}
创建一个高阶函数，接受一个Lambda表达式作为参数，反编译之后的Java代码为
public final class Inline {
public final void map(int size, @NotNull Function1 fn) {
Intrinsics.checkNotNullParameter(fn, "fn");
String var3 = String.valueOf(((Number)fn.invoke(size)).intValue());
System.out.println(var3);
}
}
public static final void main() {
Inline inline = new Inline();
inline.map(2, (Function1)null.INSTANCE);
}
下面给高阶函数添加inline修饰
public final class Inline {
public final void map(int size, @NotNull Function1 fn) {
int $i$f$map = 0;
Intrinsics.checkNotNullParameter(fn, "fn");
String var4 = String.valueOf(((Number)fn.invoke(size)).intValue());
System.out.println(var4);
}
}
public static final void main() {
Inline inline = new Inline();
int size$iv = 2;
int $i$f$map = false;
int var5 = false;
String var4 = String.valueOf(size$iv + 2);
System.out.println(var4);
}
从函数调用处可以看出区别，添加inline之后，调用map函数的地方直接换成了函数体。
inline适合在高阶函数上使用，不适合在普通函数上使用，在普通函数上使用时会有相应提示，能带来的性能提升效果很小。
noinline
如果你不希望传递给函数的全部Lambda参数内联，那么可以使用noinline标记不希望被内联的Lambda参数。
inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
inlined()
notInlined()
}
// 方法调用
inline.foo({ println("inlined") }, { println("noinlined") })
反编译之后的Java代码为
Function0 notInlined$iv = (Function0)null.INSTANCE;
$i$f$foo = false;
int var8 = false;
String var9 = "inlined";
System.out.println(var9);
notInlined$iv.invoke();
可以看到inlined 被替换成了对应内容，而noinlined 没有被替换。
sealed
sealed类或接口的子类在编译阶段是已知的，不允许在编译以后创建它的子类。
密封类用于子类类型有限的类， 密封类用来表示受限制的类层次结构。
密封类适合用在when语句中，可以省略else分支。
密封类是自身抽象的，不能实例化。
sealed interface Error
sealed class IOError(): Error
class FileReadError(val file: File): IOError()
class DatabaseError(val db: String): IOError()
可以查看反编译之后的Java代码
public abstract class IOError implements Error {
private IOError() {
}
// $FF: synthetic method
public IOError(DefaultConstructorMarker $constructor_marker) {
this();
}
}
可以看到IOError是一个抽象类。
密封类的常见写法是这样的
sealed class Error(val message: String) {
class NetworkError: Error("Network error.")
class DatabaseError: Error("Database")
class UnknownError: Error("UnknownError")
}
密封类和枚举的区别：
每个枚举常量仅作为单个实例存在，而 Sealed Classes 的子类可以表示不同状态的实例
密封类的使用场景：
- 需要有限的子类继承
- 需要类型安全的设计
- 使用封闭的API
参考：
- Kotlinn 官方文档
- 《疯狂Kotlin讲义》
- Kotlin 内联函数 inline
