kotlin入门潜修之类和对象篇—委托及其原理（二）

创作不易，如有转载，还请备注。

委托方法实现原理

本篇文章将阐述委托实现的背后原理。

照例，先上我们要分析的源代码：

interface IWork {//IWork接口
    fun doWork()
}
//被委托者Boss类，实现了IWork接口
class Boss(val time: String) : IWork {
    override fun doWork() {
        println(time)
    }
}
//委托者Secretary类，实现了IWork接口，同时委托了自己的实现给work对象
class Secretary(work: IWork) : IWork by work
//测试类Main
class Main {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            val boss = Boss("today")//生成一个Boss类对象boss
            val secretary = Secretary(boss)//boss对象作为Secretary的委托实现，即boss是被委托者
            secretary.doWork()//调用secretary的doWork方法，实际上是调用了boss的doWork方法。
        }
    }
}

接下来我们把上述源代码的字节码全部粘贴上来(这里测试类Main对应的字节码暂时不粘贴)，可能有点长，可以不必先全部看完，下面会一段段分析，这里先给个整体的印象：

// ================Boss.class =================
// class version 50.0 (50)
// access flags 0x31
public final class Boss implements IWork  {
  // access flags 0x1
  public doWork()V
   L0
    LINENUMBER 7 L0
    ALOAD 0
    GETFIELD Boss.time : Ljava/lang/String;
    ASTORE 1
   L1
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 1
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/Object;)V
   L2
   L3
    LINENUMBER 8 L3
    RETURN
   L4
    LOCALVARIABLE this LBoss; L0 L4 0
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x12
  private final Ljava/lang/String; time
  @Lorg/jetbrains/annotations/NotNull;() // invisible

  // access flags 0x11
  public final getTime()Ljava/lang/String;
  @Lorg/jetbrains/annotations/NotNull;() // invisible
   L0
    LINENUMBER 5 L0
    ALOAD 0
    GETFIELD Boss.time : Ljava/lang/String;
    ARETURN
   L1
    LOCALVARIABLE this LBoss; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x1
  public <init>(Ljava/lang/String;)V
    @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
   L0
    ALOAD 1
    LDC "time"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
   L1
    LINENUMBER 5 L1
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    ALOAD 0
    ALOAD 1
    PUTFIELD Boss.time : Ljava/lang/String;
    RETURN
   L2
    LOCALVARIABLE this LBoss; L0 L2 0
    LOCALVARIABLE time Ljava/lang/String; L0 L2 1
    MAXSTACK = 2
    MAXLOCALS = 2
// ================Secretary.class =================
// class version 50.0 (50)
// access flags 0x31
public final class Secretary implements IWork  {
  // access flags 0x1
  public <init>(LIWork;)V
    @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
   L0
    ALOAD 1
    LDC "work"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
   L1
    LINENUMBER 12 L1
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
    ALOAD 0
    ALOAD 1
    PUTFIELD Secretary.$$delegate_0 : LIWork;
    RETURN
   L2
    LOCALVARIABLE this LSecretary; L0 L2 0
    LOCALVARIABLE work LIWork; L0 L2 1
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1012
  private final synthetic LIWork; $$delegate_0

  // access flags 0x1
  public doWork()V
   L0
    ALOAD 0
    GETFIELD Secretary.$$delegate_0 : LIWork;
    INVOKEINTERFACE IWork.doWork ()V
    RETURN
   L1
    LOCALVARIABLE this LSecretary; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1
  // compiled from: Main.kt
}
// ================IWork.class =================
// class version 50.0 (50)
// access flags 0x601
public abstract interface IWork {
  // access flags 0x401
  public abstract doWork()V
    LOCALVARIABLE this LIWork; L0 L1 0
  // compiled from: Main.kt
}

上面就是我们要分析的全部字节码，这里主要看class Secretary(work: IWork) : IWork by work
这句源码对应的字节码，因为这个是委托的真正实现。分析总结如下：

对于by关键字，kotlin编译器会为我们生成一个同实现接口类型（这里即是IWork类型）一致的private final的属性成员，其名字为$$delegate_0，字节码对应如下：

  private final synthetic LIWork; $$delegate_0

