Limitations in subclasses OOP

Question

In java, what is a good way to design around a subclass that reduces the functionality of the superclass?

For example, consider the class "Man", that has the function "See" and the subclass "BlindMan" that shouldn't have that function, but should have everything else that "Man" has.

The only solution I can come up with is having an abstract class "Man", and two subclasses "SeeingMan" and "BlindMan", with SeeinMan adding a function "See".

However the problem with this solution is that if I now want to add a "DeafMan" class - what does it extend? SeeingMan? and what if that man is both deaf and blind?

Answer 1

I think you should use Composition rather than inheritance in this case, or have various subclasses that make up the human.

While I do understand your logic, a BaseClass is a contract, that guarantees all classes of that type should adhere to this behavior, having a subclass that removes the parent method is a big NO NO..

While you could throw various exceptions, I wouldn't go down that path at all. Think about it this way, say I am a developer who only needs to access Human object, I expect a certain behavior, and all of a sudden I call an interface method and get..an Exception just because I called it?? You should not be aware of the derived classes implementations and when you can or cano't call them.

Here are a few solutions:

Make Human a composition of BasicHumanFunctions, VisionSystem, etc. Then blind man would have only a few of those.

class Human {   private BasicHumanFunctions _basicFunctions; //contains breathe funcitonality.   private VisionSystem _vision; //contains see }  class BlindMan {    private BasicHumanFunctions _basicFunctions; } 

Make Human base class contain only the same behaviour all humans would like breathing etc, and then create a HealthyHuman and a BlindHuman etc, each creating their own methods. You can then use HealthHuman and subclass that further if you need.

class Human {    void breathe() {};    // other Human basic functions; }   class HealthyHuman extends Human {    void see() {};    //other healthy human functions }  class BlindHuman extends Human {   void useCane() {}; } 

For the second case you can still use composition too to share behaviour:

class BlindHuman extends Human {    private VoiceSubsystem _voice = new VoiceSybsystem();    void speaker() {  _voice.speaker();} } 

Answer 2

The most important principle, is Lyskov's substitution principle.

Once you get it and apply it, you can build your model however you want.

For example, you could say that a blind man still sees, only he only gets black (or grey) pictures. There's also the question of legally blind people you want still see something if a blurred or partial picture.

You could also say that the action the object can do is not see. What we do is to watch. Seeing is the (successful) result of watching. Even with working eyes, you may watch without seeing anything! And blind people can still "see" something without eyes, or with non-functioning eyes, by listening (thus hearing, and building a mental "picture").

So, forget about "see" and "hear". Use watch and listen. And expect nothing from that. (wide pre-conditions).