On 05/11/2010 09:04, Yakov Gerlovin wrote:
"is a" and "has a" are rules that helps to build a OO design.
('private', 'protected' and 'public' are access specifiers and are
explained above)
"is a" means that some class B is (also) A. This helps you to figure
whether inheritance of B from A makes any sense.
For example, a Cat *is a*(n) Animal, so it would be logically correct
to have a base class Animal and a class Cat that is derived from it.
On the other hand, you may have a class Tail. Although Animals usually
have tail animal is not a tail, but rather animal *has a* tail.
"has a" mean that class B contains class A, so in our example class
Animal contains an instance of class Tail.
my 2 cents
Sadly, "is a implies public inheritance" isn't actually a rule that
helps you that much. For instance, a square is a rectangle whose width
and height are equal, but it doesn't tend to make sense to have a class
Square derive from a class Rectangle (depends on the specific design,
but on the whole). The Liskov Substitution Principle (LSP) -- that you
must be able to use an instance of the subtype anywhere that an instance
of the supertype is expected -- is a much better rule, because it makes
it clear why it's unwise to do things like this:
class Rectangle
{
int width, height;
//...
public:
virtual ~Rectangle()
{}
void resize(int newWidth, int newHeight)
{
//...
}
};
class Square : public Rectangle
{
//...
};
Here, calling resize with a separate width and height on a Square makes
no sense -- all you end up with is a way for users to break Square's
invariant, namely that width == height.
Or you could argue that having a resize member-function makes no sense.