彻底搞懂设计模式DesignPattern-组合模式

最新推荐文章于 2024-02-20 19:04:47 发布

Debug-ya

最新推荐文章于 2024-02-20 19:04:47 发布

阅读量278

点赞数

分类专栏： Design Patterns

本文链接：https://blog.csdn.net/wangwenpeng0529/article/details/108348530

版权

Design Patterns 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

组合模式

基本介绍

组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系。
组合模式依据树形结构来组合对象，用来表示部分以及整体层次。
这种类型的设计模式属于结构型模式。
组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象

原理类图

在这里插入图片描述

角色及职责

Component :这是组合中对象声明接口，在适当情况下，实现所有类共有的接口默认行为,用于访问和管理Component 子部件, Component 可以是抽象类或者接口
Leaf : 在组合中表示叶子节点，叶子节点没有子节点
Composite :非叶子节点，用于存储子部件，在 Component 接口中实现子部件的相关操作，比如增加(add), 删除。

解决的问题

组合模式解决这样的问题，当我们的要处理的对象可以生成一颗树形结构，而我们要对树上的节点和叶子进行操作时，它能够提供一致的方式，而不用考虑它是节点还是叶子

实例要求

编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。
思路分析和图解(类图)

代码示例

码云地址https://gitee.com/magneto/codeReview/tree/master/DesignPattern/src/pro51/top/adapter

JDK中Map的组合模式

使用类图分析

在这里插入图片描述
1.可以看到Map和AbstractMap是属于我们说的组合模式中的Component对象，声明方法的接口或者抽象类
2.HashMap其子类，属于子节点的类，用于存储子部件
3.Node是HashMap的内部类，从源码可以发现他就是我们组合模式中讲述的Leaf节点，他只有get，set功能
4.如上大致可以看出这是一个组合模式，接下来我们用源码来看看

源码分析

先看到Map接口，可以看到定义的众多方法中有两个我们常用的方法，put()，putAll()，他将被实现

public interface Map<K,V> {
    ………………
	V put(K key, V value);
	void putAll(Map<? extends K, ? extends V> m);
    ………………
}

接着来到AbstractMap，它实现了Map接口，由于Map的实现类会有很多，所以jdk中使用这个抽象类来作为缓冲类，将一些方法默认实现，使得该接口更具有扩展性，如下它默认实现了put()和putAll()

public abstract class AbstractMap<K,V> implements Map<K,V> {
    ……………………
    //默认实现
    public V put(K key, V value) {
        throw new UnsupportedOperationException();
    }
    public void putAll(Map<? extends K, ? extends V> m) {
       for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
            put(e.getKey(), e.getValue());
    }
    ……………………
}

然后我们来到最常用HashMap类中，可以看到它对接口和抽象类都进行了实现，发现了还有一个Node对象

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    ……………………
    //来到put方法，看到这里进行了具体的实现
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
    //这里省略具体的操作，我们只关心设计模式，putAll也与put方法类似，就不讲述了，之后会再写一些关于java集合类的具体实现
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        //这里用到了一个Node对象，我们进入到Node对象中观察
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        ………………………………
    }
}

来到HashMap的内部类Node对象中，我们发现，他其实就是我们组合模式中所讲述的Leaf对象，它没有再组合任何的子节点，提供的也只有get方法和set方法

 static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

如上，我们可以清晰地看出来，Map中的HashMap是应用了组合模式来实现的