Analyse d'exemples de modèles de composition de modèles de conception Java

1. Introduction de base

1) Le modèle composite, également appelé modèle partie-tout, crée une structure arborescente de groupes d'objets et combine les objets dans une structure arborescente pour représenter la relation hiérarchique « partie entière »

2) Le mode de combinaison combine des objets basés sur une structure arborescente pour représenter des parties et des niveaux entiers

3) Ce type de modèle de conception appartient au mode structurel

4) Le mode combinaison permet aux utilisateurs d'accéder à des objets uniques et à des objets combinés. Cohérent, c'est-à-dire : la combinaison permet clients pour traiter les objets individuels et les objets combinés de manière cohérente

2. Structure

Le modèle de combinaison comprend principalement trois rôles :

• Nœud racine abstrait (composant) : définit chaque niveau du système Méthodes communes et attributs des objets , certains comportements et attributs par défaut peuvent être prédéfinis

• Nœud de branche (Composite) : définir le comportement des nœuds de branche, stocker les nœuds enfants, combiner les nœuds de branche et les nœuds feuilles pour former une arborescence

• Nœud feuille (Leaf) : L'objet nœud feuille, sans branche en dessous, est la plus petite unité de traversée au niveau du système

3 Problèmes résolus par le mode combinaison

1) Le mode combinaison résout de tels problèmes lorsque nous devons les traiter L'objet. peut générer une structure arborescente, et lorsque l'on veut faire fonctionner les nœuds et les feuilles de l'arbre, cela peut fournir une manière cohérente, qu'il s'agisse d'un nœud ou d'une feuille

2) Le schéma correspondant

4 . Le modèle combiné résout le problème de l'affichage du département scolaire

1) Exigences de l'exemple d'application

Écrivez un programme pour afficher la structure d'un département scolaire : La demande est la suivante : afficher la composition du département de l'école sur une seule page, et une école a plusieurs collèges, un collège a plusieurs départements

2) Analyse et diagramme d'idées (schéma de classes)

3) Implémentation du code

Interface de déclaration d'objet composite de composant

package com.zte;
public abstract class OrganizationComponent {
    private String name;// 名字
    private String des;// 说明
    public String getName() {
        return name;
    }
    public String getDes() {
        return des;
    }
    protected void add(OrganizationComponent organizationComponent) {
        // 默认实现
        throw new UnsupportedOperationException();
    }
    protected void remove(OrganizationComponent organizationComponent) {
        // 默认实现
        throw new UnsupportedOperationException();
    }
    // 构造器
    public OrganizationComponent(String name, String des) {
        this.name = name;
        this.des = des;
    }
    // 方法print，抽象方法
    protected abstract void print();
}

Nœud composite non-feuille

package com.zte;
import java.util.ArrayList;
import java.util.List;
// University 就是 Composite，可以管理College
public class University extends OrganizationComponent {
    List<OrganizationComponent> organizationComponentList = new ArrayList<>();
    // 构造器
    public University(String name, String des) {
        super(name, des);
    }
    //重写add
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponentList.add(organizationComponent);
    }
    // 重写remove
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponent.remove(organizationComponent);
    }
    @Override
    protected void print() {
        System.out.println("==========" + getName() + "=========");
        for (OrganizationComponent organizationComponent : organizationComponentList) {
            organizationComponent.print();
        }
    }
    @Override
    public String getName() {
        return super.getName();
    }
    @Override
    public String getDes() {
        return super.getDes();
    }
}

Composite non- Nœud feuille

package com.zte;
import java.util.ArrayList;
import java.util.List;
public class College extends OrganizationComponent {
    // list中存放department
    List<OrganizationComponent> organizationComponentList = new ArrayList<>();
    public College(String name, String des) {
        super(name, des);
    }
    //重写add
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponentList.add(organizationComponent);
    }
    // 重写remove
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponent.remove(organizationComponent);
    }
    @Override
    protected void print() {
        System.out.println("==========" + getName() + "=========");
        for (OrganizationComponent organizationComponent : organizationComponentList) {
            organizationComponent.print();
        }
    }
    @Override
    public String getName() {
        return super.getName();
    }
    @Override
    public String getDes() {
        return super.getDes();
    }
}

Nœud feuille

package com.zte;
public class Department extends OrganizationComponent {
    public Department(String name, String des) {
        super(name, des);
    }
    // add和remove方法就不需要再写了
    @Override
    protected void print() {
        System.out.println("===========" + getName() + "=========");
    }
    @Override
    public String getName() {
        return super.getName();
    }
    @Override
    public String getDes() {
        return super.getDes();
    }
}

package com.zte;
public class Client {
    public static void main(String[] args) {
        // 创建大学
        OrganizationComponent university = new University("清华大学", "中国最好的大学");
        // 创建学院
        OrganizationComponent college1 = new College("计算机学院", "计算机学院");
        OrganizationComponent college2 = new College("信息工程学院", "信息工程学院");
        // 创建各个学院下面的系
        college1.add(new Department("软件工程", "软件工程"));
        college1.add(new Department("网络工程", "网络工程"));
        college1.add(new Department("计算机科学与技术", "老牌专业"));
        college2.add(new Department("通信工程", "通信工程"));
        college2.add(new Department("信息工程", "信息工程"));
        // 将学院添加到学校中
        university.add(college1);
        university.add(college2);
        // 打印大学底下的所有院系
        university.print();
        // 打印学院底下的所有系
        college1.print();
    }
}

5 Précautions et détails du mode de combinaison

1) Simplifiez les opérations du client, le client n'a besoin que de faire face à des objets cohérents sans considérer le problème global de la pièce ou de la feuille de nœud

2) Il a forte évolutivité. Lorsque nous devons modifier l'objet combiné, il suffit d'ajuster la relation hiérarchique interne et le client n'a pas besoin d'apporter de modifications. 3) Il est pratique de créer des structures hiérarchiques complexes et le client n'en a pas besoin. faire attention à l'intérieur de la combinaison. Détails de la composition, ajout facile de nœuds ou de feuilles pour créer une structure arborescente complexe

4) Lorsque vous devez parcourir la structure organisationnelle ou que l'objet en cours de traitement a une structure arborescente, c'est le cas. très approprié pour utiliser le mode combinaison

5) Abstraction très exigeante S'il existe de nombreuses différences entre les nœuds et les feuilles, par exemple, de nombreuses méthodes et attributs sont différents, il n'est pas approprié d'utiliser le mode combinaison

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!