Java设计模式之《组合模式》及应用场景

　　组合模式，就是在⼀个对象中包含其他对象，这些被包含的对象可能是终点对象（不再包含别的对象），也有可能是⾮终点对象（其内部还包含其他对象，或叫组对象），我们将对象称为节点，即⼀个根节点包含许多⼦节点，这些⼦节点有的不再包含⼦节点，⽽有的仍然包含⼦节点，以此类推。很明显，这是树形结构，终结点叫叶⼦节点，⾮终节点（组节点）叫树枝节点，第⼀个节点叫根节点。同时也类似于⽂件⽬录的结构形式：⽂件可称之为终节点，⽬录可称之为⾮终节点（组节点）。1、我们⾸先来看⼀个⽬录结构的普通实现：⽬录节点：Noder

1 import java.util.ArrayList; 2 import java.util.List; 3 /**

4 * ⽬录节点 5 * 包含：

6 * 1、⽬录名

7 * 2、下级⽂件列表 8 * 3、下级⽬录列表 9 * 4、新增⽂件⽅法10 * 5、新增⽬录⽅法

11 * 6、显⽰下级内容⽅法12 */

13 public class Noder {

14 String nodeName;//⽬录名15 //通过构造器为⽬录命名

16 public Noder(String nodeName){17 this.nodeName = nodeName;18 }

19 List nodeList = new ArrayList();//⽬录的下级⽬录列表20 List fileList = new ArrayList();//⽬录的下级⽂件列表21 //新增下级⽬录

22 public void addNoder(Noder noder){23 nodeList.add(noder);24 }

25 //新增⽂件

26 public void addFiler(Filer filer){27 fileList.add(filer);28 }

29 //显⽰下级⽬录及⽂件30 public void display(){

31 for(Noder noder:nodeList){

32 System.out.println(noder.nodeName);33 noder.display();//递归显⽰⽬录列表34 }

35 for(Filer filer:fileList){36 filer.display();37 }38 }39 }

⽂件节点：Filer

1 /**

2 * ⽂件节点

3 * ⽂件节点是终节点，⽆下级节点 4 * 包含：

5 * 1、⽂件名

6 * 2、⽂件显⽰⽅法 7 */

8 public class Filer {

9 String fileName;//⽂件名

10 public Filer(String fileName){11 this.fileName = fileName;12 }

13 //⽂件显⽰⽅法

14 public void display(){

15 System.out.println(fileName);16 }17 }

测试类：Clienter

1 import java.io.File; 2

