组合模式

组合模式

定义

1. 将对象组合成树形结构以表示“部分-总体”的层次结构。
2. 组合模式是客户端对单个对象和组合对象保持一致的方式处理。

类型

结构型

适用场景

1. 但愿客户端能够忽略组合对象与单个对象的差别是
2. 处理一个树形结构时

优势

1. 清楚地定义分层次的复杂对象，表示对象的所有或部分层次。
2. 让客户端忽略了层次的差别，方便对整个层次结构进行控制。
3. 简化客户端代码

下面开始写代码，咱们首先假设一个业务场景，假设咱们有一个课程，这个课程里面有不少课程包括java课程python等等，咱们定义一个抽象类，让这些课程类继承这个抽象类，那么咱们就能够认为这些课程是一个对象。

public abstract class CatalogComponent {
    public void add(CatalogComponent catalogComponent){
        throw new UnsupportedOperationException("不支持添加操做");
    }

    public void remove(CatalogComponent catalogComponent){
        throw new UnsupportedOperationException("不支持删除操做");
    }


    public String getName(CatalogComponent catalogComponent){
        throw new UnsupportedOperationException("不支持获取名称操做");
    }


    public double getPrice(CatalogComponent catalogComponent){
        throw new UnsupportedOperationException("不支持获取价格操做");
    }


    public void print(){
        throw new UnsupportedOperationException("不支持打印操做");
    }


}

这个就是抽象方法，至于咱们为何要在这个抽象类中抛出异常呢？这个问题咱们等写完了其余的类再解答。

public class Course extends CatalogComponent {
    private String name;
    private double price;

    public Course(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String getName(CatalogComponent catalogComponent) {
        return this.name;
    }

    @Override
    public double getPrice(CatalogComponent catalogComponent) {
        return this.price;
    }

    @Override
    public void print() {
        System.out.println("Course Name:"+name+" Price:"+price);
    }

}

这是一个课程类，咱们继承了抽象类，有价格和名称两个属性。

public class CourseCatalog extends CatalogComponent {
    private List<CatalogComponent> items = new ArrayList<CatalogComponent>();
    private String name;
    private Integer level;


    public CourseCatalog(String name,Integer level) {
        this.name = name;
        this.level = level;
    }

    @Override
    public void add(CatalogComponent catalogComponent) {
        items.add(catalogComponent);
    }

    @Override
    public String getName(CatalogComponent catalogComponent) {
        return this.name;
    }

    @Override
    public void remove(CatalogComponent catalogComponent) {
        items.remove(catalogComponent);
    }

    @Override
    public void print() {
        System.out.println(this.name);
        for(CatalogComponent catalogComponent : items){
            if(this.level != null){
                for(int  i = 0; i < this.level; i++){
                    System.out.print("  ");
                }
            }
            catalogComponent.print();
        }
    }

}

这个是目录类，有两个属性，层级和名称。这个是咱们看到代码，就解释一下为何在抽象类中要抛出异常，由于咱们的子类有的功能咱们都重写了抽象类的方法，可是若是没有重写的方法也是被继承了的。若是这时候被调用了，子类是没有这个功能我但愿不被调用因此就直接抛异常。最后咱们看看测试类的代码。

public class CompositeTest {
    public static void main(String[] args) {
        CatalogComponent linuxCourse = new Course("Linux课程",11);
        CatalogComponent windowsCourse = new Course("Windows课程",11);

        CatalogComponent javaCourseCatalog = new CourseCatalog("Java课程目录",2);

        CatalogComponent mmallCourse1 = new Course("Java设计模式一",55);
        CatalogComponent mmallCourse2 = new Course("Java设计模式二",66);
        CatalogComponent designPattern = new Course("Java设计模式三",77);

        javaCourseCatalog.add(mmallCourse1);
        javaCourseCatalog.add(mmallCourse2);
        javaCourseCatalog.add(designPattern);

        CatalogComponent imoocMainCourseCatalog = new CourseCatalog("课程主目录",1);
        imoocMainCourseCatalog.add(linuxCourse);
        imoocMainCourseCatalog.add(windowsCourse);
        imoocMainCourseCatalog.add(javaCourseCatalog);

        imoocMainCourseCatalog.print();
    }
}

组合模式最大的问题在于要花代码去判断究竟是那一个类，由于咱们在使用的时候都是使用了父类对象。