Le vieux moine raconte l'histoire au jeune moine, ce qui a déclenché le modèle de conception Java: modèle de combinaison

Exemple

Il existe un système de dessin qui permet de dessiner divers graphiques. Supposons que vous puissiez maintenant dessiner des lignes, des rectangles et des cercles.
Définissez une classe abstraite. Tous les graphiques héritent de cette classe pour terminer le dessin:

public abstract class Graphics {
    
    

    /** 绘图 */
    public abstract void draw();
}

Ligne, rectangle et cercle implémentent les classes abstraites ci-dessus:

public class Line extends Graphics {
    
    
    @Override
    public void draw() {
    
    
        System.out.println("画一条线");
    }
}

public class Rect extends Graphics {
    
    
    @Override
    public void draw() {
    
    
        System.out.println("画一个矩形");
    }
}

public class Circle extends Graphics {
    
    
    @Override
    public void draw() {
    
    
        System.out.println("画一个圆形");
    }
}

Vous devez maintenant ajouter les différents graphiques ci-dessus à la planche à dessin, puis dessiner:

public class Picture extends Graphics {
    
    

    private List<Graphics> list = new ArrayList<>();

    @Override
    public void draw() {
    
    
        for (Graphics g : list) {
    
    
            g.draw();
        }
    }

    /** 添加一个图形 */
    public void add(Graphics graphics) {
    
    
        list.add(graphics);
    }

    /** 移除一个图形 */
    public void remove(Graphics graphics) {
    
    
        list.remove(graphics);
    }

    /** 获取一个图形 */
    public Graphics getChild(int i) {
    
    
        return list.get(i);
    }
}

Catégorie de test:

public class Test {
    
    
    public static void main(String[] args) {
    
    
        Picture picture = new Picture();
        picture.add(new Line());
        picture.add(new Rect());
        picture.add(new Circle());
        picture.draw();
    }
}

Mode combiné

définition

Le mode combiné est également appelé mode partie-tout. Le mode composite organise les objets dans une structure arborescente et peut être utilisé pour décrire la relation entre le tout et la pièce. Le mode composite permet au client de traiter les éléments simples et les éléments composites de la même manière .

intention

Combinez des objets dans une structure arborescente pour représenter une structure hiérarchique "en partie entière". Le mode de combinaison permet aux utilisateurs d'utiliser un seul objet et des objets combinés de manière cohérente

Résoudre principalement le problème

Le programme client peut gérer des éléments complexes comme des éléments simples, découplant ainsi le programme client de la structure interne d'éléments complexes

Avantages et inconvénients

avantage:

• Appel simple de modules de haut niveau
• Les nœuds peuvent être ajoutés librement

Inconvénients:
lors de l'utilisation du mode combiné, les déclarations de ses feuilles et branches sont des classes d'implémentation, pas des interfaces, ce qui viole le principe d'inversion des dépendances

Mode de combinaison sûr et transparent

La figure suivante omet les détails de chaque rôle et ne donne pas

les rôles impliqués dans chacune de leurs méthodes :

• Rôle de construction abstraite (composant): il spécifie une interface pour les objets participant à la composition, et ce rôle donne une interface commune et un comportement par défaut
• Rôle feuille: représente l'objet feuille participant à la combinaison, une feuille n'a pas de sous-objets de subordonnés et définit le comportement de l'objet original participant à la combinaison
• Rôle de construction de branche (composite): Représente les objets avec des sous-objets participant à la combinaison et donne le comportement de la construction d'objet de branche

L'objet composite peut contenir d'autres objets de type Component, c'est-à-dire qu'il peut contenir d'autres objets de branche et objets feuille

La structure du mode synthétique sûr

Les méthodes requises pour gérer l'agrégation n'apparaissent que dans la classe de construction de branche, pas dans la classe de construction feuille, c'est-à-dire que la méthode de gestion des objets de sous-classe est déclarée dans la classe composite.

Les rôles concernés:

• Rôle de construction abstraite (composant): il spécifie une interface pour les objets participant à la composition. Ce rôle donne une interface commune et un comportement par défaut, qui peut être utilisé pour gérer tous les sous-objets. En mode de composition sécurisée, le rôle de construction est non Définir la méthode de gestion des sous-objets, cette définition est donnée par la construction de la branche
• Rôle feuille: représente l'objet feuille participant à la combinaison, une feuille n'a pas de sous-objets de subordonnés et définit le comportement de l'objet original participant à la combinaison
• Rôle de construction de branche (composite): Représente les objets qui ont des sous-objets participant à la combinaison, et donne le comportement de la construction d'objet de branche. Il donnera toutes les méthodes de gestion des sous-objets, telles que l'ajout, la suppression, etc.

Le code source correspondant est le suivant:

public interface Component {
    
    

    /** 返还自己的实例 */
    Composite getComposite();

    /** 某个商业方法 */
    void sampleOperation();
}

public class Composite implements Component {
    
    

    private List<Component> compositeList = new ArrayList<>();

    @Override
    public Composite getComposite() {
    
    
        return this;
    }

    @Override
    public void sampleOperation() {
    
    
        compositeList.forEach(v -> {
    
    
            v.sampleOperation();
        });
    }

    public void add(Component component) {
    
    
        compositeList.add(component);
    }

    public void remove(Component component) {
    
    
        compositeList.remove(component);
    }

