Filmbuchungssystem

Anforderungen prüfen

• Wir möchten ein Online-Filmbuchungssystem implementieren.
• Der Film repräsentiert die Basisinformationen über den Film.
  • Titel, Laufzeit, Preisinformationen usw.
• Die Vorführung repräsentiert das tatsächliche Ereignis, bei dem das Publikum den Film sieht.
  • Datum der Vorführung, Uhrzeit, Nummer usw.
• Die Leute buchen zwar Filme, aber eigentlich sollten sie Vorführungenvon Filmen buchen.
• Rabattbedingungen
  • Ob der Preis reduziert wird
  • Reihenfolgebedingung: Verwendung der Vorführungsnummer, um den Rabatt zu bestimmen
  • Zeitbedingung: Verwendung der Filmstartzeit, um den Rabatt zu bestimmen
• Rabattpolitik
  • Rabattpreise festlegen
  • Rabattpolitik für den Betrag: Rabatt auf den Buchungsbetrag
  • Rabattpolitik für den Prozentsatz: Rabatt auf den regulären Preis
• Es kann eine Rabattpolitik für jeden Film vergeben werden oder überhaupt keine, und die Rabattbedingungen können mehrere Rabattbedingungen kombinieren.
• Wenn eine Rabattpolitik angewendet wird, aber die Rabattbedingungen nicht erfüllt werden oder keine Rabattpolitik angewendet wird, wird der Preis nicht reduziert.

Auf dem Weg zur objektorientierten Programmierung

Zusammenarbeit, Objekte, Klassen

• Objektorientierte Programmierung bedeutet, Objekte zu verwenden.
  • Nachdem man sich für eine Klasse entschieden hat, sollte man nicht überlegen, welche Attribute und Methoden die Klasse benötigt.
  • Man sollte entscheiden, welche Objekte welchen Zustand und welches Verhalten haben.
  • Man sollte Objekte nicht als unabhängige Entitäten betrachten, sondern als Teil einer zusammenarbeitenden Community.

Programmierstruktur, die der Struktur des Domäns folgt

• Der Domän bezieht sich auf den Bereich, in dem der Benutzer das Programm verwendet, um ein Problem zu lösen.

• Im Allgemeinen sollten die Namen von Klassen den Namen der entsprechenden Domänenkonzepte entsprechen oder zumindest ähnlich sein.
• Auch die Beziehungen zwischen den Klassen sollten so weit wie möglich den Beziehungen entsprechen, die zwischen den Domänenkonzepten bestehen, um das Verständnis und die Vorhersagbarkeit der Programmierstruktur zu erleichtern.

Klassen implementieren

• Eine Klasse ist in einen internen und einen externen Bereich unterteilt, und um eine gute Klasse zu entwerfen, muss man entscheiden, welcher Teil für die Öffentlichkeit zugänglich ist und welcher Teil verborgen ist.
  • Die Attribute eines Objekts werden mit private gesperrt, und die notwendigen Methoden zur Änderung des internen Zustands werden mit public freigegeben.
• Die Trennung zwischen dem Inneren und Äußeren der Klasse gewährleistet die Unabhängigkeit des Objekts und bietet dem Programmierer so die Freiheit der Implementierung.

Unabhängige Objekte

• Ein Objekt sollte ein unabhängiges Objekt mit Zustand und Verhalten sein.
• Das Zusammenfassen von Daten und Funktionen innerhalb eines Objekts wird als Kapselung bezeichnet.
• Durch die Zugriffskontrolle können externe Eingriffe reduziert werden, so dass das Objekt seine eigenen Aktionen selbstständig entscheiden kann.
• Das Prinzip der Trennung von Schnittstelle und Implementierung ist ein wichtiges Prinzip, das bei der objektorientierten Programmierung befolgt werden sollte.
  • Öffentliche Schnittstelle: Der Teil, auf den von außen zugegriffen werden kann
  • Implementierung: Der Teil, auf den nur von innen zugegriffen werden kann

Freiheit des Programmierers

• Die Rolle des Programmierers wird in Klassenautoren und Client-Programmierer unterteilt.
  • Klassenautoren fügen neue Datentypen hinzu
  • Client-Programmierer verwenden die von Klassenautoren hinzugefügten Datentypen
• Implementierung verbergen
  • Klassenautoren können dem Client-Programmierer nur die notwendigen Teile zur Verfügung stellen und so die interne Implementierung verbergen.
  • Client-Programmierer müssen nur die Schnittstelle kennen, wodurch sich der Wissensbedarf reduziert.

Eine Community aus zusammenarbeitenden Objekten

