Das Composite-Muster bedeutet, andere Objekte in ein Objekt aufzunehmen. Diese aufgenommenen Objekte können Endobjekte sein (die keine weiteren Objekte mehr enthalten) oder Nicht-Endobjekte (deren Inneres noch andere Objekte enthält, oder sie werden Gruppenobjekte genannt). Wir nennen die Objekte Knoten, das heißt, ein Wurzelknoten enthält viele Kindknoten; einige dieser Kindknoten enthalten keine Kindknoten mehr, während andere noch Kindknoten enthalten, und so weiter. Offensichtlich ist dies eine Baumstruktur. Die Endknoten werden Blattknoten genannt, die Nicht-Endknoten (Gruppenknoten) werden Zweigknoten genannt, und der erste Knoten wird Wurzelknoten genannt. Es ähnelt auch der Struktur eines Dateiverzeichnisses: Dateien können Endknoten genannt werden, und Verzeichnisse können Nicht-Endknoten (Gruppenknoten) genannt werden.


Gewöhnliche Implementierung

1. Schauen wir uns zunächst eine gewöhnliche Implementierung einer Verzeichnisstruktur an:

Verzeichnisknoten: Noder

import java.util.ArrayList; import java.util.List; /** * Verzeichnisknoten * Enthält: * 1. Verzeichnisname * 2. Liste der untergeordneten Dateien * 3. Liste der untergeordneten Verzeichnisse * 4. Methode zum Hinzufügen einer Datei * 5. Methode zum Hinzufügen eines Verzeichnisses * 6. Methode zum Anzeigen untergeordneter Inhalte*/ public class Noder { String nodeName;//Verzeichnisname //Das Verzeichnis über den Konstruktor benennen public Noder(String nodeName){ this.nodeName = nodeName; } List<Noder> nodeList = new ArrayList<Noder>();//Die Liste der untergeordneten Verzeichnisse des Verzeichnisses List<Filer> fileList = new ArrayList<Filer>();//Die Liste der untergeordneten Dateien des Verzeichnisses //Ein untergeordnetes Verzeichnis hinzufügen public void addNoder(Noder noder){ nodeList.add(noder); } //Eine Datei hinzufügen public void addFiler(Filer filer){ fileList.add(filer); } //Untergeordnete Verzeichnisse und Dateien anzeigen public void display(){ for(Noder noder:nodeList){ System.out.println(noder.nodeName); noder.display();//Die Verzeichnisliste rekursiv anzeigen } for(Filer filer:fileList){ filer.display(); } } }

Dateiknoten: Filer

/** * Dateiknoten * Der Dateiknoten ist ein Endknoten und hat keine untergeordneten Knoten * Enthält: * 1. Dateiname * 2. Dateianzeigemethode*/ public class Filer { String fileName;//Dateiname public Filer(String fileName){ this.fileName = fileName; } //Dateianzeigemethode public void display(){ System.out.println(fileName); } }

Testklasse: Clienter

import java.io.File; public class Clienter { public static void createTree(Noder node){ File file = new File(node.nodeName); File[] f = file.listFiles(); for(File fi : f){ if(fi.isFile()){ Filer filer = new Filer(fi.getAbsolutePath()); node.addFiler(filer); } if(fi.isDirectory()){ Noder noder = new Noder(fi.getAbsolutePath()); node.addNoder(noder); createTree(noder);//Rekursion verwenden, um die Baumstruktur zu erzeugen } } } public static void main(String[] args) { Noder noder = new Noder("E://ceshi"); createTree(noder);//Eine Verzeichnisbaumstruktur erstellen noder.display();//Verzeichnisse und Dateien anzeigen } }

Ausführungsergebnis:

E:\ceshi\目录1
E:\ceshi\目录1\目录3
E:\ceshi\目录1\文件2.txt
E:\ceshi\目录2
E:\ceshi\目录2\文件3.txt
E:\ceshi\文件1.txt

2. Kompositionsmuster

Aus dem obigen Code ist ersichtlich, dass wir das Dateiknotenobjekt und das Verzeichnisknotenobjekt getrennt definiert haben. Dies liegt daran, dass die Operationen zwischen Dateien und Verzeichnissen unterschiedlich sind: Dateien haben keine untergeordneten Knoten, während Verzeichnisse untergeordnete Knoten haben können. Aber können wir es so betrachten: Da sowohl Dateien als auch Verzeichnisse als untergeordnete Knoten eines Knotens existieren können, können wir beide zu einem Objekttyp abstrahieren? Obwohl die Operationen der beiden unterschiedlich sind, können wir sie konkret in den Methodenimplementierungen der Implementierungsklassen definieren. Zum Beispiel hat eine Datei keine Methode zum Hinzufügen eines untergeordneten Knotens, daher können wir in dieser Methode der Datei eine Ausnahme auslösen, ohne sie konkret zu implementieren, während wir im Verzeichnis die Hinzufügeoperation konkret implementieren. Beide haben die Anzeigeoperation, und sie können sie separat implementieren. Da wir Dateien und Verzeichnisse außerdem zu einem Typ abstrahieren, können wir es in Kombination mit Polymorphismus wie folgt implementieren:

Abstrakte Klasse: Node

/** * Behandle Dateien und Verzeichnisse einheitlich als einen Knotentyp, erstelle eine abstrakte Klasse, um diesen Knoten zu definieren, und verwende dann ihre Implementierungsklassen, um Dateien von Verzeichnissen zu unterscheiden, wobei ihre jeweiligen konkreten Implementierungsinhalte in den Implementierungsklassen definiert werden.*/ public abstract class Node { protected String name;//Name //Namen über Konstruktor zuweisen public Node(String name){ this.name = name; } //Knoten hinzufügen: Der Dateiknoten hat diese Methode nicht, der Verzeichnisknoten überschreibt diese Methode public void addNode(Node node) throws Exception{ throw new Exception("Ungültige Ausnahme"); } //Knoten anzeigen: Sowohl Datei als auch Verzeichnis implementieren diese Methode abstract void display(); }

Datei-Implementierungsklasse: Filter

/** * Dateiknoten implementieren*/ public class Filer extends Node { //Benenne den Dateiknoten über den Konstruktor public Filer(String name) { super(name); } //Dateiknoten anzeigen @Override public void display() { System.out.println(name); } }

Verzeichnis-Implementierungsklasse: Noder

import java.util.*; /** * Verzeichnisknoten implementieren*/ public class Noder extends Node { List<Node> nodeList = new ArrayList<Node>();//Interne Knotenliste (einschließlich Dateien und Unterverzeichnisse) //Weisen Sie dem aktuellen Verzeichnisknoten über den Konstruktor einen Namen zu public Noder(String name) { super(name); } //Knoten hinzufügen public void addNode(Node node) throws Exception{ nodeList.add(node); } //Rekursiv durchlaufen, um untergeordnete Knoten anzuzeigen @Override void display() { System.out.println(name); for(Node node:nodeList){ node.display(); } } }

Testklasse: Clienter

import java.io.File; public class Clienter { public static void createTree(Node node) throws Exception{ File file = new File(node.name); File[] f = file.listFiles(); for(File fi : f){ if(fi.isFile()){ Filer filer = new Filer(fi.getAbsolutePath()); node.addNode(filer); } if(fi.isDirectory()){ Noder noder = new Noder(fi.getAbsolutePath()); node.addNode(noder); createTree(noder);//Rekursion verwenden, um die Baumstruktur zu erzeugen } } } public static void main(String[] args) { Node noder = new Noder("E://ceshi"); try { createTree(noder); } catch (Exception e) { e.printStackTrace(); } noder.display(); } }

Ergebnis der Ausführung:

E://ceshi
E:\ceshi\文件1.txt
E:\ceshi\目录1
E:\ceshi\目录1\文件2.txt
E:\ceshi\目录1\目录3
E:\ceshi\目录2
E:\ceshi\目录2\文件3.txt

Anhand der obigen Implementierung ist zu erkennen, dass das sogenannte Composite-Muster eigentlich das Problem von Objekten, die Objekte enthalten, bezeichnet. Es wird durch Komposition aufgebaut (Referenzieren von Objekten innerhalb von Objekten). Ich denke, diese Komposition unterscheidet sich von Vererbung. Eine weitere Bedeutung bezieht sich auf die Abstraktion von Kindknoten in einer Baumstruktur (Blattknoten und Verzweigungsknoten als Kindknoten zu abstrahieren), was sich von der üblichen Art unterscheidet, Blattknoten und Verzweigungsknoten getrennt zu definieren.


3. Anwendungsszenarien für das Composite-Muster

Dieses Kompositum-Muster wurde genau für Baumstrukturen entwickelt, daher ist das Anwendungsszenario des Kompositum-Musters überall dort, wo Baumstrukturen auftreten. Zum Beispiel Operationen auf baumstrukturierten Daten wie Dateiverzeichnisanzeige, mehrstufige Verzeichnisdarstellung und so weiter.

Originaladresse: https://www.cnblogs.com/V1haoge/p/6489827.html