polymorphism

Polymorphism & Interfaces :Polymorphism & Interfaces


Example class hierarchy :Example class hierarchy Animal Cat Dog Horse


Polymorphism :Polymorphism Normally we have this when we create an object: Dog dog = new Dog(); Polymorphism allows us to also do this: Animal pet = new Dog(); The object reference variable can be a super class of the actual object type! (Does NOT work the other way around: Dog is an Animal but Animal is not necessarily a Dog)


Where Polymorphism is Helpful :Where Polymorphism is Helpful Arrays Passing parameters Returning values from a method


Polymorphic Array Example :Polymorphic Array Example Animal[] myPets = new Animal[5]; myPets[0] = new Cat(); myPets[1] = new Cat(); myPets[3] = new Dog(); for (int i = 0; i < myPets.length; i++) { myPets.feed(); } You can put any subclass of Animal in the Animal array!


Polymorphic Arguments :Polymorphic Arguments public class Vet { public void giveShot(Animal pet) { pet.makeNoise(); } } public class PetOwner { Vet vet = new Vet(); Dog dog = new Dog(); Cat cat = new Cat(); vet.giveShot(dog); vet.giveShot(cat); }


Abstract Classes :Abstract Classes Sometimes we don’t want to allow an object to be created of a certain type. What exactly would an Animal object be? We use the keyword abstract to prevent a class from ever being instantiated. abstract public class Animal


Abstract Classes :Abstract Classes Can still use abstract classes as a reference variable, for the purposes of polymorphism. An abstract class has no use until it is extended! A class that is not abstract is called concrete.


Abstract Methods :Abstract Methods An abstract method has no body and is marked with the keyword abstract. public abstract void eat(); If a method is abstract, the class it is contained in must also be abstract. Abstract methods help the programmer to provide a protocol for a group of subclasses. The first concrete class in the inheritance hierarchy must implement the abstract method (i.e. override it and provide it a body)


Side Effects of Polymorphism :Side Effects of Polymorphism ArrayList pets = new ArrayList(); Dog dog = new Dog(); pets.add(dog); int index = pets.indexOf(dog); Dog dog1 = pets.get(index); // won’t work Object dog2 = pets.get(index); dog2.bark(); // won’t work ((Dog)dog2).bark(); // works because of casting if (dog2 instanceof Dog) { // being careful ((Dog)dog2).bark(); } Dog dog3 = (Dog) pets.get(index); // works because of casting if (dog2 instanceof Dog) { // being careful Dog dog4 = (Dog) dog2; }


Slide 11 :Animal Canine Feline Wolf Dog Cat Tiger Lion But remember we said that Java does not support multiple inheritance. There is a solution however: interfaces.


Interfaces :Interfaces Interface: A collection of constants and abstract methods that cannot be instantiated. A class implements an interface by providing method implementations for each of the abstract methods defined in the interface. public class Dog extends Canine implements Pet


Interfaces :Interfaces public interface Pet { public abstract void beFriendly(); public abstract void play(); } public class Dog extends Canine implements Pet { public void beFriendly() { wagTail(); } public void play() { chaseBall(); } . . . all the other Dog methods . . . } Explicitly typing in public and abstract is not necessary since they MUST be public and abstract Must implement these methods since they are in Pet


Interfaces vs. Subclasses :Interfaces vs. Subclasses Make a subclass only when you want to make a more specific version of a class. Use an interface when you want to define a role that other classes can play, regardless of where those classes are in the inheritance tree.


Polymorphism via Interfaces :Polymorphism via Interfaces An interface reference variable can be used to refer to any object of any class that implements that interface. This works the same with superclasses. Pet myPet = new Dog(); The same side effects of polymorphism occur with interfaces as with inheritance.


Comparable Interface :Comparable Interface Defined in the java.lang package Only contains one method: compareTo which takes an object as a parameter and returns an integer. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. Provides a common mechanism for comparing one object to another. http://java.sun.com/j2se/1.5.0/docs/api/java/lang/Comparable.html