Kompositmuster

Das Kompositmuster, auch als Teil-Ganzes-Muster bezeichnet, wird verwendet, um eine Gruppe ähnlicher Objekte als ein einzelnes Objekt zu behandeln. Das Kompositmuster kombiniert Objekte gemäß einer Baumstruktur, um Teil-Ganzes-Hierarchien darzustellen. Diese Art von Entwurfsmuster ist ein Strukturmuster; es erstellt eine Baumstruktur aus Objektgruppen.

Dieses Muster erstellt eine Klasse, die eine Gruppe ihrer eigenen Objekte enthält. Die Klasse bietet eine Möglichkeit, dieselbe Gruppe von Objekten zu ändern.

Wir verwenden das folgende Beispiel, um die Verwendung des Kompositmusters zu demonstrieren. Das Beispiel veranschaulicht die hierarchische Struktur von Mitarbeitern in einer Organisation.

Einführung

Absicht

Kombinieren Sie Objekte zu Baumstrukturen, um "Teil-Ganzes"-Hierarchien darzustellen. Das Kompositmuster macht die Verwendung einzelner Objekte und zusammengesetzter Objekte für Benutzer konsistent.

Wesentliche gelöste Probleme

  • Vereinfachen Sie den Umgang mit Objekten in einer Baumstruktur, unabhängig davon, ob es sich um einzelne Objekte oder zusammengesetzte Objekte handelt.
  • Entkoppeln Sie den Client-Code von der internen Struktur komplexer Elemente, damit Clients alle Arten von Knoten einheitlich behandeln können.

Anwendungsfall

  • Wenn hierarchische Strukturen von Objekten dargestellt werden müssen, wie Dateisysteme oder Organisationsstrukturen.
  • Wenn Sie möchten, dass Client-Code alle Objekte in einer Baumstruktur auf konsistente Weise behandelt.

Implementierungsansatz

  • Einheitliche SchnittstelleDefinieren Sie eine Schnittstelle, die alle Objekte (Zweige und Blätter) implementieren.
  • KompositstrukturVerzweigungsobjekte enthalten eine Liste von Referenzen auf die Schnittstelle; diese Referenzen können Blätter oder Verzweigungen sein.

Schlüsselcode

  • KomponentenschnittstelleDefiniert die Operationen, die alle Objekte implementieren müssen.
  • BlattklasseImplementiert die Komponentenschnittstelle und repräsentiert Blattknoten im Baum.
  • Composite-KlasseImplementiert ebenfalls die Komponentenschnittstelle und enthält eine Sammlung anderer Komponentenobjekte.

Anwendungsbeispiel

  1. Arithmetischer AusdruckErstellt eine Baumstruktur aus Operanden, Operatoren und Teilausdrücken.
  2. GUI-KomponentenIn den Java-Bibliotheken AWT und Swing können Container (z. B. Panel) andere Komponenten (z. B. Schaltflächen und Kontrollkästchen) enthalten.

Vorteile

  1. Client-Code vereinfachenClients können alle Knotentypen einheitlich behandeln.
  2. Leicht erweiterbarNeue Blatttypen oder Verzweigungstypen können leicht hinzugefügt werden.

Nachteile

  • Verletzung des Dependency-Inversion-PrinzipsKomponentendeklarationen basieren auf konkreten Klassen statt auf Schnittstellen, was die Flexibilität des Codes verringern kann.

Verwendungshinweise

  • Bevorzugen Sie beim Entwerfen Schnittstellen gegenüber konkreten Klassen, um die Flexibilität und Wartbarkeit des Systems zu verbessern.
  • Geeignet für Szenarien, die komplexe Baumstrukturen verarbeiten müssen, wie Dateisysteme, Organisationsstrukturen usw.

Hinweise

  • Achten Sie bei der Implementierung darauf, dass alle Komponenten einer einheitlichen Schnittstelle folgen, um Konsistenz zu wahren.
  • Erwägen Sie, das Factory Pattern zu verwenden, um verschiedene Arten von Komponenten zu erstellen, um die Komponentenerstellungslogik weiter zu entkoppeln.

Struktur

