【设计模式】【17】组合模式

应用场景

组合模式，又叫部分整体模式，英文名Composite Pattern

该模式将所有对象视为树状结构中的一个节点，所有对象的结构是完全一致的，且具备容器的功能，每个节点都可以再包含多个子节点

这种模式可以用来实现上级-下级，或是整体-部分的关系

组合模式有两种实现方式

• 一种是通过一个统一的节点类，来表示所有对象，任何一个对象都可以拥有上级节点，或添加下级节点
• 另一种是将根节点、枝节点、叶节点分别用三种不同的类来表示，根节点不允许拥有上级节点，叶节点不允许添加下级节点

第一种更加灵活，因为大多时候，根节点、枝节点、叶节点是没有绝对界限的，叶节点拥有了下级就会成为枝节点，枝节点删除了所有下级就会成为叶节点

第二种更加严格，适合只读不可改的树结构，或者是在添加节点时，就能实现预知该节点以后有没有下级节点的情况

实现代码一

	@SuppressWarnings("all")
	public class Node {
	
	    Node parent;
	
	    List<Node> children;
	
	    public void exec() {
	        //无下级节点时，自己处理
	        if (children == null) {
	            System.out.println("root node exec");
	            return;
	        }
	        //有下级节点时，转发给下级处理
	        for (Node child : children)
	            child.exec();
	    }
	
	    public Node getParent() {
	        return parent;
	    }
	
	    public List<Node> getChildren() {
	        return children;
	    }
	
	    public void setParent(Node parent) {
	        this.parent = parent;
	    }
	
	    public void add(Node node) {
	        children.add(node);
	        node.setParent(this);
	    }
	
	    public void remove(Node node) {
	        children.remove(node);
	        node.setParent(null);
	    }
	}

实现代码二

	abstract public class Node {
	
	    abstract public void exec();
	
	    abstract public BranchNode getParent();
	
	    abstract public List<Node> getChildren();
	
	    abstract public void setParent(BranchNode parent);
	
	    abstract public void add(Node node);
	
	    abstract public void remove(Node node);
	}

	//叶节点，底层节点，无下级
	@SuppressWarnings("all")
	public class LeafNode extends Node {
	
	    BranchNode parent;
	
	    @Override
	    public void exec() {
	        System.out.println("LeafNode exec");
	    }
	
	    @Override
	    public BranchNode getParent() {
	        return parent;
	    }
	
	    @Override
	    public List<Node> getChildren() {
	        throw new RuntimeException("LeafNode cannot have children");
	    }
	
	    @Override
	    public void setParent(BranchNode parent) {
	        this.parent = parent;
	    }
	
	    @Override
	    public void add(Node node) {
	        throw new RuntimeException("LeafNode cannot have children");
	    }
	
	    @Override
	    public void remove(Node node) {
	        throw new RuntimeException("LeafNode cannot have children");
	    }
	}

	//枝节点，中间节点，有上级也有下级
	public class BranchNode extends Node {
	
	    BranchNode parent;
	
	    List<Node> children;
	
	    @Override
	    public void exec() {
	        for (Node child : children)
	            child.exec();
	    }
	
	    @Override
	    public BranchNode getParent() {
	        return parent;
	    }
	
	    @Override
	    public List<Node> getChildren() {
	        return children;
	    }
	
	    @Override
	    public void setParent(BranchNode parent) {
	        this.parent = parent;
	    }
	
	    @Override
	    public void add(Node node) {
	        children.add(node);
	        node.setParent(this);
	    }
	
	    @Override
	    public void remove(Node node) {
	        children.remove(node);
	        node.setParent(null);
	    }
	}

	//根节点，顶级节点，无上级
	//根节点可视为一种特殊的枝节点
	@SuppressWarnings("all")
	public class RootNode extends BranchNode {
	
	    LeafNode parent;
	
	    List<Node> children;
	
	    @Override
	    public void exec() {
	        for (Node child : children)
	            child.exec();
	    }
	
	    @Override
	    public BranchNode getParent() {
	        throw new RuntimeException("RootNode cannot have parent");
	    }
	
	    @Override
	    public List<Node> getChildren() {
	        return children;
	    }
	
	    @Override
	    public void setParent(BranchNode parent) {
	        throw new RuntimeException("RootNode cannot have parent");
	    }
	
	    @Override
	    public void add(Node node) {
	        children.add(node);
	        node.setParent(this);
	    }
	
	    @Override
	    public void remove(Node node) {
	        children.remove(node);
	        node.setParent(null);
	    }
	
	    //对整个树进行数据统计
	    public void statistic(){
	        System.out.println("tree statistic");
	    }
	}