UML erstellen mit strategy pattern

Question

Frage:

Die Betreibenden eines Webshops wollen das Strategy Pattern nutzen, um verschiedene Strategien zur Berechnung der Gesamtkosten eines Online-Warenkorbs umzusetzen. Konkret gibt
es drei verschiedene Abrechnungsstrategien:

Regulär Die Gesamtkosten werden ganz regulär als Summe aller Einzelkosten berechnet.
Rabatt Auf die Summe aller Einzelkosten werden 20% Rabatt gewährt.
Aktion Wenn mindestens drei Elemente im Warenkorb sind, ist das günstigste davon umsonst,
für alle anderen wird der normale Preis berechnet.

Das Listing 1 zeigt einen Auszug (angedeutet durch [...]) aus der Implementation der Klasse Warenkorb, die in diesem Beispiel als Kontext der Strategie agiert. Der Auszug zeigt, wie die
AbrechnungsStrategie genutzt wird. Es ist nun Ihre Aufgabe, die drei oben genannten Stra-
tegien umzusetzen. Bearbeiten Sie auf dazu die folgende Aufgabe:

a) Zeichnen Sie ein gültiges UML Klassendiagramm, welches die Beziehung der Entitäten
Warenkorb, AbrechnungsStrategie sowie der drei oben genannten Strategien unter-
einander, sowie die jeweils relevanten Felder und Methoden darstellt.

b) Geben Sie gültigen Java-Code für die Umsetzung der drei oben genannten Strategien,
sowie der Entität AbrechnungsStrategie an. Der Code muss zu der in Listing 1 gezeigten
Implementation kompatibel sein.

1 class Warenkorb {
2
3 [...]
4
5 private final AbrechnungsStrategie strategy ;
6
7 public Warenkorb ( AbrechnungsStrategie s) {
8 this. strategy = s;
9 }
10
11 public double berechneGesamtkosten (List <Double > einzelkosten ){
12 return this. strategy . berechne ( einzelkosten );
13 }
14 }

Listing 1: Auszug aus der Klasse Warenkorb

Leider weiß ich nicht genau, wie ich ein UML zeichnen kann.

Answer 1

Antwort mit KI erzeugt

a) UML Klassendiagramm

Hier ist das UML-Klassendiagramm, welches die Beziehung der Klasse Warenkorb, der abstrakten Klasse AbrechnungsStrategie und der drei konkreten Strategien (RegulaerStrategie, RabattStrategie, AktionStrategie) zeigt. Die relevantesten Felder und Methoden sind ebenfalls enthalten.

plaintext
+------------------------------------------------------+
|                        Warenkorb                     |
|------------------------------------------------------|
| - strategy: AbrechnungsStrategie                     |
|------------------------------------------------------|
| + Warenkorb(s: AbrechnungsStrategie)                 |
| + berechneGesamtkosten(einzelkosten: List<Double>):  |
|   double                                             |
+------------------------------------------------------+
                           |
                           |
                           v
+------------------------------------------------------+
|                   AbrechnungsStrategie               |
|------------------------------------------------------|
| + berechne(einzelkosten: List<Double>): double       |
+------------------------------------------------------+
         /                   |                    \
        /                    |                     \
+----------------+   +------------------+   +-------------------+
| RegulaerStrategie |   | RabattStrategie |   | AktionStrategie   |
|----------------- |   | ----------------|   | ------------------|
|+ berechne(einzel-|   |+ berechne(einzel-|   |+ berechne(einzel- |
| kosten: List<    |   | kosten: List<    |   | kosten: List<     |
| Double>): double |   | Double>): double |   | Double>): double  |
+------------------+   +------------------+   +-------------------+

b) Java-Code für die Strategien

Hier ist der Java-Code zur Umsetzung der drei genannten Strategien und der abstrakten Klasse AbrechnungsStrategie:

java
import java.util.List;
import java.util.Collections;

interface AbrechnungsStrategie {
    double berechne(List<Double> einzelkosten);
}

class RegulaerStrategie implements AbrechnungsStrategie {
    @Override
    public double berechne(List<Double> einzelkosten) {
        return einzelkosten.stream().mapToDouble(Double::doubleValue).sum();
    }
}

class RabattStrategie implements AbrechnungsStrategie {
    @Override
    public double berechne(List<Double> einzelkosten) {
        double summe = einzelkosten.stream().mapToDouble(Double::doubleValue).sum();
        return summe * 0.8; // 20% Rabatt
    }
}

class AktionStrategie implements AbrechnungsStrategie {
    @Override
    public double berechne(List<Double> einzelkosten) {
        if (einzelkosten.size() < 3) {
            return einzelkosten.stream().mapToDouble(Double::doubleValue).sum();
        } else {
            double minimalerPreis = Collections.min(einzelkosten);
            double summe = einzelkosten.stream().mapToDouble(Double::doubleValue).sum();
            return summe - minimalerPreis; // das günstigste Element ist umsonst
        }
    }
}

class Warenkorb {
    private final AbrechnungsStrategie strategy;
    
    public Warenkorb(AbrechnungsStrategie s) {
        this.strategy = s;
    }
    
    public double berechneGesamtkosten(List<Double> einzelkosten) {
        return this.strategy.berechne(einzelkosten);
    }

    public static void main(String[] args) {
        List<Double> einzelkosten = List.of(10.0, 20.0, 30.0);

        Warenkorb warenkorb = new Warenkorb(new RegulaerStrategie());
        System.out.println("Regulär: " + warenkorb.berechneGesamtkosten(einzelkosten));

        warenkorb = new Warenkorb(new RabattStrategie());
        System.out.println("Rabatt: " + warenkorb.berechneGesamtkosten(einzelkosten));

        warenkorb = new Warenkorb(new AktionStrategie());
        System.out.println("Aktion: " + warenkorb.berechneGesamtkosten(einzelkosten));
    }
}

Erläuterungen:
- AbrechnungsStrategie ist das Interface, welches die Methode berechne deklariert.
- RegulaerStrategie berechnet die Gesamtkosten als einfache Summe der Einzelkosten.
- RabattStrategie berechnet die Gesamtkosten und zieht 20% Rabatt ab.
- AktionStrategie berechnet die Gesamtkosten, lässt aber das günstigste Element kostenlos, falls es mindestens drei Elemente gibt.
- Warenkorb ist die Klasse, die das Strategy-Pattern nutzt, um die Gesamtkosten basierend auf der ausgewählten Strategie zu berechnen.

Die bereitgestellten Klassen sind kompatibel zu dem in Listing 1 gezeigten Code der Klasse Warenkorb.