Die Kernrollen des Composite-Musters umfassen:

  • Komponente:

    • Definiert eine gemeinsame Schnittstelle für alle Objekte in der Komposition, die eine abstrakte Klasse oder eine Schnittstelle sein kann. Sie deklariert Methoden für den Zugriff auf und die Verwaltung von untergeordneten Komponenten, einschließlich Hinzufügen, Löschen und Abrufen von untergeordneten Komponenten usw.

  • Blattknoten (Leaf):

    • Repräsentiert Blattknotenobjekte in der Komposition; Blattknoten haben keine Kinder. Sie implementieren die Methoden der Component-Schnittstelle, enthalten aber im Allgemeinen keine untergeordneten Komponenten.

  • Kompositknoten (Composite):

    • Repräsentiert Composite-Objekte in der Komposition. Kompositknoten können Kindknoten enthalten, bei denen es sich um Blattknoten oder andere Kompositknoten handeln kann. Er implementiert die Methoden der Component-Schnittstelle, einschließlich Methoden zur Verwaltung untergeordneter Komponenten.

  • Client:

    • Interagiert über die Component-Schnittstelle mit der Composite-Struktur. Clients müssen nicht zwischen Blattknoten und Kompositknoten unterscheiden und können Ganze und Teile einheitlich behandeln.

Implementierung

Wir haben eine KlasseEmployee, diese Klasse wird als Composite-Modellklasse behandelt.CompositePatternDemoKlassenverwendungEmployeeKlasse zum Hinzufügen der Abteilungshierarchie und zum Ausgeben aller Mitarbeiter.

组合模式的 UML 图

Schritt 1

Erstellen Sie die KlasseEmployee, die eine Liste vonEmployeeObjekten enthält.

Employee.java

import java.util.ArrayList; import java.util.List; public class Employee { private String name; private String dept; private int salary; private List<Employee> subordinates; //Konstruktor public Employee(String name,String dept, int sal) { this.name = name; this.dept = dept; this.salary = sal; subordinates = new ArrayList<Employee>(); } public void add(Employee e) { subordinates.add(e); } public void remove(Employee e) { subordinates.remove(e); } public List<Employee> getSubordinates(){ return subordinates; } public String toString(){ return ("Employee :[ Name : "+ name +", dept : "+ dept + ", salary :" + salary+" ]"); } }

Schritt 2

VerwendungEmployeeKlasse zum Erstellen und Ausgeben der Mitarbeiterhierarchie.

CompositePatternDemo.java

public class CompositePatternDemo { public static void main(String[] args) { Employee CEO = new Employee("John","CEO", 30000); Employee headSales = new Employee("Robert","Vertriebsleiter", 20000); Employee head = new Employee("Michel","Marketingleiter", 20000); Employee clerk1 = new Employee("Laura","Marketing", 10000); Employee clerk2 = new Employee("Bob","Marketing", 10000); Employee salesExecutive1 = new Employee("Richard","Sales", 10000); Employee salesExecutive2 = new Employee("Rob","Sales", 10000); CEO.add(headSales); CEO.add(headMarketing); headSales.add(salesExecutive1); headSales.add(salesExecutive2); headMarketing.add(clerk1); headMarketing.add(clerk2); //Alle Mitarbeiter der Organisation ausgeben System.out.println(CEO); for (Employee headEmployee : CEO.getSubordinates()) { System.out.println(headEmployee); for (Employee employee : headEmployee.getSubordinates()) { System.out.println(employee); } } } }

Schritt 3

Führen Sie das Programm aus, die Ausgabe ist:

Employee :[ Name : John, dept : CEO, salary :30000 ]
Employee :[ Name : Robert, dept : Head Sales, salary :20000 ]
Employee :[ Name : Richard, dept : Sales, salary :10000 ]
Employee :[ Name : Rob, dept : Sales, salary :10000 ]
Employee :[ Name : Michel, dept : Head Marketing, salary :20000 ]
Employee :[ Name : Laura, dept : Marketing, salary :10000 ]
Employee :[ Name : Bob, dept : Marketing, salary :10000 ]
Weitere Erweiterungen