Finden Sie heraus, welches Designmuster verwendet werden soll?

Question

In den meisten Funkgeräten können wir die Welle, die wir erkunden und die Stationen hören möchten, mit dem Demodulationsmodus konfigurieren, der mit diesem Typ kompatibel ist.

Es gibt mindestens zwei Typen AM und FM. Wir können das Funkgerät in diesem Fall wie folgt modellieren:

class RadioDevice { 
    void demodulate (String m) { 
     if(m.equals("FM") 
      /* FM modelation */ 
     else if(m.equals("AM") 
      /* AM modelation */ 
    } 
} 

Wie kann ich das Strategie-Muster in diesem Fall anwenden?

Answer 1

Warum verwenden Sie keinen Polymorphismus?

Machen Sie eine Schnittstelle:

interface Radio { 
    void modulate(); 
} 

Und als implementieren 2 Klassen:

FMRadio implements Radio{ 

    public void demodule(){ 
     //FM modulation 
    } 
} 

AMRadio implements Radio{ 

    public void demodule(){ 
     //AM modulation 
    } 
} 

Und als, in der Haupt, könnten Sie gehen:

Radio myRadio = new FMRadio(); 
myRadio.demodule(); 

Answer 2

Wenn Sie können eine Schnittstelle, die den Vertrag für AM- und FM-Demodulation abdeckt, können Sie das Strategie-Muster verwenden:

Demodulator d; // interface Demodulator { byte[] demodulate(); } 
switch(m) { 
    case "AM": 
     d = new AMDemodulator(); 
     break; 
    case "FM" 
     d = new FMDemodulator(); 
     break; 
    default: 
     throw new IllegalArgumentException("Unsupported type '"+ m + "'"); // you could use an Enum instead of a String 
} 
d.demodulate(waves); 

Auf diese Weise können Sie die Demodulator Teil im laufenden Betrieb wechseln, während der Rest der Programmlogik gemeinsam (keine Vervielfältigung) zu halten.

prüfen diese Repo (nicht von mir) für Design-Muster und Beispiele: https://github.com/iluwatar/java-design-patterns

Answer 3

Um es eine richtige Strategie Muster zu machen, würde ich mit einem Context Klasse auf die vorherige Antwort von @Ladislav_M hinzufügen, die & encapsulate umbrochen eine bestimmte Strategie Ausführung und mehr Flexibilität, um den Code geben:

class Context { 
    private Radio radio; 

    public Context(Radio radio) { 
     this.radio = radio; 
    } 

    public Object runStrategy() { 
     radio.demodulate(); 
     // do any other stuff you want 
     return ... 
    } 
} 

die Ausführung in main wäre bequemer geworden:

Context context = new Context(new FmRadio()); 
Object result = context.runStrategy(); 

Oder Sie können die oben Inline:

Object result = (new Context(new FmRadio())).runStrategy(); 

Natürlich können Sie die Implementierung von Radio in einem switch Block wählen und es einfach passieren als Variable der Context ‚s-Konstruktor.

Answer 4

Dies ist kein guter Anwendungsfall für Strategie Designmuster, seine einfache Vererbung Fall. Die Strategie wird verwendet, wobei sich der Status des Objekts nicht ändert, aber unterschiedliche Algorithmen zu unterschiedlichen Zeiten gelten. z.B. PayPackage-Berechnung für verschiedene Rollen von Mitarbeitern (z. B. temporäre, permanente etc.). Wichtiger Punkt hier ist, dass temporäre Mitarbeiter eines Tages dauerhaft werden können.

Im obigen Fall wird AM in seiner Lebenszeit niemals zu FM. Daher ist Strategie nicht das richtige Muster dafür. Dies sind (wahrscheinlich) verschiedene Klassen mit gemeinsamem Verhalten (falls vorhanden), die in die Basisklasse verschoben werden können. Wenn sie einen gemeinsamen Vertrag mit Kunden zeigen, wird sogar die Schnittstelle die Aufgabe übernehmen.