koltin的特性大多不是空穴来风，而是为了解决一些固有问题。

kotlin代理模式官方文档地址：http://kotlinlang.org/docs/reference/delegation.html

一.代理模式

代理是实现代码复用的一种方法。
在面向对象的语言中，代理模式是通过组合的方式来达到和继承一样的效果的。

代理模式定义：给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问，即客户不直接操控原对象，而是通过代理对象间接地操控原对象。

下面是代理模式UML图：

代理模式三要素：1.RealSubject 原对象 2.Proxy 代理对象 3.Subject 接口

RealSubject和Proxy都实现了Subject接口，这样两者就具有了公共方法Request。

通过执行Proxy中的Request方法，间接的执行RealSubject中的Request方法。

先来个🌰了解一下如何实现：

interface Subject {
    void request();
}
class RealSubject implements Subject{

    @Override
    public void request() {
        System.out.println("RealSubject");
    }
}
class Proxy implements Subject{
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request() {
        System.out.println("Proxy start");
        realSubject.request();
        System.out.println("Proxy end");
    }
}
public static void main(String[] args){
    RealSubject realSubject = new RealSubject();
    Proxy proxy=new Proxy(realSubject);
    proxy.request();
}

以上代码就是代理模式的实现原理。

通过代理模式：
功能1. 我们可以复用RealSubject类的代码。
功能2. 在执行RealSubject的request方法执行之前和执行之后，插入一段代码（比如打印出来request方法的执行时间）。

对于功能1 接下来让我们思考一个问题：
假如Subject接口声明了2个方法。而我们需要复用RealSubject其中的1个方法：

interface Subject {
    void request1();
    void request2();
}
class RealSubject implements Subject{
    @Override
    public void request1() {
        System.out.println("RealSubject request1");
    }

    @Override
    public void request2() {
        System.out.println("RealSubject request2");
    }
}
class Proxy implements Subject{
    private RealSubject realSubject;

    public Proxy(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void request1() {
        realSubject.request1();
    }

    @Override
    public void request2() {
        System.out.println("Proxy request2");
    }
}

我们需要手动书写Proxy类，然后重载request1和request2方法，我们可以很快的把代码敲完。

如果Subject接口声明了100个方法，而我们想复用RealSubject类中的90个方法呢，这敲代码花费的时间不可忽视。

kotlin成功的解决了这个问题。

二.kotlin代理模式的实现

kotlin实现代理模式非常简单，看一个官网的🌰：

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}

class Derived(b: Base) : Base by b

fun main(args: Array<String>) {
    val b = BaseImpl(10)
    Derived(b).print()
}

运行结果是：10

转为java代码看一下庐山真面目：

// Base.java
import kotlin.Metadata;

public interface Base {
   void print();
}
// Derived.java
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

public final class Derived implements Base {
   private final Base $$delegate_0;

   public Derived(@NotNull Base b) {
      Intrinsics.checkParameterIsNotNull(b, "b");
      super();
      this.$$delegate_0 = b;
   }

   public void print() {
      this.$$delegate_0.print();
   }
}
// TestKt.java
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;

public final class TestKt {
   public static final void main(@NotNull String[] args) {
      Intrinsics.checkParameterIsNotNull(args, "args");
      BaseImpl b = new BaseImpl(10);
      (new Derived((Base)b)).print();
   }
}
// BaseImpl.java
import kotlin.Metadata;

public final class BaseImpl implements Base {
   private final int x;

   public void print() {
      int var1 = this.x;
      System.out.print(var1);
   }

   public final int getX() {
      return this.x;
   }

   public BaseImpl(int x) {
      this.x = x;
   }
}

其实就是在编译期自动生成了Derived类，解放了双手。

我们可以按照需求复写print()方法

interface Base {
    fun printMessage()
    fun printMessageLine()
}

class BaseImpl(val x: Int) : Base {
    override fun printMessage() { print(x) }
    override fun printMessageLine() { println(x) }
}

class Derived(b: Base) : Base by b {
    override fun printMessage() { print("abc") }
}

fun main(args: Array<String>) {
    val b = BaseImpl(10)
    Derived(b).printMessage()
    Derived(b).printMessageLine()
}

输出：abc10

Derived除了可以实现Base接口，还可以继承其他父类，方法名字遇到冲突怎么办

比如Derived继承了父类Parent，而父类同样拥有print方法：

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() {
        print(x)
    }
}

open class Parent {
    open fun print() {
        println("Parent print")
    }
}

class Derived(b: Base) : Parent(),Base by b

fun main(args: Array<String>) {
    val b = BaseImpl(10)
    Derived(b).print()
}

输出：10
可以看到父类print方法会被覆盖。

三.kotlin代理模式的总结

1.只能实现对接口方法的代理，即Base类不能为抽象类。
2.不方便对所有的代理方法进行统一处理。比如说在执行每个方法前都执行相同的逻辑，而java动态代理可以方便的实现这个功能。
3.方法名称有冲突时，代理类方法优先级较高。
4.编译期自动生成代理模式。不会影响运行效率。

四.继承和代理的选择

如果仅仅是代码复用和方法重写，继承能达到和代理一样的效果。

继承和代理的使用都存在条件限制：

如果使用继承的话，父类必须为可继承的，并且想要覆盖的方法也必须为可重写的，即java中类和方法都不能存在final修饰符，kotlin中明确使用open修饰符。

使用代理的话，两者需要存在公共接口，比如上面例子中类Derived和Parent都需要实现Base接口。

由于kotlin、java存在单继承的约束（每个类只能存在一个父类），在使用继承或者代理均可的情况下，推荐使用代理。