CH10 Supplementary Material Prepared by Fatimah Alakeel Oct 2010

Polymorphism Overloaded methods are methods with the same name signature but either a different number of parameters or different types in the parameter list. For example 'spinning' a number may mean increase it, 'spinning' an image may mean rotate it by 90 degrees. By defining a method for handling each type of parameter you achieve the effect that you want. Overridden methods are methods that are redefined within an inherited or subclass. They have the same signature and the subclass definition is used.inherited or subclass

Polymorphism Polymorphism is the capability of an action or method to do different things based on the object that it is acting upon. This is the third basic principle of object oriented programming. Overloading and overriding are two types of polymorphism. Now we will look at the third type: dynamic method binding.

Example Animal DogCatSnake

Example Assume that three subclasses (Cow, Dog and Snake) have been created based on the Animal abstract class, each having their own speak() method.

Abstract Class public abstract class Animal // class is abstract { private String name; public Animal(String nm) // constructor method { name=nm; } public String getName() // regular method { return (name); } public abstract void speak(); // abstract method - note no {} }

public class AnimalReference { public static void main(String args[]) { Animal ref ; // set up var for an Animal Cow aCow = new Cow("Bossy"); // makes specific objects Dog aDog = new Dog("Rover"); Snake aSnake = new Snake("Ernie"); // now reference each as an Animal ref = aCow; ref.speak(); ref = aDog; ref.speak(); ref = aSnake; ref.speak(); } Notice that although each method reference was to an Animal (but no animal objects exist), the program is able to resolve the correct method related to the subclass object at runtime. This is known as dynamic (or late) method binding.

Arrays of Objects As with arrays of primitive types, arrays of objects allow much more efficient methods of access. Note in this example that once the array of Animals has been structured, it can be used to store objects of any subclass of Animal. By making the method speak() abstract, it can be defined for each subclass and any usage will be polymorphic (ie. adapted to the appropriate object type at runtime). It now becomes very easy to rehearse the speak() method for each object by object indexing.

public class AnimalArray { public static void main(String args[]){ Animal ref[] = new Animal[3]; // assign space for array Cow aCow = new Cow("Bossy"); // makes specific objects Dog aDog = new Dog("Rover"); Snake aSnake = new Snake("Earnie"); // now put them in an array ref[0] = aCow; ref[1] = aDog; ref[2] = aSnake; // now demo dynamic method binding for (int x=0;x<3;++x) { ref[x].speak(); } }

Casting Objects One of the difficulties of using a superclass array to hold many instances of subclass objects is that one can only access properties and methods that are in the superclass (ie. common to all). By casting an individual instance to its subclass form, one can refer to any property or method. But first take care to make sure the cast is valid by using the instanceof operator. Then perform the cast. As an example using the above Animal class:

Example if (ref[x] instanceof Dog) // ok right type of object { Dog doggy = (Dog) ref[x]; // cast current instance to subclass doggy.someDogOnlyMethod(); } Casts to subclass can be done implicitly but explicit casts are recommended. Casts to superclass must be done explicitly. Casts cannot be made between sibling classes.

Interfaces Interfaces are similar to abstract classes but all methods are abstract and all properties are static final. Interfaces can be inherited (ie. you can have a sub-interface). As with classes the extends keyword is used for inheritence.Java does not allow multiple inheritance for classes (ie. a subclass being the extension of more than one superclass). An interface is used to tie elements of several classes together. Interfaces are also used to separate design from coding as class method headers are specified but not their bodies. This allows compilation and parameter consistency testing prior to the coding phase. Interfaces are also used to set up unit testing frameworks.

Interfaces As an example, we will build a Working interface for the subclasses of Animal. Since this interface has the method called work(), that method must be defined in any class using the Working interface. public interface Working { public void work(); }

Interfaces When you create a class that uses an interface, you reference the interface with the phrase implements Interface_list. Interface_list is one or more interfaces as multiple interfaces are allowed. Any class that implements an interface must include code for all methods in the interface. This ensures commonality between interfaced objects.

Interfaces Dog Working Dog Working

Interfaces public class WorkingDog extends Dog implements Working { public WorkingDog(String nm) { super(nm); // builds ala parent } public void work() // this method specific to WorkingDog { speak(); System.out.println("I can herd sheep and cows"); }

References