• Wenn man Geld darstellen möchte, ist es besser, es nicht einfach als Variable vom Typ Long zu deklarieren, sondern es in ein Objekt wie Money zu verpacken. Die Verwendung von Objekten trägt zu einer besseren Bedeutungserklärung bei und ermöglicht es, redundante Berechnungen an einem Ort durchzuführen.
• Die Interaktion zwischen Objekten zur Implementierung einer bestimmten Funktion des Systems wird als Zusammenarbeit bezeichnet.

Eine kurze Geschichte der Zusammenarbeit

• Die einzige Möglichkeit, wie ein Objekt mit einem anderen Objekt interagieren kann, ist das Senden oder Empfangen von Nachrichten.
• Eine eigene Methode zur Verarbeitung der empfangenen Nachrichten wird als Methode bezeichnet.
• Es ist wichtig, Nachrichten und Methoden zu unterscheiden, da hier das Konzept des Polymorphismus seinen Ursprung hat.

Rabattpreise berechnen

Zusammenarbeit zur Berechnung von Rabattpreisen starten

• Die Klasse Movie enthält keine detaillierte Logik für die Rabattpolitik, sondern delegiert diese an die Schnittstelle DiscountPolicy. Vererbung und Polymorphismus, Abstraktion sind sehr wichtig.

Rabattpolitik und Rabattbedingungen

Vererbung und Polymorphismus

Abhängigkeit zur Kompilierzeit und Abhängigkeit zur Laufzeit

• Die Abhängigkeit des Codes und die Abhängigkeit zum Zeitpunkt der Ausführung können unterschiedlich sein.
• Je unterschiedlicher diese Abhängigkeiten sind, desto schwieriger wird es, den Code zu verstehen, aber umso flexibler und erweiterbarer wird er.

Programmieren durch Unterschiede

• Vererbung ermöglicht es, neue Klassen auf der Grundlage bestehender Klassen einfach und schnell hinzuzufügen, und die Implementierung der Basisklasse kann wiederverwendet werden.
• Die Methode, neue Klassen zu erstellen, indem nur die Unterschiede zur Basisklasse hinzugefügt werden, wird als Programmierung durch Unterschiede bezeichnet.

Vererbung und Schnittstellen

• Durch Vererbung erbt die Unterklasse alle Schnittstellen von der Oberklasse.
• Eine Schnittstelle definiert die Liste der Nachrichten, die ein Objekt verstehen kann.

public class Movie {

    public Money calculateMovieFee(Screening screening) {
        return fee.minus(discountPolicy.calculateDiscountAmount(screening));
    }

• Movie sendet eine Nachricht an DiscountPolicy, um calculateDiscountAmount auszuführen. Für Movie ist es nicht relevant, welche Klasse das Objekt ist, das antwortet, sondern nur, ob es erfolgreich antwortet.
• Daher können sowohl AmountDiscountPolicy als auch PercentDiscountPolicy anstelle von DiscountPolicy mit Movie zusammenarbeiten.
• Wenn eine Unterklasse die Oberklasse ersetzt, spricht man von Upcasting. Dies liegt daran, dass die Unterklasse automatisch als Typ der Oberklasse betrachtet wird, als würde sie nach oben gecastet werden.

Polymorphismus

• Polymorphismus bedeutet die Fähigkeit, bei Empfang der gleichen Nachricht je nach Objekttyp unterschiedlich zu reagieren.
  • Movie sendet die gleiche Nachricht, aber welche Methode tatsächlich ausgeführt wird, hängt davon ab, welche Klasse das Objekt hat, das die Nachricht empfängt.
• Polymorphismus basiert auf der Tatsache, dass die Abhängigkeit des Programms zur Kompilierzeit und zur Laufzeit unterschiedlich sein kann.
• Da Polymorphismus die Methode zur Ausführung zur Laufzeit bestimmt, wird es auch als verzögertes Binden oder dynamisches Binden bezeichnet.

Schnittstellen und Polymorphismus

• Wenn die Implementierung nicht gemeinsam genutzt werden muss und nur die Schnittstelle gemeinsam genutzt werden soll, kann man anstelle einer abstrakten Klasse eine Schnittstelle verwenden.

Abstraktion und Flexibilität

Die Kraft der Abstraktion

• Die Vorteile der Abstraktion
  • Wenn man nur die Abstraktionsebene betrachtet, kann man die Richtlinien der Anforderungen auf einer höheren Ebene beschreiben.
  • Das Design wird flexibler.

Flexibles Design

• Abstraktion verhindert, dass das Design an eine bestimmte Situation gebunden wird, und ermöglicht so ein flexibles Design.

Abstrakte Klassen und Schnittstellen: Abwägung

public abstract class DiscountPolicy {

    private List conditions;

    public DiscountPolicy(DiscountCondition... conditions) {
        this.conditions = Arrays.asList(conditions);
    }

    public Money calculateDiscountAmount(Screening screening) {
        for (DiscountCondition condition : conditions) {
            if (condition.isSatisfiedBy(screening)) {
                return getDiscountAmount(screening);
            }
        }
        return Money.ZERO;
    }