$$delegate_0属性会在Secretary实例构造方法中完成初始化，其值正是我们通过Secretary构造方法传入的boss对象，字节码如下所示：

// access flags 0x1
  public <init>(LIWork;)V//Secretary的实例构造方法
    @Lorg/jetbrains/annotations/NotNull;() // invisible, parameter 0
   L0
    ALOAD 1
    LDC "work"
    INVOKESTATIC kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull (Ljava/lang/Object;Ljava/lang/String;)V
   L1//重点在L1这部分内容
    LINENUMBER 12 L1
    ALOAD 0//实际上将this装载到了当前操作数栈中
    INVOKESPECIAL java/lang/Object.<init> ()V//调用了父类构造方法
    ALOAD 0
    ALOAD 1//这里实际上是将构造方法中的work对象装载到操作栈顶，这个work对象实际上是外部传入的boss类对象
    PUTFIELD Secretary.$$delegate_0 : LIWork;//将装入的work对象赋值给$$delegate_0
    RETURN
   L2
    LOCALVARIABLE this LSecretary; L0 L2 0
    LOCALVARIABLE work LIWork; L0 L2 1
    MAXSTACK = 2
    MAXLOCALS = 2

通过 secretary.doWork()来调用doWork方法的时候，实际上是通过 $$delegate_0属性成员来完成调用的，要确认这一点，只需要找到Secretary类中生成的doWork方法对应的字节码即可，如下所示：

  public doWork()V//kotlin编译器为委托类Secretary生成的doWork方法
   L0
    ALOAD 0
    GETFIELD Secretary.$$delegate_0 : LIWork;//这里实际上就是上面kotlin为我们生成的IWork类型的对象
    INVOKEINTERFACE IWork.doWork ()V//INVOKEINTERFACE指令实际上是调用接口方法的指令，他会搜索实现了IWork接口对象的doWork方法，
//这里正是$$delegate_0对象
    RETURN
   L1
    LOCALVARIABLE this LSecretary; L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

至此关于委托方法阐述完毕。

委托属性实现原理

本小节来看下委托属性的实现原理，这里主要以lazy委托为例进行分析。

照例先上我们要分析的源代码，如下所示：

class Test {
    val lazyVal: String by lazy {
        "hello"
    }

    fun test(){
        print(lazyVal)
    }
}

源代码及其简单，但是其生成的字节码却很复杂，这里照例先把上面代码对应的字节码粘贴如下：

// ================Test.class =================
// class version 50.0 (50)
// access flags 0x31
public final class Test {
  // access flags 0x12
  private final Lkotlin/Lazy; lazyVal$delegate
  @Lorg/jetbrains/annotations/NotNull;() // invisible

