[设计模式8]组合模式

最新推荐文章于 2023-09-23 10:59:12 发布

stay_running

最新推荐文章于 2023-09-23 10:59:12 发布

阅读量153

点赞数

文章标签：组合模式 java 设计模式

本文链接：https://blog.csdn.net/weixin_38602383/article/details/122615873

版权

6，组合模式在java HashMap源码中的应用

1，基本介绍：

1) 组合模式（Composite Pattern），又叫部分整体模式，它是一种将对象组合成树状的层次结构的模式，将对象组合成树状结构以表示“整体-部分”的层次关系。

2) 组合模式依据树形结构来组合对象，用来表示部分以及整体层次。

3) 这种类型的设计模式属于结构型模式。

4) 组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象。

组合模式一般用来描述整体与部分的关系，它将对象组织到树形结构中，顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含树枝节点和叶子节点，树形结构图如下。

由上图可以看出，其实根节点和树枝节点本质上属于同一种数据类型，可以作为容器使用；而叶子节点与树枝节点在语义上不属于用一种类型。但是在组合模式中，会把树枝节点和叶子节点看作属于同一种数据类型（用统一接口定义），让它们具备一致行为。这样，在组合模式中，整个树形结构中的对象都属于同一种类型，带来的好处就是用户不需要辨别是树枝节点还是叶子节点，可以直接进行操作，给用户的使用带来极大的便利。

2，组合模式的注意事项和细节

2.1 优点

简化客户端操作。组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象。
具有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动，满足“开闭原则”。
方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结构
需要遍历组织机构，或者处理的对象具有树形结构时, 非常适合使用组合模式.

2.2 缺点

要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式
设计较复杂，客户端需要花更多时间理清类之间的层次关系；
不容易限制容器中的构件；
不容易用继承的方法来增加构件的新功能；

3，模式的结构

组合模式包含以下主要角色。

抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。（总的抽象类或接口，定义一些通用的方法，比如新增、删除）
树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。
树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

如下图所示

组合模式分为透明式的组合模式和安全式的组合模式。

3.1 透明方式

在该方式中，由于抽象构件声明了所有子类中的全部方法，所以客户端无须区别树叶对象和树枝对象，对客户端来说是透明的。但其缺点是：树叶构件本来没有 Add()、Remove() 及 GetChild() 方法，却要实现它们（空实现或抛异常），这样会带来一些安全性问题。其结构图如图 1 所示。

3.2 安全方式

在该方式中，将管理子构件的方法移到树枝构件中，抽象构件和树叶构件没有对子对象的管理方法，这样就避免了上一种方式的安全性问题，但由于叶子和分支有不同的接口，客户端在调用时要知道树叶对象和树枝对象的存在，所以失去了透明性。其结构图如图 2 所示。

4，模式实现：

4.1 透明组合模式

下面为透明式的组合模式的实现代码。

public class CompositePattern {
    public static void main(String[] args) {
        Component c0 = new Composite();
        Component c1 = new Composite();
        Component leaf1 = new Leaf("1");
        Component leaf2 = new Leaf("2");
        Component leaf3 = new Leaf("3");
        c0.add(leaf1);
        c0.add(c1);
        c1.add(leaf2);
        c1.add(leaf3);
        c0.operation();
    }
}
//抽象构件
interface Component {
    public void add(Component c);
    public void remove(Component c);
    public Component getChild(int i);
    public void operation();
}
//树叶构件
class Leaf implements Component {
    private String name;
    public Leaf(String name) {
        this.name = name;
    }
    public void add(Component c) {
    }
    public void remove(Component c) {
    }
    public Component getChild(int i) {
        return null;
    }
    public void operation() {
        System.out.println("树叶" + name + "：被访问！");
    }
}
//树枝构件
class Composite implements Component {
    private ArrayList<Component> children = new ArrayList<Component>();
    public void add(Component c) {
        children.add(c);
    }
    public void remove(Component c) {
        children.remove(c);
    }
    public Component getChild(int i) {
        return children.get(i);
    }
    public void operation() {
        for (Object obj : children) {
            ((Component) obj).operation();
        }
    }
}

4.2 安全组合模式

安全式的组合模式与透明式组合模式的实现代码类似，只要对其做简单修改就可以了，代码如下。

首先修改 Component 代码，只保留层次的公共行为。

