How to avoid duplicated if statements

To achieve this requirement, we need to pattern.

1. Factory pattern.
2. Strategy pattern.

TypeFactory creates an object based on the string we delivered. Each Type implementation implements a doSomething() method in its own way. (factory pattern is used here)

Type Strategy:

interface Type{
    public void doSomething();
}

class TypeOne implements Type{
    @Override
    public void doSomething() {
        System.out.println("Type One!");    
    }
}

class TypeTwo implements Type{
    @Override
    public void doSomething() {
        System.out.println("Type Two!");
        
    }
}

Type Factory:

class TypeFactory{
    Type type;
    public Type createType(String condition) {
        if (condition == null || condition.isEmpty()) {
            return null;
        }
        if ("type1".equals(condition)) {
            return new TypeOne();
        }
        else if ("type2".equals(condition)) {
            return new TypeTwo();
        }
        return null;
    }
}

Now to achieve the final goal, we need to declare a Service interface with an execute method. This execute method takes Type as an input parameter. Based on which type you actually pass, the corresponding doSometing method will be invoked. (strategy pattern used only)

interface Service{
    public void execute(Type type);
}

class ServiceOne implements Service{

    @Override
    public void execute(Type type) {
        System.out.print("Service One - ");
        type.doSomething();
        
    }
}

class ServiceTwo implements Service{

    @Override
    public void execute(Type type) {
        System.out.print("Service Two - ");
        type.doSomething();
        
    }
}

Main Class looks like this:

public class DesignPatternCombo {

    public static void main(String[] args) {
        
        Type typeOne = new TypeFactory().createType("type1");
        Type typeTwo =  new TypeFactory().createType("type2");
        
        Service serviceOne = new ServiceOne();
        serviceOne.execute(typeOne);
        
        Service serviceTwo = new ServiceTwo();
        serviceTwo.execute(typeOne);
        serviceTwo.execute(typeTwo);

    }

}

Expected output:

Service One - Type One!
Service Two - Type One!
Service Two - Type Two!

Tricky question, I may have a solution that could work.

That would be to store the Types, with the code that type does in the form of a HashMap.

HashMap<String, Function<Void, Void>> types = new HashMap<String, Function<Void, Void>>();

Then in the main function, you would fill up the HashMap with the names of the types, and the function it runs.

types.put("Type1",()->{
    /*Do something*/
});
types.put("Type2",()->{
    /*Do something*/
});
types.put("Type3",()->{
    /*Do something*/
});

Then in the Service, you would have an array of Strings for what types it uses. Such as:

String[] serviceTypes = {"Type1", "Type2"};

Finally, in the execute function of the Service you would run the corresponding lambda to the string.

public void execute(String type){
    if((new ArrayList<>(Arrays.asList(serviceTypes))).contains(type)) {
        Main.types.get(type);
    }
}

You might work with an abstract base class.

The base class implements Service and has the execute() method. It does not get around if statements, but after all it could have a list of allowed values, and as soon as the type parameter is contained in the list it would call another method. Per default the method does nothing.

Concise subclasses of the base no longer need to perform the if conditions as they simply override the single methods in the base class. So this works for a whole bunch of quite similar services. The advantage of this approach is if you have some exotic, incompatible type of service you can skip the if statements by directly overwriting the execute() method. So that pattern is extensible, which is probably worth more than saving a few more if statements.

You can solve this elegantly with the Strategy Design Pattern.

1. Create a common interface called Strategy

interface Strategy {
  void execute(JSONObject payload);
}

2. Create multiple implementations of Strategy according to your needs:

class ServiceType1 implements Strategy {
  //constructors and fields
  @Override
  public void execute(JSONObject payload) {
    //code to be executed for "type1"
  }
}

class ServiceType2 implements Strategy {
  //constructors and fields
  @Override
  public void execute(JSONObject payload) {
    //code to be executed for "type2"
  }
}

...

3. Group the Service implementations by type, eg.:

Map<String, Strategy> strategyMap = new HashMap<>();
strategyMap.put("type1", new ServiceType1());
strategyMap.put("type2", new ServiceType2());
...

4. Invoke the desired Service without the need for any if statements, like this:

private static void exec(String payloadType, JSONObject payload) {
  strategyMap.get(payloadType).execute(payload);
}

P.S.: if all implementations of Strategy share some common behaviour, you can convert Strategy from interface to abstract class and move the common behaviour there.

wow, your architecture seems much complex. you should consider better hierarchy. but if you can't, why don't you just make a method on Service and let the subtype decide what behavior they want. Then you can call that method from Service to execute

static class Main {
        
        public static void main(String[] args) {
            exec(new B());
        }

        private static void exec(Service service){
            service.execute();
        }
    }

    interface Service{
        void execute();
    }
    
    interface Init{
        public void init();
    }

    interface Action{
        public void action();
    }

    static class A implements Service, Init{
        @Override
        public void init(){
            System.out.println("init a");
        }

        @Override
        public void execute(){
            init();
        }
    }

    static class B implements Service, Init, Action{

        @Override
        public void init(){
            System.out.println("init b");
        }

        @Override
        public void action(){
            System.out.println("action");
        }

        @Override
        public void execute(){
            action();
        }
    }

What about extracting common logic to the separate class. It cloud be:

• BaseService and all other services should implement this one;
• ServiceDelegate and all other services should delegate all work to this one.

The below snippet provides the first solution.

// This is you Service interface
public interface Service {

    void execute(JSONObject payload, String payloadType);
}

// This is base implementation. Use `Map` to replace `if` statements
public abstract class BaseService implements Service {

    private static final Consumer<JSONObject> NULL = jsonObject -> { };

    private final Map<String, Consumer<JSONObject>> consumers;

    protected BaseService(Map<String, Consumer<JSONObject>> consumers) {
        this.consumers = consumers == null || consumers.isEmpty() ? Map.of()
                                : Collections.unmodifiableMap(consumers);
    }

    @Override
    public final void execute(JSONObject payload, String payloadType) {
        consumers.getOrDefault(payloadType, NULL).accept(payload);
    }
}

public class ConcreteService extends BaseService {

    private static final Consumer<JSONObject> DO_SOMETHING_TYPE1 = jsonObject -> {
        // TODO implementation for "type1"
    };

    private static final Consumer<JSONObject> DO_SOMETHING_TYPE2 = jsonObject -> {
        // TODO implementation for "type2"
    };

    public ConcreteService() {
        super(Map.of(
                "type1", DO_SOMETHING_TYPE1,
                "type2", DO_SOMETHING_TYPE2));
    }
}