Question

I often have a situation where I need to do:

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;
}

I feel like I am repeating myself, yet where I have ...., the methods are different, have different signatures, etc..

What do people normally do? Add an if (this type) do this stuff, else do the other stuff that is different? It doesn’t seem like a very good solution either.

Answer 1

Polymorphism and possibly abstraction and encapsulation are your friends here.

You should specify better what kind of instructions you have on the .... // do some things part. If you’re always using the same information, but doing different things with it, the solution is fairly easy using simple polymorphism. See my first revision of this answer. I’ll assume you need different information to do the specific tasks in each case.

You also didn’t specify if those functions are in the same class/module or not. If they are not, you can use inheritance to share the common parts and polymorphism to introduce different behavior in the specific part. If they are in the same class you don’t need inheritance nor polymorphism.

---

In different classes

Taking into account you’re stating in the question that you might need to make calls to functions with different signature depending on the implementation subclass (for instance, passing a or b as parameter depending on the case), and assuming you need to do something with the intermediate local variables (i.e. a and b) in the specific implementations:

Short version: Polymorphism+Encapsulation: Pass all the possible in & out parameters that every subclass might need to the abstract function. Might be less painful if you encapsulate them in an object.

Long Version
I’d store intermediate state in generic class’ member, and pass it to the implementation methods. Alternatively you could grab the State from the implementation methods instead of passing it as an argument. Then, you can make two subclasses of it implementing the doSpecificStuff(State) method, and grabbing the needed parameters from the intermediate state in the superclass. If needed by the superclass, subclasses might also modify state.

(Java specifics next, sorry)

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();
   }
}

---

In the same class

Another possibility would be making the preProcess() method return a State variable, and use it inthe implementations of a1() and 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();
  }
}