modèle de conception de combinaison java

En Java, le modèle de conception composite (Composite Design Pattern) est utilisé pour combiner des objets dans une structure arborescente, de sorte que les objets individuels et les objets composites soient cohérents pour le client. Le modèle composite est un modèle de conception structurel qui simplifie le code client en rendant inutile pour le client de faire la distinction entre les objets individuels et les objets composites.

Le mode composite contient les rôles principaux suivants :

1. Composant : un objet dans une composition qui déclare une interface et, le cas échéant, implémente le comportement par défaut de l'interface commune à toutes les classes. Déclarez une interface pour accéder et gérer les composants enfants.

2. Feuille : dans la combinaison, il représente l'objet nœud feuille et le nœud feuille n'a pas de nœud enfant.

3. Composite : Définissez le comportement de ces composants avec des sous-composants, stockez les sous-composants et implémentez les opérations liées aux sous-composants dans l'interface Component.

Voici un exemple simple :

Tout d'abord, nous créons une interface de composant (Component):

public interface Component {     void operation(); } Ensuite, nous créons une classe feuille (Leaf) pour implémenter l'interface du composant :

public class Leaf implémente Component {     private String name;

    public Leaf(String name) {         this.name = name;     }

    @Override
    public void operation() {         System.out.println("Leaf " + name + " fait quelque chose."); }     } Ensuite , nous créons une classe composite (Composite), implémentons l'interface du composant et y stockons Sous-composants et opérations de mise en œuvre liées aux sous-composants :

importer java.util.ArrayList ;
importer java.util.List ;

public class Composite implémente Component {     private String name;     enfants privés List<Composant> ;

    public Composite(String name) {         this.name = name;         enfants = new ArrayList<>();     }

    @Override
    public void operation() {         System.out.println("Composite " + name + " fait quelque chose.");         for (Component child : children) {             child.operation();         }     }

    public void addComponent(Composant composant) {         children.add(composant);     }

    public void removeComponent(Component component) {         children.remove(component);     } } Maintenant, nous pouvons utiliser le modèle Composite pour composer des objets. Commencez par créer un objet feuille et un objet composite, puis ajoutez l'objet feuille à l'objet composite, et enfin appelez l'opération de l'objet composite en appelant la méthode de l'objet composite :



operation()

public class Main {     public static void main(String[] args) {         Leaf leaf1 = new Leaf("Leaf 1");         Feuille feuille2 = new Feuille("Feuille 2");

        Composite composite1 = new Composite("Composite 1");
        composite1.addComponent(feuille1);
        composite1.addComponent(feuille2);

        Feuille feuille3 = new Feuille("Feuille 3");
        Composite composite2 = new Composite("Composite 2");
        composite2.addComponent(feuille3);
        composite2.addComponent(composite1);

        composite2.operation();
    }
}
résultat de sortie :

Composite Composite 2 fait quelque chose.
Leaf Leaf 3 fait quelque chose.
Composite Composite 1 fait quelque chose.
Leaf Leaf 1 fait quelque chose.
Leaf Leaf 2 fait quelque chose.
Cet exemple montre comment le modèle composite est implémenté. En créant des interfaces de composants, des classes feuille et des classes composites, et en stockant des sous-composants dans la classe composite, une structure composite arborescente peut être créée, et le client peut appeler de manière récursive la méthode d'opération de l'objet composite sans connaître sa structure spécifique, simplifiant ainsi le code de fin client.