为此使用复合模式是个好主意吗？

Question

我正在编写代码来制作自定义电视分时段。

所以我需要制作这个数据表：

一个dayParting可以有多个DayParts
一个DayPart可以有多个TimeParts.
DayPart 和 DayParting 有开始时间和结束时间
TimePart只有一个小时，有节目到时候放映

第一次我只是使用列表来完成工作，但我开始认为这是太 "not open to extension" 和太 "to implementation and not to intarface" 的解决方案，所以我开始寻找替代解决方案问题。

我在考虑使用复合模式，该模式提供了灵活性，开放了扩展并允许我统一处理复合对象和单个对象。

所以，我认为我的类应该是：

class AbstractDayparting{ //
}
class DayParting extends AbstractDayparting{ //Composite
}
class TimePart extends AbstractDayparting{ // Leaf
}

我觉得我可以使用复合模式，但我有两个不好的感觉：

我的自定义复合图案很漂亮 "rigid" 因为叶子总是在最低处等级。
我需要从特定级别获取对象。

我不知道 (1) 是否合适，以及 (2) 我不知道如何获取特定类型的所有复合对象（例如：所有 DayParts）。

我在强制模式？这个问题有更好的解决方案吗？

Answer 1

My custom composite pattern is pretty "rigid" because the leafs are always in the lowest level.

一个A有多个B，一个B有多个C。自然 C 处于最低级别。没什么不对的。

I need to get objects from a particular level.

由于 DayPart 属于 DayParting，您调用 DayParting.getDayParts() 获取所有 DayParts。示例代码：

    /**
     * A parting is a period of time.
     */
    abstract class Parting {
      final int beginingHour;
      final int endHour;
      public Parting(int beginingHour, int endHour) {
        this.beginingHour = beginingHour;
        this.endHour = endHour;
      }

      public int getBeginingHour() {
        return beginingHour;
      }

      public int getEndHour() {
        return endHour;
      }
    }

    class DayParting extends Parting {
      List<DayPart> dayParts = new ArrayList<DayPart>();

      public DayParting(int beginingHour, int endHour) {
        super(beginingHour, endHour);
      }

      public List<DayPart> getDayParts() {
        return dayParts;
      }
    }

    class DayPart extends Parting {
      List<TimePart> timeParts= new ArrayList<TimePart>();

      public DayPart(int beginingHour, int endHour) {
        super(beginingHour, endHour);
      }
    }

    class TimePart extends Parting {
      public TimePart(int beginingHour) {
        super(beginingHour, beginingHour + 1); // only one hour
      }
    }

假设属于 DayParting 的所有 DayParts 具有相同的 (beginingHour,endHour)，您添加此

    class DayParting extends Parting {
      public void addDayPart() {
        dayParts.add(new DayPart(this.beginingHour, this.endHour));
      }
    }

假设属于 DayParting 的每个 DayPart 都有单独的 (beginingHour,endHour)，你添加这个

    class DayParting extends Parting {
      public void addDayPart(int beginingHour, int endHour) {
        dayParts.add(new DayPart(beginingHour, endHour));
      }
    }

问题是，DayParting 只有一种 DayPart 类型，但是有很多实例，所以它仍然是 Composite 模式。好的是，你以后可以添加更多的类型，变化很小。

    class VariantDayPart extends DayPart {
      public VariantDayPart(int beginingHour, int endHour) {
        super(beginingHour, endHour);
      }
    }

为此使用复合模式是个好主意吗？

Is a good idea use composite pattern for this?

java

design-patterns

composite