Notes sur les modèles de combinaison de modèles de conception
illustrer
Enregistrez la méthode d'écriture pour apprendre le modèle de combinaison de modèle de conception. La version du JDK utilisée est la version 1.8.
Composite
Intention : Combinez des objets dans une structure arborescente pour représenter une hiérarchie « partie-tout ». Composite permet aux utilisateurs d'utiliser des objets uniques et des objets composites de manière cohérente.
Structure :
dans:
- Le composant déclare une interface pour les objets de la composition ; implémente le comportement par défaut de l'interface commune à toutes les classes le cas échéant ; déclare une interface pour accéder et gérer les sous-composants du composant ; (facultatif) définit une interface dans la structure récursive pour l'accès un composant parent et implémentez-le le cas échéant.
- Leaf représente l'objet nœud feuille dans la combinaison, et le nœud feuille n'a pas de nœud enfant ; le comportement de l'objet primitif est défini dans la combinaison.
- Composite définit le comportement des composants qui ont des sous-composants, stocke les sous-composants et implémente les opérations liées aux sous-composants dans l'interface du composant.
- Le client manipule les objets des composants composites via l'interface Component.
applicabilité :
- Vous souhaitez représenter une hiérarchie d’objets partie-tout.
- On espère que les utilisateurs ignoreront la différence entre les objets composites et les objets uniques, et qu'ils utiliseront uniformément tous les objets de la structure composite.
Scénarios d'utilisation :
le mode combinaison est né en réponse à la structure arborescente, donc le scénario d'utilisation du mode combinaison est l'endroit où la structure arborescente apparaît. Par exemple : affichage du répertoire de fichiers, présentation du répertoire à plusieurs niveaux et autres opérations de données de structure arborescente.
Table des matières
Exemple de diagramme de classes de modèle de combinaison
Utilisez ce diagramme de classes UML pour implémenter l’exemple de modèle de composition.
Classe abstraite du composant de menu
package com.example.deesign_patterns.composite;
//菜单组件类
public abstract class MenuComponent {
//菜单组件的名称
protected String name;
//菜单组件的层级
protected int level;
//添加子菜单
public void add(MenuComponent menuComponent){
throw new UnsupportedOperationException();
}
//移除子菜单
public void remove(MenuComponent menuComponent){
throw new UnsupportedOperationException();
}
//获取指定的子菜单
public MenuComponent getChild(int index){
throw new UnsupportedOperationException();
}
//获取菜单或者菜单项的名称
public String getName(){
return name;
}
//打印菜单名称的方法(包含子菜单和子菜单项)
public abstract void print();
}
Type de menu
package com.example.deesign_patterns.composite;
import java.util.ArrayList;
import java.util.List;
//菜单类
public class Menu extends MenuComponent{
//菜单可以有多个子菜单或者子菜单项
private List<MenuComponent> menuComponentList=new ArrayList<MenuComponent>();
//构造方法
public Menu(String name,int level) {
this.name=name;
this.level=level;
}
@Override
public void add(MenuComponent menuComponent) {
menuComponentList.add(menuComponent);
}
@Override
public void remove(MenuComponent menuComponent) {
menuComponentList.remove(menuComponent);
}
@Override
public MenuComponent getChild(int index) {
return menuComponentList.get(index);
}
@Override
public void print() {
//打印菜单名称
for(int i=0;i<level;i++){
System.out.print("--");
}
System.out.println(name);
//打印子菜单或者子菜单项名称
for(MenuComponent component:menuComponentList){
component.print();
}
}
}
Classe d'éléments de menu
package com.example.deesign_patterns.composite;
//菜单项类
public class MenuItem extends MenuComponent{
//构造方法
public MenuItem(String name,int level) {
this.name=name;
this.level=level;
}
@Override
public void print() {
//打印菜单项的名称
for(int i=0;i<level;i++){
System.out.print("--");
}
System.out.println(name);
}
}
Classe d'essai
package com.example.deesign_patterns.composite;
//测试类
public class Client {
public static void main(String[] args) {
//创建菜单树
MenuComponent menu1=new Menu("菜单管理",2);
menu1.add(new MenuItem("页面访问",3));
menu1.add(new MenuItem("展开菜单",3));
menu1.add(new MenuItem("编辑菜单",3));
menu1.add(new MenuItem("删除菜单",3));
menu1.add(new MenuItem("新增菜单",3));
MenuComponent menu2=new Menu("权限配置",2);
menu2.add(new MenuItem("页面访问",3));
menu2.add(new MenuItem("提交保存",3));
MenuComponent menu3=new Menu("角色管理",2);
menu3.add(new MenuItem("页面访问",3));
menu3.add(new MenuItem("新增角色",3));
menu3.add(new MenuItem("修改角色",3));
//创建一级菜单
MenuComponent component=new Menu("系统管理",1);
//将二级菜单添加到一级菜单
component.add(menu1);
component.add(menu2);
component.add(menu3);
//打印菜单名称(如果有子菜单一块打印)
component.print();
}
}
avantage:
- Le mode combinaison permet de définir clairement des objets hiérarchiques complexes, représentant tout ou partie de la hiérarchie de l'objet. Il permet au client d'ignorer les différences hiérarchiques et de faciliter le contrôle de l'ensemble de la structure hiérarchique.
- Le client peut utiliser de manière cohérente une structure composite ou un objet unique à l'intérieur de celle-ci, sans avoir à se soucier de savoir s'il s'agit d'un objet unique ou de l'objet composite entier, ce qui simplifie le code client.
- Il est très pratique d'ajouter de nouveaux nœuds de branche et de feuille en mode combinaison sans aucune modification à la bibliothèque de classes existante, qui est conforme au principe d'ouverture et de fermeture.
- Le mode combinaison fournit une solution flexible pour la mise en œuvre orientée objet des structures arborescentes. Grâce à la combinaison récursive de nœuds feuilles et de nœuds de branche, des structures arborescentes complexes peuvent être formées, mais le contrôle de la structure arborescente est très simple.