interface Component {
    public void operation();
}

5，组合模式应用实例：

以学校和学院关系为例说明

示例代码：

1，定义接口：

//接口，组件
public interface OrganizationComponent {

    //添加组件
    void add(OrganizationComponent component);

    //删除组件
    void remove(OrganizationComponent component);

    //打印信息
    void print();
}

2，定义抽象类，实现接口

public abstract class Organization implements OrganizationComponent {

    //名称
    protected String name;

    //描述
    protected String des;

    public Organization(String name, String des) {
        this.name = name;
        this.des = des;
    }

    protected String getName() {
        return name;
    }

    protected String getDes() {
        return des;
    }

    @Override
    public void add(OrganizationComponent component) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void remove(OrganizationComponent component) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void print() {
    }
}

3.定义大学，学院，系（结构相似）

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class University extends Organization {

    List<OrganizationComponent> components = new ArrayList<>();

    public University(String name, String des) {
        super(name, des);
    }

    @Override
    public void add(OrganizationComponent component) {
        components.add(component);
    }

    @Override
    public void remove(OrganizationComponent component) {
        components.remove(component);
    }

    @Override
    public void print() {
        List<String> collect = components.stream().map(item -> {
            Organization organization = (Organization) item;
            return organization.getName();
        }).collect(Collectors.toList());
        System.out.println("university " + super.getName() + "contains colleges : " + collect.toString());
    }
}

public class College extends Organization{

    List<OrganizationComponent> components = new ArrayList<>();


    public College(String name, String des) {
        super(name, des);
    }

    @Override
    public void add(OrganizationComponent component) {
        components.add(component);
    }

    @Override
    public void remove(OrganizationComponent component) {
        components.remove(component);
    }

    @Override
    public void print() {
        List<String> collect = components.stream().map(item -> {
            Organization organization = (Organization) item;
            return organization.getName();
        }).collect(Collectors.toList());
        System.out.println("college " + super.getName() + "contains department : " + collect.toString());
    }
}

public class Department extends Organization {

    public Department(String name, String des) {
        super(name, des);
    }

    @Override
    public void print() {
        System.out.println(super.getName());
    }
}

4，调用

public class Client {

    public static void main(String[] args) {
        //构建学校以及相关学院，系的组织树
        OrganizationComponent component = new University("西北农大","还不错");
        //构建学院
        OrganizationComponent computerCollege = new College("计算机学院","挺好");
        //构建系
        OrganizationComponent programmingDepartment = new Department("软件编程","牛逼");
        OrganizationComponent softwareDesignDepartment = new Department("软件设计","更牛逼");
        computerCollege.add(programmingDepartment);
        computerCollege.add(softwareDesignDepartment);
        programmingDepartment.print();
        System.out.println("========");

        OrganizationComponent informationCollege = new College("信工学院","挺好！！！");
        OrganizationComponent communicationDepartment = new Department("通信工程","好牛逼");
        OrganizationComponent communicationDesignDepartment = new Department("通信设计","更牛逼");
        informationCollege.add(communicationDepartment);
        informationCollege.add(communicationDesignDepartment);
        informationCollege.print();
        System.out.println("========");

        //组件学校
        component.add(computerCollege);
        component.add(informationCollege);
        component.print();

    }
}

6，组合模式在java HashMap源码中的应用

从下面 HashMap 类的简化源码，我们可以看到 putAll( ) 方法中传入的是 Map 对象。这里的 Map 就是一个抽象构件，同时这个构件只支持键值对的存储格式，而 HashMap 是一个中间构件，HashMap 中的 Node 节点就是叶子节点。

如下图UML类图：

部分源码如下：

1,定义接口Map，并且Map中定义方法

public interface Map<K, V> {
    //定义相关方法
    
    int size();
    boolean isEmpty();
    ......
}

2,定义抽象类，并实现了Map方法

public abstract class AbstractMap<K,V> implements Map<K,V> {
    
    public int size() {
        return entrySet().size();
    }


    public boolean isEmpty() {
        return size() == 0;
    }
}

3,定义HashMap

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
        
        //HashMap中包含Node静态内部类 (叶子)
        static class Node<K,V> implements Map.Entry<K,V> {
            
        }
        
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    
    //接受一个Map
    public void putAll(Map<? extends K, ? extends V> m) {
        putMapEntries(m, true);
    }
}