我们有（官方的？）此模式得名称？[关闭]

Question

在Java的一次关于继承的有用性的讨论中,我偶然发现了一个类的这种模式：

public final class Demo<T>
{
  private final T m_Value;
  private final Function<T,String> m_Processor;

  public Demo( final T value, final Function<T,String> processor )
  {
    m_Value = value;
    m_Processor = processor;
  }

  public final String process() { return m_Processor.apply( m_Value ); }
}

坦白地说，这个特殊的类的用处有限！但它应该只演示底层模式：我可以有相同类的实例，但每个实例都有不同的行为，因为我在创建时分配了不同的处理器。

甚至更糟的是，当m_processor不是最终的，并且我为它提供了一个setter时，它可以在它的生存期内改变它的行为。

由于这与JavaScript的行为类似，因此讨论的一位参与者为其创造了“JavaScript继承”的名称。

当然，我们可以开始讨论这个模式的有用性，或者它是否是一个反模式…但请不要在这里！我只是感兴趣的是如果已经有一个名字为它！

通过分配处理器来确定demo的行为类似于“策略”模式，在这方面，示例可能会被选错。

但是“策略”并不意味着是继承的替代，它利用了多态性。

更好的候选者将是“facade”或“adapter”（从目的来看），但它们的实现方式不同。

Answer 1

我认为这是一个组合凌驾于继承之上的例子。继承有时可能是矫枉过正。让我们举一个例子。

public interface Duck{
  public void fly();
}

public class DuckOne implements Duck{
  public void fly(){
     System.out.print("flying"!)
  }
}

public class DuckTwo implements Duck{
  public void fly(){
     System.out.print("flying"!)
  }
}

public class DuckThree implements Duck{
  public void fly(){
     System.out.print("can't fly"!)
  }
}

如您所见，fly方法可以在不同duck实现中通用。并且假设您需要更改一个常见的fly方法。您需要修改所有的duck子类。下面我们就来看看吧。

public interface Duck{
  public void fly();
}

public interface Fly{
  public void process();
}
public class CanFly implements Fly{
  public void process(){
     System.out.print("flying");
}
public class CanNotFly implements Fly{
  public void process(){
     System.out.print("not flying");
}

public class DuckOne implements Duck{
  private Fly fly;
  public DuckOne(Fly canFly){
     this.fly = fly;
  }
  public void fly(){
     fly.process();
  }
}

public class DuckTwo implements Duck{
  private Fly fly;
  public DuckTwo(Fly canFly){
     this.fly = fly;
  }
  public void fly(){
     fly.process();
  }
}

public class DuckOne implements Duck{
  private Fly fly;
  public DuckOne(Fly cannotFly){
     this.fly = fly;
  }
  public void fly(){
     fly.process();
  }
}

现在只能修改一个fly类。希望澄清其中的一个优点。