在决定调用哪个方法时如何避免 if..else（或任何条件）？

Question

How to follow Open Close Principle without violating LSP while deciding which method to be invoked with different parameters in a statically typed language?

Consider the requirement like

• Action 1: perform DB operation on Table 1

• Action 2: Perform DB operation on Table 2 based on input

• Action 3: Do Nothing

Code for above requirement would look like

process(obj) {
    
    if(obj.type === action1) {
       db.updateTable1()
    }
    if(obj.type === action2) {
       db.updateTable2(obj.status)
    }
    if(obj.type === action3) {
       //May be log action 3 recieved
    }
}

Figured out a way to follow OCP in above code for additional actions, by moving body of if statement to method and maintain a map of keys with action as name. Reference

However feels solution is violating the OCP as method wrapping the contents of first if block will not receive any parameter, second method wrapping the contents of second if block will have a parameter.

Either it forces all method to follow the same signature in trade off following OCP but violating LSP or give up OCP itself and thereby live with multi if statements.

Answer 1

Flip it. Make the object define the behaviour, not the process.

Now, a collection of objects conforming to the parent class can call Update() and perform an appropriate action without checking the type.

ParentClass {
    Update() {}
}

Class1 : ParentClass {
    Update() {
        db.updateTable1()
    }
}

Class2 : ParentClass {
    Update() {
        db.updateTable2(class2.status)
    }
}

Class3 : ParentClass {
    Update() { 
        // do nothing
    }
}

Answer 2

A simple solution would be to define a strategy, which execute the code currently contained in the if / else if / else branches:

interface Strategy {
  String getType();
  void apply();
}

The strategies need to be registered:

class Executor {
  private Map<String, Strategy> strategies;

  void registerStrategy(strategy Strategy) {
    strategies.put(strategy.getType(), strategy);
  }

  void process(obj) {
    if (strategies.containsKey(obj.type)) {
      // apply might execute db.updateTable1(),
      // depending on the interface's implementation
      strategies.get(obj.type).apply();
    } else {
      System.out.println("No strategy registered for type: " + obj.type);
    }
  }
}

Answer 3

The nature of obj is ambiguous, but I would recommend having a well-defined interface and pass it throughout your code where the class implementation of your interface would be equivalent to your 'action'. Here's an example of what that might look like in Typescript:

interface someDBInterface {
  performAction() : void;
}

function process(obj : someDBInterface) {
  let result = obj.performAction();
}

class action1 implements someDBInterface {
  status: any
  performAction() {
    //db.updateTable1();
  }
}

class action2 implements someDBInterface {
  status : any
  performAction() {
    //db.updateTable1(this.status);
  }
}

class action3 implements someDBInterface {
  performAction() {
    //May be log action 3 recieved
  }
}

If this doesn't meet your requirements, feel free to reach out:)