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) {
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) {
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) {
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存在单继承的约束（每个类只能存在一个父类），在使用继承或者代理均可的情况下，推荐使用代理。