java23类设计模式三(连载)

java23种设计模式三(连载)

三、组合模式

组合模式，也叫合成模式，树模式，它是一组对象的组合，这些对象可以是容器对象，表现为组的概念。

组合模式的意图是为了保证客户端调用单对象于组合对象的一致性。

涉及角色：
　　1.Component 是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component
子部件。
　　2.Leaf 在组合中表示叶子结点对象，叶子结点没有子结点。
　　3.Composite 定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关操作，如增加(add)和删除(remove)等。

适用性
　　以下情况下适用组合模式：
　　1．你想表示对象的部分-整体层次结构
　　2．你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

以下代码体现了组合模式的思想：

package tree;


public abstract class Tree {
	
	/**
	 * 添加一个树节点
	 * @param tree
	 */
	public abstract void add(Tree tree);
	
	/**
	 * 批量添加树节点
	 * @param trees
	 */
	public abstract void add(Tree[] trees);
	
	/**
	 * 移除一个树节点
	 * @param tree
	 */
	public abstract void remove(Tree tree);
	
}

package cn.sunsharp.tbapp.util.tree;

import java.util.ArrayList;
import java.util.List;

public class TreeNode extends Tree{
    
    private Long id;
    
    private Long parentId;
    
    private List<Tree> children;
    
    private String text;
    
    private String state;
    
    private Boolean checked;
    
    
    public static class Builder{
        private Long id;
        
        private Long parentId;
        
        private List<Tree> children = new ArrayList<Tree>();
        
        private String text;
        
        private String state;
        
        private Boolean checked;
        
        public Builder id(Long id){
            this.id = id;
            return this;
        }
        
        public Builder parentId(Long parentId){
            this.parentId = parentId;
            return this;
        }
        
        public Builder children(List<Tree> children){
            this.children = children;
            return this;
        }
        
        public Builder text(String text){
            this.text = text;
            return this;
        }

        public Builder state(String state){
            this.state = state;
            return this;
        }
        
        public Builder checked(Boolean checked){
            this.checked = checked;
            return this;
        }
        public Tree build(){
            return new TreeNode(this);
        }
    }
    
    @Override
    public void add(Tree tree) {
        children.add(tree);
    }

    @Override
    public void remove(Tree tree) {
        children.remove(tree);
    }
    
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(1000);
        sb.append("{id:");
        sb.append(id);
        sb.append(",text:\"");
        sb.append(text);
        sb.append("\",iconCls:");
        sb.append("\"icon-ok\"");
        sb.append(",children:");
        sb.append(children.toString());
        sb.append("}");
        return sb.toString();
    }
        
    private TreeNode(Builder builder){
        id = builder.id;
        parentId = builder.parentId;
        children = builder.children;
        text = builder.text;
        state = builder.state;
        checked = builder.checked;
    }

    public Long getId() {
        return id;
    }
    
    public Long getParentId() {
        return parentId;
    }
    
    public String getText() {
        return text;
    }
    public String getState() {
        return state;
    }
    public Boolean getChecked() {
        return checked;
    }
    public List<Tree> getChildren() {
        return children;
    }

    @Override
    public void add(Tree[] trees) {
        for(Tree tree:trees){
            children.add(tree);
        }
    }
}

public static void main(String[] args) {
		Tree root = new TreeNode.Builder().text("根节点").build();
		Tree parent1 = new TreeNode.Builder().text("父节点1").build();
		Tree parent2 = new TreeNode.Builder().text("父节点2").build();
		root.add(parent1);
		root.add(parent2);
		Tree son11 = new TreeNode.Builder().text("子节点11").build();
		Tree son12 = new TreeNode.Builder().text("子节点12").build();
		parent1.add(son11);
		parent1.add(son11);
		System.out.println(root.toString());
	}

java23类设计模式三(连载)

相关推荐