Java 23种设计模式（11.结构型模式-组合模式）

ゝ一纸荒年。 2023-09-23 22:58 127阅读 0赞

> # 结构型模式-`组合模式` #

# 代码解析 #

## 类图 ##

![在这里插入图片描述][b11122411c55404b9229edf0d4a69f3e.png]

## 代码 ##

abstract class Component {
        
        protected  String name;//名称
        protected int level;    //层级
        abstract void add(Component c);//添加子树
        abstract void remove(Component c);//移除子树
        Component getChild(int i) {
        return null;}//获取指定的子树
    
        abstract void display ();//打印树名称的方法（包含子树和叶）
    
        public Component(String name, int level) {
        
            this.name = name;
            this.level = level;
        }
    }

public class Composite extends Component{
        
        protected List<Component> list ;//树可以有多个子树或者树叶
    
        public Composite(String name, int level) {
        
            super(name, level);
            list= new ArrayList<Component>();
        }
    
        void add(Component c) {
        
            list.add(c);
        }
        void remove(Component c) {
        
            list.remove(c);
        }
        @Override
        Component getChild(int i) {
        
            return list.get(i);
        }
        void display() {
        
            for (int i = 0; i < level; i++) {
        
                System.out.print("-");
            }
            System.out.println(name);
    
            for(Component c :list){
        
                c.display();
            }
        }
    }

public class Leaf extends Component{
        
    
        public Leaf(String name, int level) {
        
            super(name, level);
        }
    
        void add(Component c) {
        
            System.out.println("add a leaf");
        }
    
        void remove(Component c) {
        
            System.out.println("remove a leaf");
    
        }
    
        void display() {
        
            for (int i = 0; i < level; i++) {
        
                System.out.print("-");
            }
            System.out.println(name);
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
    
            Composite root  = new Composite("root",1);
            root.add(new Leaf("leaf A",2));
            root.add(new Leaf("leaf B",2));
    
            Composite branch1  = new Composite("branch1",2);
            branch1.add(new Leaf("branch1 A",3));
            branch1.add(new Leaf("branch1 B",3));
            root.add(branch1);
    
            Composite branch2  = new Composite("branch2",2);
            branch2.add(new Leaf("branch2 A",3));
            branch2.add(new Leaf("branch2 B",3));
            root.add(branch2);
            root.display();
            System.out.println("====");
            Component child = root.getChild(1);
            System.out.println(child.name);
        }
    }

-root
    --leaf A
    --leaf B
    --branch1
    ---branch1 A
    ---branch1 B
    --branch2
    ---branch2 A
    ---branch2 B
    ====
    leaf B

## 结果 ##

# 1.概述 #

![在这里插入图片描述][59308279f4de4521bd001106a1dcb08e.png]  
对于这个图片肯定会非常熟悉，上图我们可以看做是一个文件系统，对于这样的结构我们称之为`树形结构`。在树形结构中可以通过调用某个方法来遍历整个树，当我们找到某个叶子节点后，就可以对叶子节点进行相关的操作。**可以将这颗树理解成一个大的容器，容器里面包含很多的成员对象，这些成员对象即可是容器对象也可以是叶子对象。但是由于容器对象和叶子对象在功能上面的区别**，使得我们在使用的过程中必须要区分容器对象和叶子对象，但是这样就会给客户带来不必要的麻烦，作为客户而已，它始终希望**能够一致的对待容器对象和叶子对象**。

**定义：**

又名部分`整体模式`，是用于**把一组相似的对象当作一个单一的对象**。**组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式**，它创建了对象组的树形结构。

# 2.结构 #

组合模式主要包含三种角色：

*  `抽象根节点（Component）`：定义**系统各层次对象的共有方法和属性**，可以预先定义一些默认行为和属性。
 *  `树枝节点（Composite）`：定义**树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。**
 *  `叶子节点（Leaf）`：叶子节点对象，其下再无分支，是**系统层次遍历的最小单位**。

# 3. 类图 #

![在这里插入图片描述][d8b58c7a161642938e3d6a2dab18fe1a.png]

# 4. 代码 #

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();
        }
        MenuComponent getChild(int i){
        //获取指定的子菜单
            throw new UnsupportedOperationException();
        }
    
        public String getName(){
        //获取菜单或者菜单项的名称
            return name;
        }
        abstract void print();//打印菜单名称的方法（包含子菜单和字菜单项）
    }

public class Menu extends MenuComponent {
        
        private List<MenuComponent> menuComponentList ;//菜单可以有多个子菜单或者子菜单项
    
        public Menu(String name,int level) {
        //构造方法
            this.name = name;
            this.level = level;
            menuComponentList = new ArrayList<>();
        }
    
        @Override
        public void add(MenuComponent menuComponent) {
        
            menuComponentList.add(menuComponent);
        }
        public void remove(MenuComponent menuComponent){
        
            menuComponentList.remove(menuComponent);
        }
    
        @Override
        MenuComponent getChild(int i) {
        
            return menuComponentList.get(i);
        }
    
        public void print(){
        //打印菜单名称
            for (int i = 0; i < level; i++) {
        
                System.out.print("--");
            }
            System.out.println(name);
            for(MenuComponent menuComponent:menuComponentList){
        //打印子菜单或者子菜单项名称
                menuComponent.print();
            }
        }
    }

public class MenuItem extends MenuComponent{
        
    
        public MenuItem(String name, int level) {
        
            this.name = name;
            this.level = level;
        }
        public void print(){
        
            //打印菜单项的名称
            for (int i = 0; i <level; i++) {
        
                System.out.print("--");
            }
            System.out.println(name);
        }
    }

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();
        }
    }

--系统管理
    ----菜单管理
    ------页面访问
    ------展开菜单
    ------编辑菜单
    ------删除菜单
    ------新增菜单
    ----权限管理
    ------页面访问
    ------提交保存
    ----角色管理
    ------页面访问
    ------新增角色
    ------修改角色

# 5.优缺点 #

*  `组合模式`可以清楚地定义分层次的复杂对象，**表示对象的全部或部分层次**，它让**客户端忽略了层次的差异，方便对整个层次结构进行控制**。
 *  客户端可以一致地使用一个组合结构或其中单个对象，**不必关心处理的是单个对象还是整个组合结构，简化了客户端代码**。
 *  在组合模式中增加新的树枝节点和叶子节点都很方便，无须对现有类库进行任何修改，符合“开闭原则”。
 *  组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，**通过叶子节点和树枝节点的递归组合，可以形成复杂的树形结构**，但对树形结构的控制却非常简单。

# 6. 使用场景 #

**组合模式正是应树形结构而生**，所以组合模式的使用场景就是出现树形结构的地方。比如：**文件目录显示，多级目录呈现等树形结构数据的操作**。

[b11122411c55404b9229edf0d4a69f3e.png]: https://img-blog.csdnimg.cn/b11122411c55404b9229edf0d4a69f3e.png
[59308279f4de4521bd001106a1dcb08e.png]: https://img-blog.csdnimg.cn/59308279f4de4521bd001106a1dcb08e.png
[d8b58c7a161642938e3d6a2dab18fe1a.png]: https://img-blog.csdnimg.cn/d8b58c7a161642938e3d6a2dab18fe1a.png