Come gestisco due algoritmi che sembrano uguali ma diversi?

Sembra il modello di metodo dei modelli :

A template method defines the program skeleton of an algorithm. One or more of the algorithm steps can be overridden by subclasses to allow differing behaviors while ensuring that the overarching algorithm is still followed.

Ad esempio:

abstract class Base {
    void stepOne(Object item) {
        // Do some stuff on item...
    }

    void stepTwo(Object item) {
        // Do some stuff on item...
    }

    void stepThree(Object item) {
        // Do some stuff on item...
    }

    void allSteps(Collection<Object> data) {
        for (Object x : data) {
            stepOne(x);
            stepTwo(x);
            stepThree(x);
        }
    }
}

class SpecificOne extends Base {
    @Override
    void stepTwo(Object item) {
        // Do something different on item
    }
}

class SpecificTwo extends Base {
    @Override
    void allSteps(Collection<Object> data) {
        for (Object x : data) {
            // The order is altered
            stepThree(x);
            stepTwo(x);
            stepOne(x);
        }
    }
}

Quindi useresti i diversi algoritmi come questo:

public class TMTest {
    public static void main(String[] args) {
        Collection<Object> items = ...;

        Base one = new SpecificOne();
        Base two = new SpecificTwo();

        one.allSteps(items);
        two.allSteps(items);
    }
}

Sembra che la procedura stessa debba essere estratta e quindi avere due metodi diversi, uno che esegue le iterazioni e chiama quella procedura all'interno e l'altra che la chiama una sola volta.

Risposta al commento:

Ricorda Non ripeterti . Una delle parti più importanti dell'architettura è capire come organizzare il codice in modo che i metodi che hanno ancora parti simili abbiano parti simili separate in modo che possano essere condivise. Se sembrano eseguire lo stesso algoritmo ma con diversi parametri , questa è un'opportunità perfetta per un metodo (o, se ci sono più uscite, forse una classe).

Dai un'occhiata dal punto di vista dell'utente. Quando un utente di uno degli algoritmi avrà bisogno dell'altro? Quando un utente risolve un tipico problema per cui questi algoritmi si adattano bene, ha senso per lui passare da one-step a iterativo (o back) a seconda di alcune circostanze? Cioè, se dovessi semplicemente usare questi algoritmi, il parametro iterative avrebbe senso nel tuo lavoro quotidiano?