Class hierachy help required

Question

I have some classes.
1 base
2 container
container is a base. container can contain bases. So container can contain other containers.
Now I add a 3rd class
3 system
a system is a form of container. it can contain base classes. But in fact a system can not contain another system, and a system can not be contained by a system. Does this in effect mean my system is actually NOT a container? Should it merely be composed of a container, but not actually be a container?
need guidance.

Answer 1

Have an abstract class that implements common (public
and protected) methods, and all other classes (base,
container, system and any other you may come across in
future) can be derived from these class.This does not prevent Containers containing Systems. Whether the classes that implement Container and Containee have common functionality independent of that association shouldn't effect the design of the interface types, eginterface Container { Containable contained (int index) ; ... }
interface Containable { Container container ();}
abstract class SomeCommonBase {}
abstract class AbstractContainer extends SomeCommonBase implements Container {}
class System extends AbstractContainer {}
class ABranchComponent extends AbstractContainer implements Containable {}
class ALeafComponent extends SomeCommonBase implements Containable {} But much cleaner implementation can be achieved thru Decorator design pattern. A calss (I don't mean super
class here) should implement all common functionality and dynamically at runtime add the features that you
need (well that's the essence of Decorator pattern), for which you can use some kind of creational pattern
(some variation of factory or builder pattern)If you do that you lose static type checking. It is also harder to write decorators that stop you doing something, like adding a system as a subcomponent, than those which add functionality. As GHJV says, a Decorator is used to 'attach additional responsibilities to an object dynamically.' It isn't an additional responsibility on one particular pig that it mustn't fly; it's intrinsic to the class of things that are pigs that they lack that capability. Systems lack the containable capability.
Pete