Specializing method arguments in subclasses in Java

Question

Consider the following situation:

public abstract class AnimalFeed{
}
public class FishFeed extends AnimalFeed{
}
public class BirdFeed extends AnimalFeed{
}         


        

Answer 1

You'd need to add a type variable to the class:

public abstract class Animal<F extends AnimalFeed> {
  public abstract void eat(F somethingToEat);
}

Then you can declare your subclasses as wanting a particular type of AnimalFeed:

public class Bird extends Animal<BirdFeed> {
  public void eat(BirdFeed somethingToEat) {}
}

public class Fish extends Animal<FishFeed> {
  public void eat(FishFeed somethingToEat) {}
}

Answer 2

What you are asking for doesn't make sense from an theoretical point of view.

Restricting a method parameter violates the Liskov Substitution Principle.

The idea there: any occurance (usage) of some base class object must be able to deal with some sub class object, too.

A more simple example: when your base interface goes:

void foo(Number n)

then you must not do

@Override
void foo(Integer i)

in a subclass. Because all of a sudden, a caller

someObject.foo(someNumber)

would run into ugly ugly problems when someObject is of that derived class; which only accepts Integers, but not Numbers.

In other words: good OO design is much more than just writting down A extends B. You have to follow such rules; or you end up with systems are already broken on a conceptual point!

And for the record: it is theoretically valid to widen method parameters (in general, but in Java); and it is also ok to restrict the return types of methods (because these changes can not break client code; and that even works in Java).

Long story short: the answer here is too change your design; for example by using Generics and dependent interfaces to somehow create a relationship between the Animal and the Feed class hierarchy.