首页 > 编程笔记 > Java笔记

使用透明组合模式实现课程目录结构

本节以 新宝库的教程为例,设计一个教程的关系结构。比如,我们有 Java 入门教程、SSM教程、Java设计模式、源码分析、软技能等,而 Java 设计模式、源码分析、软技能也可以属于 Java 架构师系列教程包,每个教程的定价都不一样。但是,这些教程不论怎么组合,都有一些共性,而且是整体和部分的关系,所以可以用组合模式来设计。

首先创建一个顶层的抽象组件 CourseComponent。
public abstract class CourseComponent {

    public void add(CourseComponent Component){
        throw new UnsupportedOperationException("不支持添加操作");
    }

    public void remove(CourseComponent Component){
        throw new UnsupportedOperationException("不支持删除操作");
    }

    public String getName(CourseComponent Component){
        throw new UnsupportedOperationException("不支持获取名称操作");
    }

    public double getPrice(CourseComponent Component){
        throw new UnsupportedOperationException("不支持获得价格操作");
    }

    public void print(){
        throw new UnsupportedOperationException("不支持打印操作");
    }
}
把所有可能用到的方法都定义到这个顶层的抽象组件中,但是不写任何逻辑处理的代码,而是直接抛异常。

可能这里有些小伙伴会有疑惑,为什么不用抽象方法?因为用了抽象方法,其子类就必须实现,这样便体现不出各子类的细微差异了。所以子类继承此抽象类后,只需要重写有差异的方法覆盖父类的方法即可。

然后分别创建教程 Course 类和教程包 CoursePackage 类。创建 Course 类的代码如下。
public class Course extends CourseComponent {

    private String name;
    private double price;

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

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

    @Override
    public double getPrice(CourseComponent Component) {
        return this.price;
    }

    @Override
    public void print() {
        System.out.println(name + "(¥" + price + "元)");
    }
}
创建 CoursePackage 类的代码如下。
import java.util.ArrayList;
import java.util.List;

public class CoursePackage extends CourseComponent {
    private List<CourseComponent> itmes = new ArrayList<CourseComponent>();

    private String name;
    private Integer level;

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

    @Override
    public void add(CourseComponent Component) {
        itmes.add(Component);
    }

    @Override
    public void remove(CourseComponent Component) {
        itmes.remove(Component);
    }

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

    @Override
    public void print() {
        System.out.println(this.name);

        for (CourseComponent c : itmes) {
            if (this.level != null) {
                for (int i = 0; i < this.level; i++) {
                    System.out.print("   ");
                }
                for (int i = 0; i < this.level; i++) {
                    if (i == 0) {
                        System.out.print("+");
                    }
                    System.out.print("-");
                }
            }
            c.print();
        }
    }
}
最后编写客户端测试代码。
public class Test {
    public static void main(String[] args) {
        System.out.println("============透明的组合模式==============");

        CourseComponent javaBase = new Course("Java入门教程", 8280);
        CourseComponent ssm = new Course("SSM", 5000);

        CourseComponent packageCourse = new CoursePackage("Java架构师教程", 2);

        CourseComponent design = new Course("Java设计模式", 1500);
        CourseComponent source = new Course("源码分析", 2000);
        CourseComponent softSkill = new Course("软技能", 3000);

        packageCourse.add(design);
        packageCourse.add(source);
        packageCourse.add(softSkill);

        CourseComponent catalog = new CoursePackage("新宝库教程目录", 1);
        catalog.add(javaBase);
        catalog.add(ssm);
        catalog.add(packageCourse);

        catalog.print();
    }
}
运行结果如下所示。

============透明的组合模式==============
新宝库教程目录
   +-Java入门教程(¥8280.0元)
   +-SSM(¥5000.0元)
   +-Java架构师教程
      +--Java设计模式(¥1500.0元)
      +--源码分析(¥2000.0元)
      +--软技能(¥3000.0元)

透明组合模式把所有公共方法都定义在 Component 中,这样客户端就不需要区分操作对象是叶子节点还是树枝节点。但是,叶子节点会继承一些它不需要(管理子类操作的方法)的方法,这与设计模式的接口隔离原则相违背。

所有教程

优秀文章