Scelta più pulita per operazioni simmetriche

Question

Scelta più pulita per operazioni simmetriche

#1 da (2 voti)
#2 da (0 voti)

1

Ho bisogno di eseguire alcune elaborazioni da un formato A a un formato B e da B a A. Il lavoro in una direzione è molto simile alla sua controparte. Entrambi i formati sono rappresentati con un'interfaccia Msg .

In tal caso, posso vedere quattro soluzioni ovvie, che è la più pulita? Spero che ci siano dei principi concreti che spiegano una scelta rispetto alle altre e non solo preferenze personali

Ecco le scelte ovvie

1) Classi diverse per ogni

public class TransformToA {
   public TransformToA() {
       ...
   }
   public Msg transform(Msg incoming) {
       ...
   }
}
public class TransformToB {
   public TransformToB() {
       ...
   }
   public Msg transform(Msg incoming) {
       ...
   }
}

Si noti che in questa opzione, potrei estrarre alcune logiche comuni in una terza classe comune per evitare la duplicazione del codice

2) Un campo booleano per definire la direzione

public class Transformer {
   private boolean toBFormat;
   public Transformer(boolean toBFormat) {
       ...
   }
   public Msg transform(Msg incoming) {
       if (toBFormat) {
          ...
       } else {
          //to A format
       }
   }
}

3) un flag booleano sul metodo (questo è probabilmente il peggiore dal momento che il chiamante è costretto a passare il flag ogni volta e fa sì che un metodo si comporti in due modi diversi)

public class Transformer {
   public Transformer() {
       ...
   }
   public Msg transform(Msg incoming, boolean toBFormat) {
       if (toBFormat) {
          ...
       } else {
          //to A format
       }
   }
}

4) Due metodi diversi

public class Transformer {
   public Transformer() {
       ...
   }
   public Msg transformToA(Msg incoming) {
       ...
   }
   public Msg transformToB(Msg incoming) {
       ...
   }
}

object-oriented design java interfaces

posta Hilikus 05.11.2014 - 16:07

fonte

2 risposte

Leggi altre domande sui tag object-oriented design java interfaces

Come faccio a verificare le modifiche al codice che sono il risultato della sincronizzazione? Gestione dei file generati in un progetto di Visual Studio

score 2 · Answer 1

Stai descrivendo una sorta di costruttore di copie: utilizzando un'istanza Msg per costruirne un'altra. Lo implementerei come tale, trovando un altro posto dove mettere la funzionalità di supporto comune.

public class A implements Msg {
  public A(Msg msg){...}
}

public class B implements Msg {
  public B(Msg msg){...}
}

Tuttavia, sei stato vago sulle tue ragioni per effettuare la trasformazione e sospetto che ci sia un altro problema in corso. Sembra che tu stia cercando di fare troppo nelle classi A e B . Forse dovresti dividere Msg nella sua stessa classe che agisce solo come modello, quindi avere A e B agire di più come una vista, con solo la funzionalità in cui è importante il formato in cui si trova.

Ad esempio, se Msg era un documento di foglio di calcolo e A e B sono formati Excel o OpenDocument, allora dovresti fare la maggior parte del tuo lavoro nel formato Msg interno e crea solo un A o B mentre stai leggendo o scrivendo il tuo documento su disco.

score 0 · Answer 2

Esistono molte soluzioni pulite.

La mia scelta in Java sarebbe sicuramente la seguente struttura:

public abstract class AbstractTransform {

    ... do whatever is the same in all transformer, 
        or if the constructor would be the same etc...

    protected void iDoThisAllTheTime(){
        ... boring, repeating codes come here
    }

    public Msg transform(Msg incoming);

}

quindi estendi questa classe di abtract e implementa il metodo mancante:

public class TransformToA extends AbstractTransform {

    @Override
    public Msg transform(Msg incoming){
        ... do the transformation
        iDoThisAllTheTime();
    }

}

Advatanges:

facile da estendere nel modo desiderato. Se ne hai bisogno, aggiungilo ancora una volta.
documenti in sé, è necessario documentare praticamente solo l'Abstract per dire a cosa serve. Il resto delle classi farà lo stesso.
se hai bisogno di logiche comuni, puoi implementarlo in classe astratta, eviterai duplicazioni. È possibile implementare metodi protetti per uso comune e richiamarli nelle classi figlie.
non complicato. Non è necessario manipolare le classi, le interfacce se l'attività è semplice, il codice può rimanere semplice.