Problema con il design OOP

Question

Problema con il design OOP

#1 da (1 voti)

-1

Ho un problema con la progettazione di alcune classi semplici. Voglio quattro classi: una elimina ricorsivamente la directory, un'altra copia una dir allo stesso modo. Altri due fanno lo stesso dei primi due, ma aggiungono un comportamento osservabile: calcola pochi parametri come il tempo stimato o le percentuali di funzionamento e attivano gli osservatori. Qual è il modo migliore di progettarli?

il modo più semplice per fare questo schema:

ma ho problemi con la violazione del principio DRY nel codice che calcola percentuali e altri valori nella classe osservabile.

Posso spostare quel codice in classe astratta ma ho bisogno di estendere quella classe astratta e la classe Copy o Delete appropriata, questo è vietato in java

Ho deciso di implementare un modello di strategia ma questa uml e il mio codice hanno ancora un odore.

qual è la soluzione migliore qui, dove sono i miei errori?

object-oriented java design-patterns uml

posta Vincent 09.02.2017 - 01:44

fonte

1 risposta

Leggi altre domande sui tag object-oriented java design-patterns uml

Come minimizzare la duplicazione del codice? [chiuso] Eliminando le scelte dei linguaggi di programmazione? [chiuso]

score 1 · Accepted Answer

Hai alcune alternative. Ognuno ha vantaggi e svantaggi. Non c'è una formula magica per programmare; devi fare delle scelte basate sulla tua ipotesi migliore su cosa funzionerà.

Fallo parte della classe base

Potresti implementarlo come parte della classe base Action .

public abstract class Action {
    private List<Listener> listeners;

    public Action() {
        this.listeners = new ArrayList<Listener>();
    }

    public void addListener(Listener l) {
        this.listeners.add(l);
    }

    // You'll need a remove listener function, too.

    public final void performAction() {
        for(Listener l: this.listeners) {
            l.notify(/* args here*/);
        }
        this.innerPerformAction();
    }

    protected abstract void innerPerformAction();
}

Il vantaggio principale di questo è che ogni Action può avere ascoltatori. Nessuno può sostanziarne uno che non sia in grado di notificare un altro pezzo di codice.

Implementa un wrapper

La composizione potrebbe essere una buona idea qui.

public class ObservableAction extends Action {
    private List<Listener> listeners;
    private Action action;

    public ObservableAction(Action a) {
        this.listeners = new ArrayList<Listener>();
        this.action = a; 
    }

    public void addListener(Listener l) {
        this.listeners.add(l);
    }

    public void performAction() {
        // Do "observing" here
        this.action.performAction();
    }
}

Poi,

Action deleteAction = new ObservableAction(new DeleteAction());

Questo ha più senso se hai bisogno di più osservazioni mirate, solo in alcuni punti. Oppure se non puoi modificare Action del tutto (ad es. È in una libreria di terze parti).