    public List<Component> components() {
    
    
        return compositeList;
    }
}

public class Leaf implements Component {
    
    
    @Override
    public Composite getComposite() {
    
    
        return null;
    }

    @Override
    public void sampleOperation() {
    
    

    }
}

Structure en mode composite transparent

Le mode de synthèse transparent nécessite que toutes les classes de construction spécifiques, qu'il s'agisse de branches ou de feuilles, doivent implémenter une interface fixe

.

• Rôle de construction abstraite (composant): il spécifie une interface pour les objets participant à la combinaison. Ce rôle donne une interface commune et un comportement par défaut. Il peut être utilisé pour gérer tous les sous-objets. Il donnera toutes les méthodes de gestion des sous-objets . Comme ajouter, supprimer, etc.
• Rôle feuille: représente l'objet feuille participant à la combinaison, une feuille n'a pas de sous-objets de subordonnés et définit le comportement de l'objet original participant à la combinaison
• Rôle de construction de branche (composite): Représente les objets avec des sous-objets participant à la combinaison et donne le comportement de la construction d'objet de branche

Le code source correspondant est le suivant:

public interface Component {
    
    

    /** 返还自己的实例 */
    Composite getComposite();

    /** 某个商业方法 */
    void sampleOperation();

    /** 增加一个子构建对象 */
    void add(Component component);

    /** 删除一个子构建对象 */
    void remove(Component component);

    /** 返回所有的构建对象 */
    List<Component> components();
}

public class Composite implements Component {
    
    

    private List<Component> compositeList = new ArrayList<>();

    @Override
    public Composite getComposite() {
    
    
        return this;
    }

    @Override
    public void sampleOperation() {
    
    
        compositeList.forEach(v -> {
    
    
            v.sampleOperation();
        });
    }

    @Override
    public void add(Component component) {
    
    
        compositeList.add(component);
    }

    @Override
    public void remove(Component component) {
    
    
        compositeList.remove(component);
    }

    @Override
    public List<Component> components() {
    
    
        return compositeList;
    }
}

public class Leaf implements Component {
    
    
    @Override
    public Composite getComposite() {
    
    
        return null;
    }

    @Override
    public void sampleOperation() {
    
    

    }

    @Override
    public void add(Component component) {
    
    

    }

    @Override
    public void remove(Component component) {
    
    

    }

    @Override
    public List<Component> components() {
    
    
        return null;
    }
}

L'histoire du vieux moine et du jeune moine

Il y avait une montagne et un temple dans la montagne. Il y avait un vieux moine dans le temple qui racontait une histoire au petit moine. L'histoire concerne une montagne et un temple dans la montagne. Il y avait un vieux moine dans le temple qui racontait une histoire au petit moine.…
L'histoire ici est la construction de branche mentionnée ci-dessus, qui comprend des montagnes, des temples et des moines, tandis que les montagnes, les temples et les moines sont construits à partir de feuilles. Il n'y a pas de personnages internes

à voir. Les objets d'histoire incluent les objets de montagne, les objets de temple et les objets de moine., l'objet d'histoire, etc. L'

exemple de code correspondant est le suivant:
L'interface pour la narration, c'est-à-dire que l'histoire est un rôle de construction abstrait:

public interface StoryComponent {
    
    

    /** 讲故事 */
    void tellStory();
}

Voici le rôle qui laisse construire, c'est-à-dire l'histoire:

public class StoryComposite implements StoryComponent {
    
    

    private List<StoryComponent> componentList = new ArrayList<>();

    @Override
    public void tellStory() {
    
    
        for (StoryComponent s : componentList) {
    
    
            s.tellStory();
            if (s.getClass().getName().contains("MonkLeaf")) {
    
    
                tellStory();
            }
        }
    }

    public void add(StoryComponent component) {
    
    
        componentList.add(component);
    }

    public void remove(StoryComponent component) {
    
    
        componentList.remove(component);
    }

    public List<StoryComponent> getChild() {
    
    
        return componentList;
    }
}

Ce qui suit sont des montagnes, des temples et des moines, sans objet enfant:

public class MountainLeaf implements StoryComponent {
    
    
    @Override
    public void tellStory() {
    
    
        System.out.println("从前有座山");
    }
}

public class TempleLeaf implements StoryComponent {
    
    
    @Override
    public void tellStory() {
    
    
        System.out.println("山里有个庙");
    }
}

public class MonkLeaf implements StoryComponent {
    
    
    @Override
    public void tellStory() {
    
    
        System.out.println("庙里有个老和尚，老和尚再给小和尚讲故事，讲的什么故事呢？");
        System.out.println("讲的是：");
        System.out.println("----------------------------------------------------------------------");
    }
}

Commencé à raconter l'histoire:

public class StoryTest {
    
    

    public static void main(String[] args) {
    
    
        //故事
        StoryComposite story = new StoryComposite();
        //叶子：山、庙、道士
        StoryComponent mountain = new MountainLeaf();
        StoryComponent temple = new TempleLeaf();
        StoryComponent monk = new MonkLeaf();

        //添加子构建对象
        story.add(mountain);
        story.add(temple);
        story.add(monk);
        //开始讲故事
        story.tellStory();
    }
}

Ensuite, vous constaterez que le vieux moine est épuisé, haha. . .

Diagramme de classe: