中间的代码不同，其他都一样

Question

我经常遇到一种需要做的情况：

function a1() {
 a = getA;
 b = getB;
 b.doStuff();
 ....  // do some things
 b.send()
 return a - b;
}

function a2() {
 a = getA;
 b = getB;
 b.doStuff();
 ....  // do some things, but different to above
 b.send()
 return a - b;
}

我觉得我在重复自己，但我有 ....，方法不同，有不同的签名等等。

人们会做什么通常会做什么？添加一个 if （此类型）执行此操作，否则执行其他不同的操作？这似乎也不是一个很好的解决方案。

Answer 1

多态性以及可能的抽象和封装是你的朋友。

您应该在 .... // do some things 部分更好地指定您的指令类型。如果您总是使用相同的信息，但用它做不同的事情，那么使用简单的多态性解决方案相当容易。请参阅我对此答案的第一次修订。我假设您需要不同的信息来完成每种情况下的特定任务。

您也没有指定这些函数是否位于同一类/模块中。如果不是，您可以使用继承来共享公共部分，并使用多态性在特定部分中引入不同的行为。如果它们位于同一个类中，则不需要继承或多态性。

---

在不同的类中

考虑到您在问题中指出，您可能需要根据实现子类调用具有不同签名的函数（例如，传递 a或 b 作为参数，具体取决于情况），并假设您需要对中间局部变量（即 a 和 b）执行某些操作具体实现：

简短版本：多态+封装：将所有可能的in & 传递出去out 每个子类可能需要抽象函数的参数。如果将它们封装在一个对象中，可能会少一些痛苦。

长版
我将中间状态存储在泛型类的成员中，并将其传递给实现方法。或者，您可以从实现方法中获取状态，而不是将其作为参数传递。然后，您可以创建它的两个子类来实现 doSpecificStuff(State) 方法，并从超类中的中间状态获取所需的参数。如果超类需要，子类也可能会修改状态。

（接下来是 Java 细节，抱歉）

public abstract class Generic {
  private State state = new State();
  public void a() {
     preProcess();
     prepareState();
     doSpecificStuf(state);
     clearState();
     return postProcess();
  }
  protected void preProcess(){ 
     a = getA;
     b = getB;
     b.doStuff();
  }
  protected Object postProcess(){ 
     b.send()
     return a - b;
  }
  protected void prepareState(){ 
     state.prepareState(a,b);
  }
  private void clearState() { 
     state.clear();
  }
  protected abstract doSpecificStuf(State state);
}
public class Specific extends Generic { 
   protected doSpecificStuf(State state) { 
       state.getA().doThings();
       state.setB(someCalculation);
   }
}
public class Specific2 extends Generic { 
   protected doSpecificStuf(State state) { 
       state.getB().doThings();
   }
}

---

在同一个类中

另一种可能性是让 preProcess() 方法返回一个 State 变量，并使用它在 a1() 和 a2() 的实现中。

public class MyClass {
  protected State preProcess(){ 
     a = getA;
     b = getB;
     b.doStuff();
     return new State(a,b);
  }
  protected Object postProcess(){ 
     b.send()
     return a - b;
  }
  public void a1(){
      State st = preProcess();
      st.getA().doThings();
      State.clear(st);
      return postProcess();
  }
  public void a2(){
      State st = preProcess();
      st.getB().doThings();
      State.clear(st);
      return postProcess();
  }
}

Answer 2

好吧，不要重复自己。我的黄金法则（诚然，我有时会打破它）是基于 ZOI 规则：所有代码必须恰好存在零次、一次或无限次。如果您看到代码重复，您应该将其重构为共同的祖先。

也就是说，不可能给你一个明确的答案如何重构你的代码；有无数种方法可以做到这一点。例如，如果 a1() 和 a2() 驻留在不同的类中，那么您可以使用多态性。如果它们位于同一个类中，您可以创建一个接收匿名函数作为参数的函数，然后 a1() 和 a2() 只是该函数的包装器。也可以使用（颤抖）参数来更改函数行为。

Answer 3

您可以通过两种方式之一解决此问题。 a1 和 a2 都会调用 a3。 a3 将执行共享代码，并且：
1. 调用它作为参数接收的函数，该函数执行 a1 的中间部分或 a2 的中间部分（并且它们将传递正确的参数），
- 或 -
2.接收一个标志（例如布尔值），该标志将告诉它需要执行哪一部分，并且使用if语句将执行正确的代码。

Answer 4

这对于设计模式“模板方法”来说是大声尖叫的。

一般部分在超类中：

package patterns.templatemethod;

public abstract class AbstractSuper {

public Integer doTheStuff(Integer a, Integer b) {
    Integer x = b.intValue() + a.intValue();

    Integer y = doSpecificStuff(x);

    return b.intValue() * y;
}

protected abstract Integer doSpecificStuff(Integer x);
}

特殊部分在子类中：

package patterns.templatemethod;

public class ConcreteA extends AbstractSuper {

@Override
protected Integer doSpecificStuff(Integer x) {
    return x.intValue() * x.intValue();
}

}

对于每个特殊的解决方案，您都实现一个具有特定行为的子类。

如果将它们全部放入集合中，则可以迭代它们并始终调用通用方法，每个类都会发挥其魔力。 ;）

希望这有帮助