09 polymorphism

Click here to load reader

Post on 22-Dec-2014

408 views

Category:

Documents

4 download

Embed Size (px)

DESCRIPTION

 

TRANSCRIPT

  • 1. Using IS-A and HAS-A
    LIS4930 PIC
    When you want to know if one thing should extend another; apply the IS-A test.
    Triangle IS-A Shape.
    YES
    Cat IS-A Feline.
    YES
    Bathroom has a reference to a Tub, but Bathroom does not extendTub and vice-versa.
    Surgeon IS-A Doctor.
    YES
    Tub IS-A Bathroom.
    NO
    Bathroom HAS-A Tub.
    Tub and Bathroom are related, but not through inheritance: Bathroom HAS-A Tub instance variable.

2. Wait! Theres More!
LIS4930 PIC
If class B extends A, class B IS-A class A. This is true anywhere in the inheritance tree. If class C extends class B, class C passes the IS-A test for both B and A.
Canine extends Animal
Wolf extends Canine
Wolf extends Animal
Canine IS-A Animal
Wolf IS-A Canine
Wolf IS-A Animal
Keep in mind that the inheritance IS-A relationship works in only ONE direction!
Animal
makeNoise()
eat()
sleep()
roam()
Canine
roam()
Wolf
makeNoise()
eat()
3. Test Yourself!
LIS4930 PIC
Oven extends Kitchen
Guitar extends Instrument
Person extends Employee
Ferrari extends Engine
FriedEgg extends Food
Beagle extends Pet
Container extends Jar
Metal extends Titanium
Beverage extends Coke
4. Access Level Control
LIS4930 PIC
A subclass inherits all public instance variables and methods of the superclass, but does not inherit the private instance variables and methods of the superclass.
public members are inherited
private members are not inherited
Mammal
private weight
public color
private eat()
private roam()
public sleep()
Elephant
makeNoise()
5. Polymorphism! What is that?
LIS4930 PIC
I think this is best explained with an example. Lets step back and look at the way we normally declare a reference and create an object
myDog
Declare a reference variable
Dog myDog
1
Dog
6. Polymorphism! What is that?
LIS4930 PIC
Dog
Create an object
Dog myDog = new Dog()
2
Dog object
7. Polymorphism! What is that?
LIS4930 PIC
myDog
Dog
Link the object and the reference
Dog myDog= new Dog()
3
Dog
Dog object
8. Polymorphism! What is that?
LIS4930 PIC
myDog
Dog
Dog
Dog object
The important point is that the reference type AND the object type are the same.
9. Polymorphism! What is that?
LIS4930 PIC
myDog
Dog
Animal
Dog object
But with polymorphism, the reference and the object can be different.
Animal myDog= new Dog()
10. Polymorphic Example
LIS4930 PIC
Animal[ ]animals = new Animal[5];
animals[0] = new Dog();
animals[1] = new Cat();
animals[2] = new Wolf();
animals[3] = new Hippo();
animals[4] = new Lion();
for(inti = 0; i < animals.length; i++){
animals[i].eat();
animals[i].roam();
}
11. You can have polymorphic arguments and return types
LIS4930 PIC
class Vet {
public void giveShot(Animal a) {
a.makeNoise();
}
}
a
class PetOwner {
public void start() {
Vet v = new Vet();
Dog d = new Dog();
Hippo h = new Hippo();
v.giveShot(d);
v.giveShot(h);
}
}
Animal
12. Taking Advantage of Polymorphism
LIS4930 PIC
With polymorphism, you can write code that doesnt have to change when you introduce new subclass types in the program.
That means if others want to take advantage of your Vet class, all they have to do is make sure their new Animal types extend class Animal.
13. Keeping the Contract: Rules for Overriding
LIS4930 PIC
Arguments must be the same, and return types must be compatible
1
This is NOT an override. Cant change the arguments in an overriding method!
This is actually a legal overLOAD, but not an overRIDE.
Appliance
booleanturnOn()
Toaster
booleanturnOn(int level)
14. Keeping the Contract: Rules for Overriding
LIS4930 PIC
The method cant be less accessible.
2
NOT LEGAL! Its not a legal override because we restricted the access level. Nor is it a legal overLOAD because we didnt change arguments.
Appliance
public booleanturnOn()
Toaster
private booleanturnOn()
15. Overloading A Method
LIS4930 PIC
Method overloading is nothing more than having two methods with the same name but different argument lists. Period. It has nothing to do with inheritance and polymorphism. An overloaded method is NOT the same as an overridden method.
1
2
3
The return types can be different
public class Overloads {
String uniqueID;
public intaddNums(int a, intb) {
return a + b;
}
public double addNums(double a, double b) {
return a + b;
}
public void setUniqueID(String ID){
uniqueID = theID;
}
private void setUniqueID(intssNumber){
String numString = + ssNumber;
setUniqueID(numString);
}
}
You cant change ONLY the return type
You can vary the access levels in any direction