设计模式--组合模式

设计模式--组合模式

1 概述

---

1.1 定义
组合模式(Composite Design)将对象组合成树形结构来表现"整体/部分"层次结构。组合能让客户端以一致的方式处理个别对象以及对象组合。

1.2 应用场景
维护和展示部分-整体的层次结构，如Unix中的树形文件系统。
客户端可以忽略复杂的层次结构，使用统一的方式去操作层次结构中的所有对象，也可以使用组合模式。
简单的可以说：树状结构并且其各个节点(根、枝、叶)有共同的行为，就可以使用组合模式。
1.3 类图

 

组合模式涉及的角色如下：

1. Component抽象组件角色：定义参加组合对象的方法(一些方法Leaf不实现)。
2. Composite组合角色：作用是与Leaf(树叶)节点形成一个树形结构。
3. Leaf叶子角色：是遍历的最小单位。

2 详解

public abstract class Component {
    // 个体与整体都具有的行为
    public void operate(){
        System.out.println("Common operation");
    }
    // 添加一个叶子或者组合
    public abstract void add(Component component) throws UnsupportedOperationException;

    // 移除一个叶子或者组合
    public abstract boolean remove(Component component) throws UnsupportedOperationException;

    // 获得其分支下的所有叶子和组合
    public abstract List<Component> getChildren() throws UnsupportedOperationException;
}

public class Composite extends Component {
    // 容器构件
    private List<Component> componentList = new ArrayList<>();

    @Override
    public void add(Component component) throws UnsupportedOperationException {
            componentList.add(component);
    }

    @Override
    public boolean remove(Component component) throws UnsupportedOperationException {
        return componentList.remove(component);
    }

    @Override
    public List<Component> getChildren() throws UnsupportedOperationException {
        return componentList;
    }
}

public class Leaf extends Component {
    @Override
    public void add(Component component) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean remove(Component component) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    @Override
    public List<Component> getChildren() throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }
}

public class Client {
    public static void main(String[] args) {
        Component root = new Composite();
        Component brance = new Composite();
        Component leaf = new Leaf();
        root.add(brance);
        brance.add(leaf);
    }
    // 递归遍历该树
    public static void display(Component root) {
        for(Component component : root.getChildren()) {
            // 树枝节点
            if(component instanceof Composite) {
                display(component);
            }else {
                // 叶子节点
                component.operate();
            }
        }
    }
}

3 应用

简单的模拟unix的文件系统

public abstract class IFile {
    private String name;
    // 父类IFile
    private IFile parentIFile;

    IFile(String name) {
        this.name = name;
    }

    public String getName(){
        return name;
    }

    // 删除其自己
    public abstract boolean remove();

    // 获得其分支文件或者文件名
    public abstract IFile getIFile(String name) throws UnsupportedOperationException;

    // 创建文件
    public abstract void createFile(String name) throws UnsupportedOperationException;

    // 创建文件夹
    public abstract void createFolder(String name) throws UnsupportedOperationException;

    // 删除其分支文件
    public abstract boolean deleteFile(String name) throws UnsupportedOperationException;

    // 删除其分支文件夹
    public abstract boolean deleteFolder(String name) throws UnsupportedOperationException;

    // 获得其分支的文件或文件夹
    public abstract Set<IFile> getChildren() throws UnsupportedOperationException;

    // 设置父类文件
    public void setParentIFile(IFile parentIFile) {
        this.parentIFile = parentIFile;
    }

    // 获得父类文件
    public IFile getParentIFile() {
        return parentIFile;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj == this) {
            return true;
        }
        if(obj instanceof IFile) {
            IFile iFile = (IFile) obj;
            return Objects.equals(iFile.getName(), getName());
        }
        return false;
    }

    @Override
    public int hashCode() {
        return name.hashCode();
    }

    @Override
    public String toString() {
        return name;
    }
}

public class Folder extends IFile {
    private Set<IFile> files = new HashSet<>();

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

    @Override
    public boolean remove() {
        System.out.println("删除文件夹: " + getName());
        IFile parent = getParentIFile();
        return parent.deleteFolder(getName());
    }

    @Override
    public IFile getIFile(String name) throws UnsupportedOperationException {
        for(IFile iFile : files) {
            if(iFile.getName().equals(name)) {
                return iFile;
            }
        }
        return null;
    }

    @Override
    public void createFile(String name) throws UnsupportedOperationException {
        IFile file = new File(name);
        file.setParentIFile(this);
        files.add(file);
    }

    @Override
    public void createFolder(String name) throws UnsupportedOperationException {
        IFile fileFolder = new Folder(name);
        fileFolder.setParentIFile(this);
        files.add(fileFolder);
    }

    @Override
    public boolean deleteFile(String name) throws UnsupportedOperationException {
        return files.remove(new File(name));
    }

    @Override
    public boolean deleteFolder(String name) throws UnsupportedOperationException {
        return files.remove(new Folder(name));
    }

    @Override
    public Set<IFile> getChildren() throws UnsupportedOperationException {
        return files;
    }
}

public class File extends IFile {

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

    @Override
    public boolean remove() {
        System.out.println("删除文件夹: " + getName());
        IFile parent = getParentIFile();
        return parent.deleteFile(getName());
    }

    @Override
    public void createFile(String name) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    @Override
    public void createFolder(String name) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean deleteFile(String name) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean deleteFolder(String name) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    @Override
    public Set<IFile> getChildren() throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }

    @Override
    public IFile getIFile(String name) throws UnsupportedOperationException {
        throw new UnsupportedOperationException();
    }
}

public class Client {
    public static void main(String[] args) {
        IFile root = new Folder("/");
        root.createFolder("user");
        root.createFolder("net");
        root.createFile("root.txt");

        IFile user = root.getIFile("user");
        user.createFolder("picture");
        user.createFolder("music");
        IFile picture = user.getIFile("picture");
        picture.createFile("flower.png");
        picture.createFile("book.png");
        IFile music = user.getIFile("music");
        music.createFile("hello.mp3");

        IFile net = root.getIFile("net");
        net.createFolder("config");
        net.createFile("setting.txt");

        display(null, root);
    }
    // 递归遍历
    public static void display(String prefix, IFile root) {
        if(prefix == null) {
            prefix = "";
        }
        System.out.println(prefix + root);
        for(IFile iFile : root.getChildren()) {
            if(iFile instanceof Folder) {
                display(prefix + "--", iFile);
            }
            if(iFile instanceof File) {
                System.out.println(prefix + "--" + iFile);
            }
        }
    }
}output:
/
--root.txt
--net
----setting.txt
----config
--user
----music
------hello.mp3
----picture
------flower.png
------book.png