3 public class Clienter {

4 public static void createTree(Noder node){ 5 File file = new File(node.nodeName); 6 File[] f = file.listFiles();

7 for(File fi : f){ 8 if(fi.isFile()){

9 Filer filer = new Filer(fi.getAbsolutePath());10 node.addFiler(filer);11 }

12 if(fi.isDirectory()){

13 Noder noder = new Noder(fi.getAbsolutePath());14 node.addNoder(noder);

15 createTree(noder);//使⽤递归⽣成树结构16 }17 }18 }

19 public static void main(String[] args) {20 Noder noder = new Noder(\"E://ceshi\");21 createTree(noder);//创建⽬录树形结构22 noder.display();//显⽰⽬录及⽂件23 }24 }

运⾏结果：

E:\\ceshi\\⽬录1

E:\\ceshi\\⽬录1\\⽬录3E:\\ceshi\\⽬录1\\⽂件2.txtE:\\ceshi\\⽬录2

E:\\ceshi\\⽬录2\\⽂件3.txtE:\\ceshi\\⽂件1.txt

2、组合模式

　　从上⾯的代码中可以看出，我们分别定义了⽂件节点对象与⽬录节点对象，这是因为⽂件与⽬录之间的操作不同，⽂件没有下级节点，⽽⽬录可以有下级节点，但是我们能不能这么想：既然⽂件与⽬录都是可以作为⼀个节点的下级节点⽽存在，那么我们可不可以将⼆者抽象为⼀类对象，虽然⼆者的操作不同，但是我们可以在实现类的⽅法实现中具体定义，⽐如⽂件没有新增下级节点的⽅法，我们就可以在⽂件的这个⽅法中抛出⼀个异常，不做具体实现，⽽在⽬录中则具体实现新增操作。显⽰操作⼆者都有，可以各⾃实现。⽽且由于我们将⽂件与⽬录抽象为⼀个类型，那么结合多态我们可以进⾏如下实现：抽象类：Node

1 /**

2 * 将⽂件与⽬录统⼀看作是⼀类节点，做⼀个抽象类来定义这种节点，然后以其实现类来区分⽂件与⽬录，在实现类中分别定义各⾃的具体实现内容 3 */

4 public abstract class Node { 5 protected String name;//名称 6 //构造器赋名

7 public Node(String name){ 8 this.name = name; 9 }

10 //新增节点：⽂件节点⽆此⽅法，⽬录节点重写此⽅法11 public void addNode(Node node) throws Exception{12 throw new Exception(\"Invalid exception\");13 }

14 //显⽰节点：⽂件与⽬录均实现此⽅法15 abstract void display();16 }

⽂件实现类：Filter

1 /**

2 * 实现⽂件节点 3 */

4 public class Filer extends Node { 5 //通过构造器为⽂件节点命名 6 public Filer(String name) { 7 super(name); 8 }

9 //显⽰⽂件节点10 @Override

11 public void display() {

12 System.out.println(name);13 }14 }

⽬录实现类：Noder

1 import java.util.*; 2 /**

3 * 实现⽬录节点 4 */

5 public class Noder extends Node {

6 List nodeList = new ArrayList();//内部节点列表（包括⽂件和下级⽬录）

7 //通过构造器为当前⽬录节点赋名 8 public Noder(String name) { 9 super(name);10 }

11 //新增节点

12 public void addNode(Node node) throws Exception{13 nodeList.add(node);14 }

15 //递归循环显⽰下级节点16 @Override17 void display() {

18 System.out.println(name);19 for(Node node:nodeList){20 node.display();21 }22 }23 }

测试类：Clienter

1 import java.io.File; 2

3 public class Clienter {

4 public static void createTree(Node node) throws Exception{ 5 File file = new File(node.name); 6 File[] f = file.listFiles(); 7 for(File fi : f){ 8 if(fi.isFile()){

9 Filer filer = new Filer(fi.getAbsolutePath());10 node.addNode(filer);11 }

12 if(fi.isDirectory()){

13 Noder noder = new Noder(fi.getAbsolutePath());14 node.addNode(noder);

15 createTree(noder);//使⽤递归⽣成树结构16 }17 }18 }

19 public static void main(String[] args) {20 Node noder = new Noder(\"E://ceshi\");21 try {

22 createTree(noder);23 } catch (Exception e) {24 e.printStackTrace();25 }

26 noder.display();27 }28 }

E://ceshi

E:\\ceshi\\⽂件1.txtE:\\ceshi\\⽬录1

E:\\ceshi\\⽬录1\\⽂件2.txtE:\\ceshi\\⽬录1\\⽬录3E:\\ceshi\\⽬录2

E:\\ceshi\\⽬录2\\⽂件3.txt

　　从上述实现中可以看出：所谓组合模式，其实说的是对象包含对象的问题，通过组合的⽅式（在对象内部引⽤对象）来进⾏布局，我认为这种组合是区别于继承的，⽽另⼀层含义是指树形结构⼦节点的抽象（将叶⼦节点与数枝节点抽象为⼦节点），区别于普通的分别定义叶⼦节点与数枝节点的⽅式。3、组合模式应⽤场景

　　这种组合模式正是应树形结构⽽⽣，所以组合模式的使⽤场景就是出现树形结构的地⽅。⽐如：⽂件⽬录显⽰，多及⽬录呈现等树形结构数据的操作。