JAVA 组合模式

文章目录

介绍

组合模式

实现

介绍

描述

组合模式设计模式属于结构型模式，是用于把一组相似的对象当作一个单一的对象，将对象组合成树形结构以表示“部分-整体”的层次结构。

特点

优点：高层模块调用简单，且节点可以任意增加。

缺点：难以限定新构建的类型。

实现原理

1. 抽象组件(Component)角色：为组合对象和叶子对象声明公共的接口，让客户端可以通过这个接口来访问和管理整个对象树，并可以为这些定义的接口提供缺省的实现。

2. 组合对象(Composite)角色：通常会存储子组件(组合对象、叶子对象)，定义包含子组件的那些组件的行为，并实现在抽象组件中定义的与子组件有关的操作。

3. 叶子对象(Leaf)角色：定义和实现叶子对象的行为，并且它不再包含其他的子节点对象。

适用

1. 表示对象的部分-整体层次结构（树形结构）。

2. 需要遍历组织机构。

组合模式

实现

描述学校-学院-系之间的树形关系。

第一步：新建抽象组件类Component，描述公共接口。

public abstract class Component {
    private String name;
    private String des;

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

    public void add(Component component) {
        throw new UnsupportedOperationException();
    }

    public void remove(Component component) {
        throw new UnsupportedOperationException();
    }

    // 抽象实现
    public abstract void print();

    public String getName() {
        return name;
    }

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

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }
}

第二步：新建组合对象School、Academy实现抽象组件中的行为，叶子对象为Department（不在包含其他对象）。

// 学校
public class School extends Component{
    // 添加抽象接口（代表学院）
    private List<Component> components = new ArrayList<>();

    public School(String name,String des) {
        super(name,des);
    }

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

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

    @Override
    public void print() {
        System.out.println("=== " + getName() +"学校 ===");
        for (Component c:components){
            c.print();
        }
    }
}

// 学院
public class Academy extends Component{
    // 添加抽象接口（代表系）
    private List<Component> components = new ArrayList<>();

    public Academy(String name,String des) {
        super(name,des);
    }

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

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

    @Override
    public void print() {
        System.out.println("=== " + getName() +"系 ===");
        for (Component c:components){
            c.print();
        }
    }

}
// 系
public class Department extends Component{

    public Department(String name,String des) {
        super(name,des);
    }

    @Override
    public void print() {
        System.out.println(getName() );
    }
}

第三步：测试。

public class Test {
    public static void main(String[] args) {
        Component school = new School("学校—1","排名第一");
        Component academy_1 = new Academy("机电","机电学院很好");
        Component academy_2 = new Academy("软件工程","软件工程学院很好");
        academy_1.add(new Department("机电—1","1号"));
        academy_1.add(new Department("机电—2","2号"));
        academy_2.add(new Department("软件工程—1","1号"));
        academy_2.add(new Department("软件工程—2","2号"));

        school.add(academy_1);
        school.add(academy_2);
        school.print();
        /*
          === 学校—1学校 ===
          === 机电系 ===
          机电—1
          机电—2
          === 软件工程系 ===
          软件工程—1
          软件工程—2
        */
    }
}