关于java:组合模式

将对象组合成树状构造以示意整个局部的层次结构，组合模式能够让用户对立看待单个对象和对象组合。

组合模式个别能够分三个角色

• 形象组件：定义须要实现的对立操作
• 组合节点：一个能够蕴含多个对象的复合对象，意味着它上面可能还会有其它组合节点和叶子节点
• 叶子节点：上面不会有其它节点（与组合几点惟一的差距就是没有子节点）

组合模式最罕用的就是用来示意一些树形构造的对象关系，就比如说部门或者员工之间的上下级关系。

上面通过员工上下级关系的例子来实现一个组合模式

形象组件，外面定义了一些节点的独特属性和办法

public abstract class AbstractNode {
    private String name;
    private AbstractNode parent;

    public AbstractNode(String name) {this.name = name;}

    public AbstractNode getParent() {return parent;}

    public void setParent(AbstractNode parent) {this.parent = parent;}

    public String getName(){return name;}

    public abstract void addChild(AbstractNode node);
    public abstract AbstractNode getChild(int i);
    public abstract void removeChild(int i);

    /**
     * 员工自我介绍
     */
    public abstract void introduce();

    /**
     * 团队统计
     */
    public abstract int teamCount();}

组合节点相当于领导层，它们上面会治理一些员工

public class Node extends AbstractNode{
    private List<AbstractNode> nodes;
    public Node(String name) {super(name);
        nodes = new ArrayList<>();}

    @Override
    public void addChild(AbstractNode node) {node.setParent(this);
        nodes.add(node);
    }

    @Override
    public AbstractNode getChild(int i) {return nodes.get(i);
    }

    @Override
    public void removeChild(int i) {nodes.remove(i);
    }

    @Override
    public void introduce() {String parentName = getParent()==null?"null":getParent().getName();
        System.out.println("I am"+getName()+",my parent is"+parentName+
        ",I have"+nodes.size()+"child.");
        for (AbstractNode node:nodes) {node.introduce();
        }
    }

    @Override
    public int teamCount() {
        int count = 0;
        for (AbstractNode node:nodes) {count += node.teamCount();
        }
        return count + 1;
    }


}

叶子节点，相当于底层员工，它们相随与组合节点更加简略

public class Leaf extends AbstractNode{public Leaf(String name) {super(name);
    }

    @Override
    public void addChild(AbstractNode node) {throw new RuntimeException("这是叶子节点");
    }

    @Override
    public AbstractNode getChild(int i) {throw new RuntimeException("这是叶子节点");
    }

    @Override
    public void removeChild(int i) {throw new RuntimeException("这是叶子节点");
    }

    @Override
    public void introduce() {System.out.println("I am"+getName()+",my parent is"+getParent().getName()+".");
    }

    @Override
    public int teamCount() {return 1;}
}

客户端调用

public class Client {public static void main(String[] args) {AbstractNode head = new Node("大领导");
        AbstractNode midA = new Node("小领导 A");
        AbstractNode midB = new Node("小领导 B");
        AbstractNode staff1 = new Leaf("员工 -1");
        AbstractNode staff2 = new Leaf("员工 -2");
        AbstractNode staff3 = new Leaf("员工 -3");

        head.addChild(midA);
        head.addChild(midB);
        midA.addChild(staff1);
        midA.addChild(staff2);
        midB.addChild(staff3);

        head.introduce();
        System.out.println(head.getName()+"一共领导"+head.teamCount()+"人");
        System.out.println(midA.getName()+"一共领导"+midA.teamCount()+"人");

    }
}
========== 后果 ==========
I am 大领导,my parent is  null,I have 2 child.
I am 小领导 A,my parent is 大领导,I have 2 child.
I am 员工 -1,my parent is 小领导 A.
I am 员工 -2,my parent is 小领导 A.
I am 小领导 B,my parent is 大领导,I have 1 child.
I am 员工 -3,my parent is 小领导 B.
大领导一共领导 6 人
小领导 A 一共领导 3 人

组合模式的次要目标是能够通过对象之间的组合关系把一组对象当作一个整体，对立操作。