Strategy Design Pattern in Java – Tutorial

Das Strategy Design Pattern ist eines der verschiedenen Design Pattern. Das Strategy Pattern wird verwendet, wenn wir mehrere Algorithmen für eine spezifische Aufgabe haben und der Kunde die tatsächliche Implementierung zur Laufzeit bestimmt.

Anwendungsbeispiel

Das Strategy Design Pattern ist auch bekannt als Policy Pattern. Wir definieren mehrere Algorithmen und lassen die Client-Anwendung den zu verwendenden Algorithmus als Parameter übergeben. Eines der besten Beispiele für das Strategy Design Pattern ist die Collections.sort()-Methode, die einen Comparator-Parameter nimmt. Basierend auf den verschiedenen Implementierungen von Comparator-Schnittstellen werden die Objekte auf unterschiedliche Weise sortiert.

Für unser Beispiel des Strategy Design Pattern werden wir versuchen, einen einfachen Einkaufswagen zu implementieren, in dem wir zwei Zahlungsstrategien haben – die Nutzung von Kreditkarte oder PayPal. Zuerst erstellen wir die Schnittstelle für unser Strategy Design Pattern Beispiel, in unserem Fall, um den übergebenen Betrag zu bezahlen. PaymentStrategy.java:

package com.journaldev.design.strategy;

public interface PaymentStrategy {

    public void pay(int amount);
}

Nun müssen wir für das Strategy Design Pattern konkrete Implementierungen von Algorithmen für die Zahlung mit Kredit-/Debitkarte oder über PayPal erstellen. CreditCardStrategy.java:

package com.journaldev.design.strategy;

public class CreditCardStrategy implements PaymentStrategy {

    private String name;
    private String cardNumber;
    private String cvv;
    private String dateOfExpiry;
    
    public CreditCardStrategy(String nm, String ccNum, String cvv, String expiryDate){
        this.name=nm;
        this.cardNumber=ccNum;
        this.cvv=cvv;
        this.dateOfExpiry=expiryDate;
    }
    @Override
    public void pay(int amount) {
        System.out.println(amount +" paid with credit/debit card");
    }

}

PaypalStrategy.java:

package com.journaldev.design.strategy;

public class PaypalStrategy implements PaymentStrategy {

    private String emailId;
    private String password;
    
    public PaypalStrategy(String email, String pwd){
        this.emailId=email;
        this.password=pwd;
    }
    
    @Override
    public void pay(int amount) {
        System.out.println(amount + " paid using Paypal.");
    }

}

Nun sind unsere Algorithmen für das Strategy Design Pattern Beispiel bereit. Wir können einen Einkaufswagen implementieren und die Zahlungsmethode wird den Eingang als Zahlungsstrategie benötigen. Item.java:

package com.journaldev.design.strategy;

public class Item {

    private String upcCode;
    private int price;
    
    public Item(String upc, int cost){
        this.upcCode=upc;
        this.price=cost;
    }

    public String getUpcCode() {
        return upcCode;
    }

    public int getPrice() {
        return price;
    }
    
}

ShoppingCart.java:

package com.journaldev.design.strategy;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

public class ShoppingCart {

    //List of items
    List items;
    
    public ShoppingCart(){
        this.items=new ArrayList();
    }
    
    public void addItem(Item item){
        this.items.add(item);
    }
    
    public void removeItem(Item item){
        this.items.remove(item);
    }
    
    public int calculateTotal(){
        int sum = 0;
        for(Item item : items){
            sum += item.getPrice();
        }
        return sum;
    }
    
    public void pay(PaymentStrategy paymentMethod){
        int amount = calculateTotal();
        paymentMethod.pay(amount);
    }
}

Beachten Sie, dass die Zahlungsmethode des Einkaufswagens einen Zahlungsalgorithmus als Argument benötigt und ihn nirgendwo als Instanzvariable speichert. Lassen Sie uns unser Strategy Design Pattern Beispiel Setup mit einem einfachen Programm testen. ShoppingCartTest.java:

package com.journaldev.design.strategy;

public class ShoppingCartTest {

    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        
        Item item1 = new Item("1234",10);
        Item item2 = new Item("5678",40);
        
        cart.addItem(item1);
        cart.addItem(item2);
        
        //pay by paypal
        cart.pay(new PaypalStrategy("myemail@example.com", "mypwd"));
        
        //pay by credit card
        cart.pay(new CreditCardStrategy("Pankaj Kumar", "1234567890123456", "786", "12/15"));
    }

}

Output des oben genannten Programms ist:

50 paid using Paypal.
50 paid with credit/debit card

Wichtige Punkte des Strategy Design Pattern

• Wir hätten Komposition verwenden können, um eine Instanzvariable für Strategien zu erstellen, aber das sollten wir vermeiden, da wir die spezifische Strategie für eine bestimmte Aufgabe anwenden möchten. Dies wird auch in den Collections.sort()- und Arrays.sort()-Methoden befolgt, die einen Comparator als Argument nehmen.
• Das Strategy Design Pattern ist dem State Pattern sehr ähnlich. Ein Unterschied besteht darin, dass der Kontext den Zustand als Instanzvariable enthält und es mehrere Aufgaben geben kann, deren Implementierung vom Zustand abhängen kann, während im Strategy Pattern die Strategie als Argument an die Methode übergeben wird und das Kontextobjekt keine Variable zum Speichern hat.
• Das Strategy Pattern ist nützlich, wenn wir mehrere Algorithmen für eine spezifische Aufgabe haben und wir möchten, dass unsere Anwendung flexibel ist, um einen der Algorithmen zur Laufzeit für eine spezifische Aufgabe zu wählen.