Uploaded on

 

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
383
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
13
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

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 extend Tub 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! There’s 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. Let’s 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 doesn’t 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. Can’t 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 can’t be less accessible.
    2
    NOT LEGAL! It’s not a legal override because we restricted the access level. Nor is it a legal overLOAD because we didn’t 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 can’t change ONLY the return type
    You can vary the access levels in any direction