设计模式之组合模式（卷八）

设计模式之组合模式。

0x00 概述

将多个对象组合成一个整体，在该模式下，对简单对象（叶子节点）和复杂对象（树枝节点）具有相同的操作。它的组成部分如下。

  • Component：在抽象构件中定义了叶子节点和树枝节点的共同方法。
  • Leaf：叶子结点没有子节点，实现了抽象构建中的行为。
  • Composite：树枝节点存在子节点，实现了对子节点的增加、删除、访问操作。

0x01 示例

以电脑中文件夹为例。

抽象构件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.kkk.pattern.Composite;

import java.util.Objects;

/**
 * Created by z3jjlzt on 2018/1/8.
 */
public abstract class Component {
    protected String name;

    public Component() {
    }

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

    public abstract void display();

    public abstract void removeChild(Component c);

    public abstract void addChild(Component c);
//省略equals和hashcode
}

文件夹类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.kkk.pattern.Composite;

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

/**
 * Created by z3jjlzt on 2018/1/8.
 */
public class Folder extends Component{
    private List<Component> lst = new ArrayList<>();

    public Folder(String name) {
        super(name);
    }

    @Override
    public void display() {
        lst.forEach(x -> {
            System.out.print(name + "/");
            x.display();
        });
    }

    @Override
    public void removeChild(Component component) {
        lst.remove(component);
    }

    @Override
    public void addChild(Component component) {
        lst.add(component);
    }
}

文件类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.kkk.pattern.Composite;

/**
 * Created by z3jjlzt on 2018/1/8.
 */
public class File extends Component{

    public File(String name) {
        super(name);
    }

    @Override
    public void display() {
        System.out.println(name);
    }

    @Override
    public void removeChild(Component c) {
        System.out.println();
    }

    @Override
    public void addChild(Component c) {
        System.out.println();
    }
}

客户端类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com.kkk.pattern.Composite;

/**
 * Created by z3jjlzt on 2018/1/8.
 */
public class Client {
    public static void main(String[] args) {
        Component root = new Folder("C盘");
        Component f1 = new File("xx.jpg");
        Component f2 = new File("ss.mp4");
        Component fo1 = new Folder("script");
        Component f3 = new File("Test.sql");
        root.addChild(f1);
        root.addChild(f2);
        root.addChild(fo1);
        fo1.addChild(f3);
        root.display();
        fo1.display();
        fo1.removeChild(new File("Test.sql"));
        fo1.display();
    }
}

结果：
C盘/xx.jpg
C盘/ss.mp4
C盘/script/Test.sql
script/Test.sql

0xff 总结

  • 优点：不同对象的操作统一处理，简化了客户端的处理逻辑。
  • 缺点：叶子节点需要实现一些不必要的空方法。
  • 适用场景：客户端忽略组合对象与单个对象的差异，统一地使用组合结构中的所有对象。