  // access flags 0x11
  public final getLazyVal()Ljava/lang/String;
  @Lorg/jetbrains/annotations/NotNull;() // invisible
   L0
    ALOAD 0
    GETFIELD Test.lazyVal$delegate : Lkotlin/Lazy;
    ASTORE 1
    ALOAD 0
    ASTORE 2
    GETSTATIC Test.$$delegatedProperties : [Lkotlin/reflect/KProperty;
    ICONST_0
    AALOAD
    ASTORE 3
   L1
    ALOAD 1
    INVOKEINTERFACE kotlin/Lazy.getValue ()Ljava/lang/Object;
   L2
    CHECKCAST java/lang/String
    ARETURN
   L3
    LOCALVARIABLE this LTest; L0 L3 0
    MAXSTACK = 2
    MAXLOCALS = 4

  public final test()V
   L0
    LINENUMBER 7 L0
    ALOAD 0
    INVOKEVIRTUAL Test.getLazyVal ()Ljava/lang/String;
    ASTORE 1
   L1
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    ALOAD 1
    INVOKEVIRTUAL java/io/PrintStream.print (Ljava/lang/Object;)V
   L2
   L3
    LINENUMBER 8 L3
    RETURN
   L4
    LOCALVARIABLE this LTest; L0 L4 0
    MAXSTACK = 2
    MAXLOCALS = 2

  // access flags 0x1
  public <init>()V
   L0
    LINENUMBER 1 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
   L1
    LINENUMBER 2 L1
    ALOAD 0
    GETSTATIC Test$lazyVal$2.INSTANCE : LTest$lazyVal$2;
    CHECKCAST kotlin/jvm/functions/Function0
    INVOKESTATIC kotlin/LazyKt.lazy (Lkotlin/jvm/functions/Function0;)Lkotlin/Lazy;
    PUTFIELD Test.lazyVal$delegate : Lkotlin/Lazy;
    RETURN
   L2
    LOCALVARIABLE this LTest; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x1018
  final static synthetic [Lkotlin/reflect/KProperty; $$delegatedProperties

  // access flags 0x8
  static <clinit>()V
    ICONST_1
    ANEWARRAY kotlin/reflect/KProperty
    DUP
    ICONST_0
    NEW kotlin/jvm/internal/PropertyReference1Impl
    DUP
    LDC LTest;.class
    INVOKESTATIC kotlin/jvm/internal/Reflection.getOrCreateKotlinClass (Ljava/lang/Class;)Lkotlin/reflect/KClass;
    LDC "lazyVal"
    LDC "getLazyVal()Ljava/lang/String;"
    INVOKESPECIAL kotlin/jvm/internal/PropertyReference1Impl.<init> (Lkotlin/reflect/KDeclarationContainer;Ljava/lang/String;Ljava/lang/String;)V
    INVOKESTATIC kotlin/jvm/internal/Reflection.property1 (Lkotlin/jvm/internal/PropertyReference1;)Lkotlin/reflect/KProperty1;
    CHECKCAST kotlin/reflect/KProperty
    AASTORE
    PUTSTATIC Test.$$delegatedProperties : [Lkotlin/reflect/KProperty;
    RETURN
    MAXSTACK = 8
    MAXLOCALS = 0
}


// ================Test$lazyVal$2.class =================
// class version 50.0 (50)
// access flags 0x30
// signature Lkotlin/jvm/internal/Lambda;Lkotlin/jvm/functions/Function0<Ljava/lang/String;>;
// declaration: Test$lazyVal$2 extends kotlin.jvm.internal.Lambda implements kotlin.jvm.functions.Function0<java.lang.String>
final class Test$lazyVal$2 extends kotlin/jvm/internal/Lambda  implements kotlin/jvm/functions/Function0  {


  // access flags 0x1041
  public synthetic bridge invoke()Ljava/lang/Object;
   L0
    LINENUMBER 1 L0
    ALOAD 0
    INVOKEVIRTUAL Test$lazyVal$2.invoke ()Ljava/lang/String;
    ARETURN
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x11
  public final invoke()Ljava/lang/String;
  @Lorg/jetbrains/annotations/NotNull;() // invisible
   L0
    LINENUMBER 3 L0
    LDC "hello"
   L1
    ARETURN
   L2
    LOCALVARIABLE this LTest$lazyVal$2; L0 L2 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 0x0
  <init>()V
    ALOAD 0
    ICONST_0
    INVOKESPECIAL kotlin/jvm/internal/Lambda.<init> (I)V
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 1

  // access flags 0x19
  public final static LTest$lazyVal$2; INSTANCE

  // access flags 0x8
  static <clinit>()V
    NEW Test$lazyVal$2
    DUP
    INVOKESPECIAL Test$lazyVal$2.<init> ()V
    PUTSTATIC Test$lazyVal$2.INSTANCE : LTest$lazyVal$2;
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 0
  OUTERCLASS Test <init> ()V
  // access flags 0x18
  final static INNERCLASS Test$lazyVal$2 null null
  // compiled from: Main.kt
}

万万没有想到，一段简单的代码，kotlin竟然在背后为我们做了这么多工作！这里照例分解总结如下：

kotlin编译器会为委托属性单独生成一个类，该类的命名规则是外部类+"$"+属性名+"$2"（本例中为Test$lazyVal$2），该类继承了Lambda类并实现了Function0接口，如下所示：

final class Test$lazyVal$2 extends kotlin/jvm/internal/Lambda  implements kotlin/jvm/functions/Function0

这里为什么要实现Function接口呢？先继续往下看，看完自然就明白了。

在Test$lazyVal$2类中，会暴露出了一个单例对象INSTANCE，这个对象被外部类（即Test）所使用，如下所示：

 // access flags 0x19
  public final static LTest$lazyVal$2; INSTANCE//单例对象
  // access flags 0x8
  static <clinit>()V//在类构造方法中，完成了INSTANCE的初始化
    NEW Test$lazyVal$2
    DUP
    INVOKESPECIAL Test$lazyVal$2.<init> ()V
    PUTSTATIC Test$lazyVal$2.INSTANCE : LTest$lazyVal$2;
    RETURN
    MAXSTACK = 2
    MAXLOCALS = 0

上面基本就是委托属性生成类所提供的功能，接下来从Test类中的test方法的调用处来分析上面功能是如何被使用的。

1.在test方法对应的字节码中，重点是其调用了getLazyVal 方法，getLazyVal方法会完成对属性值的获取，如下所示：

//test方法对应的字节码，这里只摘录重要部分，print对应的字节码暂时省略
  public final test()V
   L0
    LINENUMBER 7 L0
    ALOAD 0
    INVOKEVIRTUAL Test.getLazyVal ()Ljava/lang/String;
    ASTORE 1

//getLazyVal对应的字节码实现如下：
  public final getLazyVal()Ljava/lang/String;
  @Lorg/jetbrains/annotations/NotNull;() // invisible
   L0
    ALOAD 0
    GETFIELD Test.lazyVal$delegate : Lkotlin/Lazy;//这里生成了一个lazy代理对象
    ASTORE 1//将Test.lazyVal$delegate暂时存储到局部变量1中
    ALOAD 0
    ASTORE 2
    GETSTATIC Test.$$delegatedProperties : [Lkotlin/reflect/KProperty;//这里生成了KProperty类型属性对象
    ICONST_0
    AALOAD
    ASTORE 3
   L1
    ALOAD 1//这里实际上是    ASTORE 1
保存的对象，即就是Test.lazyVal$delegate对象
    INVOKEINTERFACE kotlin/Lazy.getValue ()Ljava/lang/Object;//重点是这里，调用了就是ALOAD 1指令取出来的Test.lazyVal$delegate的getValue方法
   L2
    CHECKCAST java/lang/String
    ARETURN
   L3
    LOCALVARIABLE this LTest; L0 L3 0
    MAXSTACK = 2
    MAXLOCALS = 4

getLazyVal最终调用了getValue这个方法，上面字节码中已经在注释中说明了getValue的来源，即来自于Test.lazyVal$delegate这个对象，那么这个对象是什么时候生成的？其实就是在Test类中的实例构造方法中生成的，如下所示：

//Test类的实例构造方法
  public <init>()V
   L0
    LINENUMBER 1 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
   L1
    LINENUMBER 2 L1
    ALOAD 0
//注意这里，终于调用了文章前面提示的Test$lazyVal$2.INSTANCE实例，即kotlin为我们生成的Test$lazyVal$2实例
    GETSTATIC Test$lazyVal$2.INSTANCE : LTest$lazyVal$2;
    CHECKCAST kotlin/jvm/functions/Function0
    INVOKESTATIC kotlin/LazyKt.lazy (Lkotlin/jvm/functions/Function0;)Lkotlin/Lazy;
//下面语句完成了对Test.lazyVal$delegate对象的赋值，其值就是Test$lazyVal$2.INSTANCE
    PUTFIELD Test.lazyVal$delegate : Lkotlin/Lazy;
    RETURN
   L2
    LOCALVARIABLE this LTest; L0 L2 0
    MAXSTACK = 2
    MAXLOCALS = 1

上面构造方法中有一句静态方法的调用，摘录如下：

INVOKESTATIC kotlin/LazyKt.lazy (Lkotlin/jvm/functions/Function0;)Lkotlin/Lazy;

从字节码可以看出这里调用了LazyKt类的静态方法lazy，并且传入了Function0类型的入参。这个入参正是Test$lazyVal$2.INSTANCE，这也是为什么Test$lazyVal$2要实现 kotlin/jvm/functions/Function0接口的原因。

kotlin包kotlin.jvm.functions下的所有Function接口都有一个invoke操作符，当方法被调用的时候实际上就是通过执行该操作符来完成的，这里就涉及到了kotlin中的高阶函数的原理，会有相关文章展开阐述。只需要知道，代码最终会通过调用Test$lazyVal$2类中的 public final invoke()Ljava/lang/String方法来完成lazyVal的赋值即可。

从上述分析可知，lazy实现的主要流程就是，为委托属性生成了一个类，并且提供了该类的一个单例对象，当我们使用到该委托属性的时候，就会通过该单例对象完成属性的计算赋值。

那么lazy是如何保证属性值只计算一次呢？从字节码中可以看出，获取属性值最终都会通过getValue获取，如下所示：

//位于Test类中的字节码
    INVOKEINTERFACE kotlin/Lazy.getValue ()Ljava/lang/Object;

getValue的执行实际上是通过调用invoke来实现的，invoke方法的字节码我们能够看到，但是却依然无法看出调用该方法之前的逻辑是什么。至少在我们这个例子中，字节码层面上没有体现出为什么lazy属性计算只初始化一次！所以通过看字节码显然是得不到答案了，那么是不是就没有方法了？

当然不是，从上面字节码可以看出，最终会调用Lazy类的getValue方法，所以只需要查看Lazy类的getValue方法实现即可。有朋友说getValue最后不是要调用invoke方法吗？为什么不直接看invoke方法的实现？这是因为，invoke方法的调用实际上表示的是其对应方法体的执行，getValue是完全有可能在invoke执行之前做些逻辑判断的，这有可能就是lazy属性没有多次计算的原因。

位于Lazy.kt文件中的getValue的源代码摘录如下：

@kotlin.internal.InlineOnly
public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value

可以看出，getValue最终获取的是value属性的值，所以我们需要继续找属性value的实现。

通过查找可知，value是定义在Lazy.kt文件中的Lazy接口中的val类型的属性成员，由于是位于接口中，所以需要找到其具体实现。实际上Lazy文件中针对不同环境（java版、js版等）有多个value的实现，最终我们找到了java版的value实现，位于私有类SafePublicationLazyImpl中，如下所示：

    override val value: T
        get() {
            if (_value === UNINITIALIZED_VALUE) {
                val initializerValue = initializer
                // if we see null in initializer here, it means that the value is already set by another thread
                if (initializerValue != null) {
                    val newValue = initializerValue()
                    if (valueUpdater.compareAndSet(this, UNINITIALIZED_VALUE, newValue)) {
                        initializer = null
                    }
                }
            }
            @Suppress("UNCHECKED_CAST")
            return _value as T
        }

上面代码很显然，当value值为UNINITIALIZED_VALUE会进行第一次赋值，之后再获取时就会直接返回该值。第一次赋值实际上就是通过调用initializer完成了初始化，这个初始化实际上就是执行了lazy{"hello"}这个段代码（对应于字节码中的invoke方法）。所以如果我们在lazy中添加打印语句会发现，该打印语句仅仅会在属性第一次计算的时候执行。

至此，属性相关的原理阐述完毕。

最后编辑于：2020.08.31 09:48:18

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 216,692评论 6赞 501
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 92,482评论 3赞 392
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 162,995评论 0赞 353
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 58,223评论 1赞 292
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 67,245评论 6赞 388
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 51,208评论 1赞 299
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 40,091评论 3赞 418
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 38,929评论 0赞 274
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 45,346评论 1赞 311
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 37,570评论 2赞 333
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 39,739评论 1赞 348
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 35,437评论 5赞 344
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 41,037评论 3赞 326
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 31,677评论 0赞 22
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,833评论 1赞 269
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 47,760评论 2赞 369
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 44,647评论 2赞 354

kotlin入门潜修之类和对象篇—委托及其原理（二）

委托方法实现原理

委托属性实现原理

推荐阅读更多精彩内容