深入理解Java中的Lambda表達式

 Java 8 开始出现，带来一个全新特性：使用 Lambda 表达式 (JSR-335) 进行函数式编程。今天我们要讨论的是 Lambda 的其中一部分：虚拟扩展方法，也叫做公共辩护(defender)方法。该特性可以让你在接口定义中提供方法的默认实现。例如你可以为已有的接口（如 List 和 Map）声明一个方法定义，这样其他开发者就无需重新实现这些方法，有点像抽象类，但实际却是接口。当然，Java 8 理论上还是兼容已有的库。
虚拟扩展方法为 Java 带来了多重继承的特性，尽管该团队声称与多重继承不同，虚拟扩展方法被限制用于行为继承。或许通过这个特性你可以看到了多重继承的影子。但你还是可以模拟实例状态的继承。我将在接下来的文章详细描述 Java 8 中通过 mixin 混入实现状态的继承。
什么是混入 mixin?
混入是一种组合的抽象类，主要用于多继承上下文中为一个类添加多个服务，多重继承将多个 mixin 组合成你的类。例如，如果你有一个类表示“马”，你可以实例化这个类来创建一个“马”的实例，然后通过继承像“车库”和“花园”来扩展它，使用 Scala 的写法就是：
 
val myHouse = new House with Garage with Garden
从 mixin 继承并不是一个特定的规范，这只是用来将各种功能添加到已有类的方法。在 OOP 中，有了 mixin，你就有通过它来提升类的可读性。
例如在 Python 的  socketserver 模块中就有使用 mixin 的方法，在这里，mixin 帮助 4 个基于不同 Socket 的 服务，包括支持多进程的 UDP 和 TCP 服务以及支持多线程的 UDP 和 TCP 服务。

public interface Collection<T> extends Iterable<T> {
  
  <R> Collection<R> filter(Predicate<T> p)
    default { return Collections.<T>filter(this, p); }
  
}

public interface SwitchableMixin {
  boolean isActivated() default { return Switchables.isActivated(this); }
  void setActivated(boolean activated) default { Switchables.setActivated(this, activated); }
}

public final class Switchables {
  
  private static final Map<SwitchableMixin, SwitchableDeviceState> SWITCH_STATES = new HashMap<>();
  
  public static boolean isActivated(SwitchableMixin device) {
    SwitchableDeviceState state = SWITCH_STATES.get(device);
    return state != null && state.activated;
  }
  
  public static void setActivated(SwitchableMixin device, boolean activated) {
    SwitchableDeviceState state = SWITCH_STATES.get(device);
    if (state == null) {
      state = new SwitchableDeviceState();
      SWITCH_STATES.put(device, state);
    }
    state.activated = activated;
  }
  
  private static class SwitchableDeviceState {
    private boolean activated;
  }
  
}

private static class Device {}
  
private static class DeviceA extends Device implements SwitchableMixin {}
  
private static class DeviceB extends Device implements SwitchableMixin {}

interface FakeBrokenMixin {
  static Map<FakeBrokenMixin, String> backingMap
    = Collections.synchronizedMap(new WeakHashMap<FakeBrokenMixin, String>());
  
  String getName() default { return backingMap.get(this); }
  void setName(String name) default { backingMap.put(this, name); }
}
  
interface X extends Runnable, FakeBrokenMixin {}
  
X makeX() { return () -> { System.out.println("X"); }; }
  
  X x1 = makeX();
  X x2 = makeX();
  x1.setName("x1");
  x2.setName("x2");
  
  System.out.println(x1.getName());
  System.out.println(x2.getName());

x1
x2

MyTest$1@30ae8764
MyTest$1@123acf34

x2
x2

MyTest$$Lambda$1@5506d4ea
MyTest$$Lambda$1@5506d4ea

private static void lambda$0() {
  System.out.println("X");
}

interface Switchable {  boolean isActive();
  void setActive(boolean active);
}

public interface SwitchableView extends Switchable {
  Switchable getSwitchable();
  
  
  boolean isActive() default { return getSwitchable().isActive(); }
  void setActive(boolean active) default { getSwitchable().setActive(active); }
}

public class SwitchableImpl implements Switchable {
  
  
  private boolean active;
  
  
  @Override
  public boolean isActive() {
    return active;
  }
  
  
  @Override
  public void setActive(boolean active) {
    this.active = active;
  }
}

public class Device {}
  
  
public class DeviceA extends Device implements SwitchableView {
  private Switchable switchable = new SwitchableImpl();
  
  
  @Override
  public Switchable getSwitchable() {
    return switchable;
  }
}
  
  
public class DeviceB extends Device implements SwitchableView {
  private Switchable switchable = new SwitchableImpl();
  
  
  @Override
  public Switchable getSwitchable() {
    return switchable;
  }
}