    abstract protected Money getDiscountAmount(Screening screening);
}

public class NoneDiscountPolicy extends DiscountPolicy {

    @Override
    protected Money getDiscountAmount(Screening screening) {
        return Money.ZERO;
    }

• Aktuell gibt es eigentlich keine Notwendigkeit für NoneDiscountPolicy, da die Methode calculateDiscountAmount() von DiscountPolicy bereits 0 zurückgibt, wenn keine Rabattbedingungen vorhanden sind. Dennoch wurde sie aus Benutzerperspektive hinzugefügt, da sie Movie als Argument eine None-Politik ohne Rabattpolitik übergeben müssen.
• Daher ist die Klasse NoneDiscountPolicy konzeptionell verwirrend und sollte zur besseren Lesbarkeit wie folgt geändert werden.

public interface DiscountPolicy {

    Money calculdateDiscountAmount(Screening screening);
}

public abstract class DefaultDiscountPolicy implements DiscountPolicy {

    private List conditions;

    public DefaultDiscountPolicy(DiscountCondition... conditions) {
        this.conditions = Arrays.asList(conditions);
    }

    public Money calculateDiscountAmount(Screening screening) {
        for (DiscountCondition condition : conditions) {
            if (condition.isSatisfiedBy(screening)) {
                return getDiscountAmount(screening);
            }
        }
        return Money.ZERO;
    }

    abstract protected Money getDiscountAmount(Screening screening);
}

public class NoneDiscountPolicy implements DiscountPolicy {

    @Override
    public Money calculateDiscountAmount(Screening screening) {
        return Money.ZERO;
    }
}

public class PercentDiscountPolicy extends DefaultDiscountPolicy {

    private double percent;

    public PercentDiscountPolicy(double percent, DiscountCondition... conditions) {
        super(conditions);
        this.percent = percent;
    }

    @Override
    protected Money getDiscountAmount(Screening screening) {
        return screening.getMovieFee().times(percent);
    }
}

public class AmountDiscountPolicy extends DefaultDiscountPolicy {

    private Money discountAmount;

    public AmountDiscountPolicy(Money discountAmount, DiscountCondition... conditions) {
        super(conditions);
        this.discountAmount = discountAmount;
    }

    @Override
    protected Money getDiscountAmount(Screening screening) {
        return discountAmount;
    }

• DiscountPolicy wird als Schnittstelle abstrahiert, und ihre Implementierungen werden in NoneDiscountPolicy und DefaultDiscountPolicy unterteilt, die eine allgemeine Rabattpolitik darstellen.

• Man könnte denken, dass das Hinzufügen einer Schnittstelle nur für NoneDiscountPolicy eine höhere Komplexität mit sich bringt, die nicht effizient ist.
• Man sollte sich bewusst sein, dass alle Dinge, die mit der Implementierung zusammenhängen, Gegenstand von Abwägungen sind. Das bedeutet, dass jeder Code, den man schreibt, einen triftigen Grund haben muss.

Code-Wiederverwendung

• Vererbung kann zur Wiederverwendung von Code verwendet werden.
• Bei der Code-Wiederverwendung ist es jedoch besser, Komposition anstelle von Vererbung zu verwenden.
• Die aktuelle Methode, mit der Movie den Code von DiscountPolicy wiederverwendet, ist Komposition.
• Würde man Movie als Oberklasse betrachten und diese in AmountDiscountMovie und PercentDiscountMovie aufteilen, wäre dies eine Vererbung.

Vererbung

• Nachteile der Vererbung
  • Verletzt die Kapselung.
    • Man muss die interne Struktur der Basisklasse kennen.
    • Die Wahrscheinlichkeit, dass die Unterklasse bei einer Änderung der Basisklasse geändert werden muss, ist hoch.
  • Macht das Design weniger flexibel.
    • Die Beziehung zwischen Oberklasse und Unterklasse wird zur Kompilierzeit festgelegt.
    • Es ist nicht möglich, den Typ des Objekts zur Laufzeit zu ändern.
    • Bei der Komposition kann man jedoch zur Laufzeit eine Instanz durch eine Methode wie chageDiscountPolicy() austauschen.

Komposition

• Die Methode, Code über Nachrichten zu wiederverwenden, die in der Schnittstelle definiert sind, wird als Komposition bezeichnet.
• Sie ermöglicht es, die Kapselung zu implementieren und eine lose Kopplung zu erhalten.
• Wenn man Schnittstellen für Polymorphismus wiederverwendet, sollte man Vererbung und Komposition kombinieren.
  • Beispielsweise muss die Schnittstelle DiscountPolicy Vererbung verwenden, um Unterimplementierungen zu implementieren.

Quellen

• Objekte