Question

We have App A as main app. Now we build from it App B which uses a subset of App A’s functionality.

App A stays like it is whereas app B only uses a subset of A

So I want to refactor the function without or with as little dublication as possible and with maximum readability.

So the function looks like this (it is actually longer, this is an excerpt):

  class SomeClass {

    Data prepareData() {

     if (this.bothId==1 || this.appAid=2 /*or only relevant for appA*/) {       
        if(this.data==null) { /*appA*/
            appAdoSmth(); /*appA*/
        }
        boolean merge=false; /*appA*/
        if (this.data==null) { /*appA*/
          merge=appAanalyze(data); /*appA*/
        }
        bothPrepare(merge); 
    } else if (bothIsRelevant()) {
      if(appArelevant()) { /*appA*/
        data=appAprepare(); /*appA*/
      } else {
        data=prepareBoth(); 
      }     
      bothUpdateSomeValue();
    }

  }

How would you do it?

Answer 1

Other Answers address the general question of how to refactor code. They offer good advice, but I don’t think it is what you are asking.

I think you are asking about possible refactorings of the code in your question.

It is hard to give an answer that is generally applicable, or even specifically applicable. (The sample code isn’t your real code, and it is a little difficult to understand what it actually “means”).

• AndreasD gives one approach: break the big complicated nested if into separate methods.

• Another approach is to use the Stragegy design pattern. Separate the code that is specific to each app into strategy classes. For example:

  interface Strategy {
      Data prepareData();
  }
  
  class GeneralStrategy implements Strategy {
      Data prepareData() {
          // do general preparation
      }
  }
  
  class App1Strategy extends GeneralStrategy {
      Data prepareData() {
          // do app1-specific preparation
          super.prepareData();
          // do more app1-specific preparation
      }
  }
  

and so on.