合成设计模式

如果要将对象组织到树中，使用树来表示对象之间的关系，请考虑使用合成的设计模式。如组织结构,分类分层等等。
既然是要表示成树自然就要定一个树节点的抽象接口，每个元素需要实现该接口。
抽象接口的组成元素，通常抽象接口中包括返回当前节点的方法，获取深度和设置深度的方法。一个提供一个操作逻辑的方法。
实现类在实现抽象接口中的方法基础之上在添加自己所需要的方法。
当然最后遍历的时候需要使用树的递归遍历，添加深度是需要根据深度做区分只节点的处理，如只节点要打印空格等等。
下面掩饰一个实例，实例引用自http://www.admin5.com/article/20080804/97386.shtml


/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-2 16:13:59
* 抽象文件角色
*/
public interface IFile {
//返回自己的实例
IFile getComposite();

//某个商业方法
void sampleOperation();

//获取深度
int getDeep();

//设置深度
void setDeep(int x);

}




import java.util.Vector;

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-2 16:15:03
* 文件夹角色
*/
public class Folder implements IFile {
private String name; //文件名字
private int deep; //层级深度，根深度为0
private Vector<IFile> componentVector = new Vector<IFile>();

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

//返回自己的实例
public IFile getComposite() {
return this;
}

//某个商业方法
public void sampleOperation() {
System.out.println("执行了某个商业方法！");
}

//增加一个文件或文件夹
public void add(IFile IFile) {
componentVector.addElement(IFile);
IFile.setDeep(this.deep 1);

}

//删除一个文件或文件夹
public void remove(IFile IFile) {
componentVector.removeElement(IFile);
}

//返回直接子文件（夹）集合
public Vector getAllComponent() {
return componentVector;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getDeep() {
return deep;
}

public void setDeep(int deep) {
this.deep = deep;
}
}




/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-2 16:27:15
* 文件
*/
public class File implements IFile {
private String name; //文件名字
private int deep; //层级深度

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

//返回自己的实例
public IFile getComposite() {
return this;
}

//某个商业方法
public void sampleOperation() {
System.out.println("执行了某个商业方法！");
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getDeep() {
return deep;
}

public void setDeep(int deep) {
this.deep = deep;
}
}




import java.util.Iterator;
import java.util.Vector;

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-2 16:35:25
* 遍历树的一个测试
*/
public class Client {
public static String indentChar = "\t"; //文件层次缩进字符

public static void main(String args[]) {
new Client().test();
}

/**
* 客户端测试方法
*/
public void test() {
//根下文件及文件夹
Folder root = new Folder("树根");

Folder b1_1 = new Folder("1_枝1");
Folder b1_2 = new Folder("1_枝2");
Folder b1_3 = new Folder("1_枝3");
File l1_1 = new File("1_叶1");
File l1_2 = new File("1_叶2");
File l1_3 = new File("1_叶3");

//b1_2下的文件及文件夹
Folder b2_1 = new Folder("2_枝1");
Folder b2_2 = new Folder("2_枝2");
File l2_1 = new File("2_叶1");

//缔造树的层次关系（简单测试，没有重复添加的控制）
root.add(b1_1);
root.add(b1_2);
root.add(l1_1);
root.add(l1_2);

b1_2.add(b2_1);
b1_2.add(b2_2);
b1_2.add(l2_1);
root.add(l1_3);
root.add(b1_3);
//控制台打印树的层次
outTree(root);
}

public void outTree(Folder folder) {
System.out.println(folder.getName());
iterateTree(folder);
}

/**
* 遍历文件夹，输入文件树
*
* @param folder
*/
public void iterateTree(Folder folder) {
Vector<IFile> clist = folder.getAllComponent();
//todo:遍历之前可以对clist进行排序，这些都不是重点
for (Iterator<IFile> it = clist.iterator(); it.hasNext();) {
IFile em = it.next();
if (em instanceof Folder) {
Folder cm = (Folder) em;
System.out.println(getIndents(em.getDeep()) cm.getName());
iterateTree(cm);
} else {
System.out.println(getIndents(em.getDeep()) ((File) em).getName());
}
}
}

/**
* 文件层次缩进字符串
*
* @param x 缩进字符个数
* @return 缩进字符串
*/
public static String getIndents(int x) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < x; i ) {
sb.append(indentChar);
}
return sb.toString();
}
}

关键部分解释：
这里添加一个元素的时候，会对子元素的深度设置父类的深度+1.然后输出的时候会根据深度值输出对应的空格个数。
注意使用递归输出时要对容器进行判断，这里是文件夹，若是容器可能还会包含子元素，所以要进行下一步的递归。
容器内需要放一个集合，以便用于存放子元素