Prentice.Hall.Introduction.to.Java.Programming,.Brief.Version.9th.(2014).[sharethefiles.com]

classes. Consider the Animal class. Suppose the howToEat method is defined in the
Animal class, as follows:
15.8 Interfaces vs. Abstract Classes 583
abstract class Animal {
public abstract String howToEat() ;
}
Animal class
Two subclasses of Animal are defined as follows:
class Chicken extends Animal {
@Override
public String howToEat() {
return "Fry it";
}
}
class Duck extends Animal {
@Override
public String howToEat() {
return "Roast it";
}
}
Chicken class
Duck class
Given this inheritance hierarchy, polymorphism enables you to hold a reference to a Chicken
object or a Duck object in a variable of type Animal, as in the following code:
public static void main(String[] args) {
Animal animal = new Chicken();
eat(animal);
}
animal = new Duck();
eat(animal);
public static void eat(Animal animal) {
animal.howToEat();
}
The JVM dynamically decides which howToEat method to invoke based on the actual object
that invokes the method.
You can define a subclass of Animal. However, there is a restriction: The subclass must be
for another animal (e.g., Turkey).
Interfaces don’t have this restriction. Interfaces give you more flexibility than classes,
because you don’t have to make everything fit into one type of class. You may define the
howToEat() method in an interface and let it serve as a common supertype for other classes.
For example,
public static void main(String[] args) {
Edible stuff = new Chicken();
eat(stuff);
stuff = new Duck();
eat(stuff);
}
stuff = new Broccoli();
eat(stuff);