Kotlin inner, inline, sealed函数

程序员小何SS

于 2024-04-16 22:24:25 发布

阅读量902

点赞数 11

文章标签： kotlin 开发语言 android

本文链接：https://blog.csdn.net/xiaokangss/article/details/137842924

版权

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

最后

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。