Beautiful Architecture

Problems

Public inheritance means “is-a.” That requires careful thinking from the part of the programmer to come up with class hierarchies that really fit this pattern. If you have a class with a method and a subclass where you realize that method makes no sense, it is beyond the scope of public inheritance, and it should be a sign of bad design. Languages, however, prove accommodating.

In C++, you can get away with it by making the nonsensical method either return an error or throw an exception. The prototypical example concerns birds (Meyers 2005, item 32):

class Bird {
public:
    virtual void fly();   // birds can fly
    // ...
};

class Penguin: public Bird {    // penguins are birds
public:
    virtual void fly() { error("Attempt to make a penguin fly!"); }
    // ...
};

C++ programmers may alternatively hide the offending method:

class Base {
public:
    virtual void f()=0;
};

class Derived: public Base {
private:
    virtual void f() {
    }
};

So, Derived is no longer an abstract class, but it still does not have an f() function that can be of any use. Such shenanigans are to be avoided.

In Java, you can get away with it again by returning an error or throwing an exception; you can also making the nonsensical method abstract in the subclass, thus making the class hierarchy abstract from that point downward until you remake the method concrete. Again, such shenanigans are to be avoided.

The usual way to design around the problem of inapplicable or irrelevant methods in a class hierarchy is to redesign that hierarchy. ...