Le patron composite signifie inclure d'autres objets dans un objet. Ces objets inclus peuvent être des objets terminaux (ne contenant plus d'autres objets), ou bien des objets non terminaux (leur intérieur contient encore d'autres objets, ou on les appelle objets groupe). Nous appelons les objets des nœuds, c'est-à-dire qu'un nœud racine contient de nombreux nœuds enfants ; certains de ces nœuds enfants ne contiennent plus de nœuds enfants, tandis que d'autres contiennent encore des nœuds enfants, et ainsi de suite. De toute évidence, il s'agit d'une structure arborescente. Les nœuds terminaux sont appelés nœuds feuilles, les nœuds non terminaux (nœuds groupe) sont appelés nœuds branches, et le premier nœud est appelé nœud racine. Cela ressemble également à la forme structurelle d'un répertoire de fichiers : les fichiers peuvent être appelés nœuds terminaux, et les répertoires peuvent être appelés nœuds non terminaux (nœuds groupe).


Implémentation ordinaire

1. Examinons d'abord une implémentation ordinaire d'une structure de répertoire :

Nœud de répertoire : Noder

import java.util.ArrayList; import java.util.List; /** * Nœud de répertoire * Contient : * 1. Nom du répertoire * 2. Liste des fichiers de niveau inférieur * 3. Liste des répertoires de niveau inférieur * 4. Méthode pour ajouter un fichier * 5. Méthode pour ajouter un répertoire * 6. Méthode pour afficher le contenu de niveau inférieur*/ public class Noder { String nodeName;//Nom du répertoire //Nommer le répertoire via le constructeur public Noder(String nodeName){ this.nodeName = nodeName; } List<Noder> nodeList = new ArrayList<Noder>();//La liste des répertoires de niveau inférieur du répertoire List<Filer> fileList = new ArrayList<Filer>();//La liste des fichiers de niveau inférieur du répertoire //Ajouter un répertoire de niveau inférieur public void addNoder(Noder noder){ nodeList.add(noder); } //Ajouter un fichier public void addFiler(Filer filer){ fileList.add(filer); } //Afficher les répertoires et fichiers de niveau inférieur public void display(){ for(Noder noder:nodeList){ System.out.println(noder.nodeName); noder.display();//Afficher récursivement la liste des répertoires } for(Filer filer:fileList){ filer.display(); } } }

Nœud de fichier : Filer

/** * Nœud de fichier * Le nœud de fichier est un nœud terminal et n'a pas de nœuds de niveau inférieur * Contient : * 1. Nom du fichier * 2. Méthode d'affichage du fichier*/ public class Filer { String fileName;//Nom du fichier public Filer(String fileName){ this.fileName = fileName; } //Méthode d'affichage du fichier public void display(){ System.out.println(fileName); } }

Classe de test : 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);//Utiliser la récursion pour générer l'arborescence } } } public static void main(String[] args) { Noder noder = new Noder("E://ceshi"); createTree(noder);//Créer une structure d'arborescence de répertoires noder.display();//Afficher les répertoires et les fichiers } }

Résultat de l'exécution:

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. Patron composite

D'après le code ci-dessus, on peut voir que nous avons défini séparément l'objet nœud de fichier et l'objet nœud de répertoire. C'est parce que les opérations entre les fichiers et les répertoires sont différentes : les fichiers n'ont pas de nœuds de niveau inférieur, tandis que les répertoires peuvent avoir des nœuds de niveau inférieur. Mais pouvons-nous voir les choses ainsi : puisque les fichiers et les répertoires peuvent tous deux exister comme nœuds de niveau inférieur d'un nœud, pouvons-nous les abstraire tous les deux en un seul type d'objet ? Bien que les opérations des deux soient différentes, nous pouvons les définir concrètement dans les implémentations de méthodes des classes d'implémentation. Par exemple, un fichier n'a pas de méthode pour ajouter un nœud de niveau inférieur, donc nous pouvons lever une exception dans cette méthode du fichier sans l'implémenter concrètement, tandis que dans le répertoire nous implémentons concrètement l'opération d'ajout. Les deux ont l'opération d'affichage, et ils peuvent l'implémenter séparément. De plus, puisque nous abstraions les fichiers et les répertoires en un seul type, combiné avec le polymorphisme, nous pouvons l'implémenter comme suit :

Classe abstraite : Node

/** * Traiter les fichiers et les répertoires uniformément comme un seul type de nœud, créer une classe abstraite pour définir ce nœud, puis utiliser ses classes d'implémentation pour distinguer les fichiers des répertoires, en définissant leurs contenus d'implémentation concrets respectifs dans les classes d'implémentation.*/ public abstract class Node { protected String name;//Nom //Attribuer le nom via le constructeur public Node(String name){ this.name = name; } //Ajouter un nœud : le nœud de fichier n'a pas cette méthode, le nœud de répertoire redéfinit cette méthode public void addNode(Node node) throws Exception{ throw new Exception("Exception invalide"); } //Afficher le nœud : le fichier et le répertoire implémentent tous deux cette méthode abstract void display(); }

Classe d'implémentation de fichier : Filter

/** * Implémenter le nœud de fichier*/ public class Filer extends Node { //Nommer le nœud de fichier via le constructeur public Filer(String name) { super(name); } //Afficher le nœud de fichier @Override public void display() { System.out.println(name); } }

Classe d'implémentation de répertoire : Noder

import java.util.*; /** * Implémenter le nœud de répertoire*/ public class Noder extends Node { List<Node> nodeList = new ArrayList<Node>();//Liste des nœuds internes (y compris les fichiers et les sous-répertoires) //Attribuer un nom au nœud du répertoire courant via le constructeur public Noder(String name) { super(name); } //Ajouter un nœud public void addNode(Node node) throws Exception{ nodeList.add(node); } //Boucler récursivement pour afficher les nœuds de niveau inférieur @Override void display() { System.out.println(name); for(Node node:nodeList){ node.display(); } } }

Classe de test : 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);//Utiliser la récursion pour générer l'arborescence } } } public static void main(String[] args) { Node noder = new Noder("E://ceshi"); try { createTree(noder); } catch (Exception e) { e.printStackTrace(); } noder.display(); } }

Résultat de sortie d'exécution :

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

À partir de l'implémentation ci-dessus, on peut constater que ce que l'on appelle le modèle composite fait en réalité référence au problème des objets contenant des objets. Il est agencé par composition (en référençant des objets à l'intérieur d'objets). Je pense que cette composition est différente de l'héritage. Une autre signification renvoie à l'abstraction des nœuds enfants dans une structure arborescente (en abstrayant les nœuds feuilles et les nœuds de branche en tant que nœuds enfants), ce qui diffère de la manière habituelle de définir séparément les nœuds feuilles et les nœuds de branche.


3. Scénarios d'application du modèle Composite

Ce patron composite est né précisément pour les structures arborescentes, donc le scénario d'utilisation du patron composite est partout où des structures arborescentes apparaissent. Par exemple, les opérations sur des données structurées en arbre telles que l'affichage de répertoires de fichiers, la présentation de répertoires à plusieurs niveaux, etc.

Adresse d'origine : https://www.cnblogs.com/V1haoge/p/6489827.html