java23中设计模式之组合模式

旧城等待， 2022-03-06 17:40 156阅读 0赞

上一节说到代理模式：[https://blog.csdn.net/zhanglei082319/article/details/88672268][https_blog.csdn.net_zhanglei082319_article_details_88672268]

代理模式：代理者拥有委托人的部分权限，代理者也可以在代理的同时加上自己的部分业务

今天说一种新的设计模式：组合模式

**组合模式： 对象自身包含其他对象的引用，以达到组合对象数据的效果**

树形的数据结构生活中非常常见，比如国家城市县镇地址，公司部门子部门班组，盘符目录子目录文件等等。这种一层嵌套者一层的数据的构建，在java中，组合设计模式就起到了用武之地。

这里就以国家城市县镇例子，简单将组合模式用代码来实现。

**1、先定义一个地址节点接口**

/**
     * 地址节点
     */
    public interface Node {
    
        /**
         * 当前节点名称
         */
        String  name();
    
        /**
         * 父节点名称
         */
        String  parentName();
    
        /**
         * 子节点名称
         */
        List<Node> childNode();
    
    
        /**
         * 添加子节点
         */
        void   addChildNode(Node childNode);
    }

**2、定义一个地址实现**

/**
     * 地址实现元素
     */
    public class Element implements Node {
    
        private String name;
    
        /**
         * 父节点名称
         */
        private String parentName;
    
        private List<Node> childNode = new LinkedList<>();
    
        public Element(String name,String parentName){
            this.name = name;
            this.parentName = parentName;
        }
    
        @Override
        public void  addChildNode(Node child){
            this.childNode.add(child);
        }
    
    
        @Override
        public String name() {
            return this.name;
        }
    
        @Override
        public String parentName() {
            return this.parentName;
        }
    
        @Override
        public List<Node> childNode() {
            return this.childNode;
        }
    }

**3、定义叶子地址实现（就是没有子地址的地址）**

/**
     * 叶子地址
     */
    public class Leaf implements Node {
        private String name;
    
        private String parentName;
    
        public Leaf(String name,String parentName){
            this.name = name;
            this.parentName = parentName;
        }
    
        @Override
        public String name() {
            return this.name;
        }
    
        @Override
        public String parentName() {
            return this.parentName;
        }
    
        @Override
        public List<Node> childNode() {
            return null;
        }
    
        @Override
        public void addChildNode(Node childNode) {
            throw new UnsupportedOperationException("unspport");
        }
    }

**最后我们来测试一下：**

public static void main(String[] args) {
            //主元素
            Element shanghai = new Element("上海",null);
            //子元素
            Element pudong = new Element("浦东新区","上海");
            Element huangpu = new Element("黄埔区","上海");
            //孙元素
            Leaf lujiazui = new Leaf("陆家嘴","浦东新区");
            Leaf babaiban = new Leaf("八佰伴","浦东新区");
            Leaf waitan = new Leaf("外滩","黄埔区");
    
    
            //组合
            pudong.addChildNode(lujiazui);
            pudong.addChildNode(babaiban);
    
            huangpu.addChildNode(waitan);
    
            shanghai.addChildNode(pudong);
            shanghai.addChildNode(huangpu);
    
            System.out.println(shanghai);
      }

执行结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbGVpMDgyMzE5_size_16_color_FFFFFF_t_70][]

这样一个简单的地址树形数据就完成了。

扩展一下，如果地址数量过多，可以进行循环递归构建树形数据，如下

private static Node build(List<Node> allNodes){
            Node element = null;
            Iterator<Node> iterator = allNodes.iterator();
            while(iterator.hasNext()){
                Node node = iterator.next();
                if(node.parentName() == null){
                    element = node;
                    iterator.remove();
                    break;
                }
            }
            recursion(allNodes,element);
            return element;
        }
    
    
        private static void  recursion(List<Node> allNodes,Node result){
            Iterator<Node> iterator = allNodes.iterator();
            while(iterator.hasNext()) {
                Node node = iterator.next();
                if(node.parentName().equals(result.name())){
                    result.addChildNode(node);
                    recursion(allNodes,node);
                }
            }
        }
    
        public static void main(String[] args) {
            //主元素
            Element shanghai = new Element("上海",null);
            //子元素
            Element pudong = new Element("浦东新区","上海");
            Element huangpu = new Element("黄埔区","上海");
            //孙元素
            Leaf lujiazui = new Leaf("陆家嘴","浦东新区");
            Leaf babaiban = new Leaf("八佰伴","浦东新区");
            Leaf waitan = new Leaf("外滩","黄埔区");
    
            List<Node> nodes = new LinkedList<>();
            nodes.add(shanghai);
            nodes.add(pudong);
            nodes.add(huangpu);
            nodes.add(lujiazui);
            nodes.add(babaiban);
            nodes.add(waitan);
    
            Node element = build(nodes);
            System.out.println();
        }

执行结果如下，并没有变化。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbGVpMDgyMzE5_size_16_color_FFFFFF_t_70 1][]

以上

[https_blog.csdn.net_zhanglei082319_article_details_88672268]: https://blog.csdn.net/zhanglei082319/article/details/88672268
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbGVpMDgyMzE5_size_16_color_FFFFFF_t_70]: /images/20220301/3cd800e786284c18a36068dff48c4aa6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nbGVpMDgyMzE5_size_16_color_FFFFFF_t_70 1]: /images/20220301/94cd1114d12d4ee9a323ff3ebcc1265c.png