• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
11 polymorphism
 

11 polymorphism

on

  • 626 views

 

Statistics

Views

Total Views
626
Views on SlideShare
597
Embed Views
29

Actions

Likes
0
Downloads
14
Comments
0

2 Embeds 29

http://pic.fsu.edu 21
https://pic.fsu.edu 8

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    11 polymorphism 11 polymorphism Presentation Transcript

    • 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.
    • 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()
    • 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
    • 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()
    • 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
    • Polymorphism! What is that?
      LIS4930 © PIC
      Dog
      Create an object
      Dog myDog = new Dog()
      2
      Dog object
    • Polymorphism! What is that?
      LIS4930 © PIC
      myDog
      Dog
      Link the object and the reference
      Dog myDog= new Dog()
      3
      Dog
      Dog object
    • 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.
    • 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()
    • 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();
      }
    • 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
    • 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.
    • 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)
    • 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()
    • 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