设计模式系统回顾（13）组合模式

目的：实现一些类似整体与部分，树形结构的东西

1.透明模式

public abstract class GkAbstractCourse {
    public void addChild(GkAbstractCourse course){//添加子节点
        System.out.println("不支持添加操作");
    }

    public String getName() throws Exception {//获取当前节点名称
        throw new Exception("不支持获取名称");
    }

    public void info() throws Exception{//获取高考科目信息
        throw new Exception("不支持查询信息操作");
    }
}

public class LeafCource extends GkAbstractCourse {
    private String name;//课程名称
    private String score;//课程分数

    public LeafCource(String name, String score) {
        this.name = name;
        this.score = score;
    }

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

    @Override
    public void info() {
        System.out.println("课程:" + this.name + ",分数:" + score);
    }
}

public class BranchCource extends GkAbstractCourse{
    private List<GkAbstractCourse> courseList = new ArrayList<>();
    private String name;//科目名称
    private int level;//层级

    public BranchCource(String name, int level) {
        this.name = name;
        this.level = level;
    }

    @Override
    public void addChild(GkAbstractCourse course) {//添加子课程
        courseList.add(course);
    }

    @Override
    public String getName(){//获取课程名称
        return this.name;
    }

    @Override
    public void info() throws Exception {//打印课程信息
       System.out.println("课程:" + this.name);
       for (GkAbstractCourse course : courseList){
           for (int i=0;i<level;i++){//根据层级关系打印空格，这样打印结果可以明显看出层级关系
               System.out.print("  ");
           }
           System.out.print(">");
           course.info();
       }
    }
}


public class TestTransparency {
    public static void main(String[] args) throws Exception {
        GkAbstractCourse ywCourse = new LeafCource("语文","150");
        GkAbstractCourse sxCourse = new LeafCource("数学","150");
        GkAbstractCourse yyCourse = new LeafCource("英语","150");

        GkAbstractCourse wlCourse = new LeafCource("物理","110");
        GkAbstractCourse hxCourse = new LeafCource("化学","100");
        GkAbstractCourse swCourse = new LeafCource("生物","90");

        GkAbstractCourse lzCourse = new BranchCource("理综",2);
        lzCourse.addChild(wlCourse);
        lzCourse.addChild(hxCourse);
        lzCourse.addChild(swCourse);

        GkAbstractCourse gkCourse = new BranchCource("理科高考",1);
        gkCourse.addChild(ywCourse);
        gkCourse.addChild(sxCourse);
        gkCourse.addChild(yyCourse);

        gkCourse.addChild(lzCourse);
        gkCourse.info();
        swCourse.addChild(ywCourse);//这里会报错，因为生物已经是叶子节点，无法继续添加子节点
    }
}

透明模式就是因为父类将所有方法都定义好了，对各个子类完全透明。这样做的好处是客户端无需分辨当前对象是属于树枝节点还是叶子节点，因为它们具备了完全一致的接口，但是叶子结点获得了不属于他的方法，违背接口隔离性

2.安全模式

public abstract class GkAbstractCourse {
    protected String name;//课程名称
    protected String score;//课程分数

    public GkAbstractCourse(String name, String score) {
        this.name = name;
        this.score = score;
    }

    public abstract void info();//获取课程信息
}

public class LeafCource extends GkAbstractCourse {
    public LeafCource(String name, String score) {
        super(name,score);
    }

    @Override
    public void info() {//获取课程信息
        System.out.println("课程:" + this.name + ",分数:" + this.score);
    }
}

public class BranchCource extends GkAbstractCourse{
    private List<GkAbstractCourse> courseList = new ArrayList<>();//子课程
    private int level;//层级

    public BranchCource(String name, String score, int level) {
        super(name,score);
        this.level = level;
    }

    public void addChild(GkAbstractCourse course) {//添加子课程
        courseList.add(course);
    }

    @Override
    public void info() {//打印课程信息
       System.out.println("课程:" + this.name + ",分数：" + this.score);
       for (GkAbstractCourse course : courseList){
           for (int i=0;i<level;i++){//根据层级关系打印空格，这样打印结果可以明显看出层级关系
               System.out.print("  ");
           }
           System.out.print(">");
           course.info();
       }
    }
}

public class TestSafe {
    public static void main(String[] args) throws Exception {
        LeafCource ywCourse = new LeafCource("语文","150");
        LeafCource sxCourse = new LeafCource("数学","150");
        LeafCource yyCourse = new LeafCource("英语","150");

        LeafCource wlCourse = new LeafCource("物理","110");
        LeafCource hxCourse = new LeafCource("化学","100");
        LeafCource swCourse = new LeafCource("生物","90");

        BranchCource lzCourse = new BranchCource("理综","300",2);
        lzCourse.addChild(wlCourse);
        lzCourse.addChild(hxCourse);
        lzCourse.addChild(swCourse);

        BranchCource gkCourse = new BranchCource("理科高考","750",1);
        gkCourse.addChild(ywCourse);
        gkCourse.addChild(sxCourse);
        gkCourse.addChild(yyCourse);

        gkCourse.addChild(lzCourse);
        gkCourse.info();
    }
}

** 区别：**
叶子节点不具备 addChild 功能，即叶子结点只有属于自己的方法
适用场景
组合模式一般应用在有层级关系的场景，最经典的就是树形菜单、文件和文件夹的管理等。