如何在限制性上下文中实现工厂模式？

Question

我有一堂课，比如说A，即extends B。 我不能改变类的名称，也不能改变什么。

但是，在A中有一种方法，比如doSomething（我不能重命名）。

根据一个标志，在A的构造函数中发送，我可以做某件事或其他事情。

根据标志给出所有这些限制，您如何建议处理doSomething中的叉子？

感谢

Answer 1

您可以选择在我看来2个选项之一：

• 使用标志和doSomething到2内的方法，根据该标志。例如：

  public class A extends B { 
      private boolean forkFlag; 
  
      public A (boolean forkFlag) { 
       this.forkFlag = forkFlag; 
      } 
  
      public void doSomething() { 
  
       if (forkFlag) { 
       doSomething1(); 
       } else { 
       doSomething2(); 
       } 
      } 
  
      private void doSomething1() { ... } 
  
      private void doSomething2() { ... } 
  } 
  

• 创建战略实施：

  public class A extends B { 
      private boolean forkFlag; 
      private Runnable doSomethingImpl; 
  
      public A (boolean forkFlag) { 
      if(forkFlag) { 
       doSomethingImpl = new DoSomethingImpl1(); 
      } else { 
       doSomethingImpl = new DoSomethingImpl2(); 
      } 
      } 
  
      public void doSomething() { 
       doSomethingImpl.run(); 
      } 
  } 
  
  
  
  public class DoSomethingImpl1 implements Runnable { 
  public void run() { ... } 
  } 
  
  public class DoSomethingImpl2 implements Runnable { 
      public void run() { ... } 
  } 
  

的2间决定取决于你的需要。如果这个分支是次要的，只是一个常规流程中的用例，我会选择第一个选项。如果您有机会可能需要第三个流程，我会采用策略模式，并享受它提供的解耦。

有了战略，你就可以注入你从类的外部要实施，是完全不知道的doSomething实施刚刚通过改变构造：

public A (Runnable doSomething) { 
    this.doSomething = doSomething; 
} 

喷射模式是最有可能优雅，并将创建一个完整的解耦您的代码从实施。此外，您可以将implements Runnable更改为您自己的更具体的界面public interface DoSomething，以使其更加健壮。

Answer 2

，你必须使用这里

public A(boolean flag){ 
    if(flag == true){ 
     this.service = new DoSomethingStrategy(); 
    }else{ 
     this.service = new DoSomethingElseStrategy(); 
    } 
} 

Strategy模式，如果你的代码的增长，在逻辑上，更好地在构造函数中使用一个工厂：

public A(boolean flag){ 
    this.service = DoSomethingFactory.getService(flag); 
} 

和代码复制DoSomethingFactory内;

终于在你的doSomething方法

public void doSomething(){ 
    this.service.doSomething(); 
} 

和你的DoSomething的行为被封装到一个战略结构。

Answer 3

没有进一步的信息：

public Foo doSomething() { 
    if(flag) { 
     return super.doSomething(); 
    } else { 
     return doSomethingElse(); 
    } 
} 

您可以使用策略模式，但它会增加几十行的代码比你应用设计模式的感觉其他没有什么好处。

在方法调用中必要的间接寻址，如果甚至可能会变慢。

Answer 4

为什么你不能创建另一个类C，它也扩展了B，并根据需要使用它来代替A？如果可以的话，通常避免使用条件和对课程内部的策略进行硬编码通常会更好。

您不需要触及基类，只需将其扩展为另一个实现即可。