Chapter 8 Polymorphism
Upcoming SlideShare
Loading in...5
×
 

Chapter 8 Polymorphism

on

  • 1,840 views

Chapter 8 Polymorphism

Chapter 8 Polymorphism
Taught by Oum Saokosal, Head of Information Technology, National Polytechnic Institute of Cambodia

Statistics

Views

Total Views
1,840
Views on SlideShare
1,823
Embed Views
17

Actions

Likes
1
Downloads
136
Comments
0

1 Embed 17

http://www.slideshare.net 17

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

    Chapter 8 Polymorphism Chapter 8 Polymorphism Presentation Transcript

    • Chapter 8 Inheritance and Polymorphism Oum Saokosal , Head of IT Department National Polytechnic Institute of Cambodia Tel: (855)-12-417214 E-mail: oum_saokosal@yahoo.com
    • Chapter 8 Polymorphism
    • Polymorphism
      • What is polymorphism?
      • Why polymorphism?
      • Specific uses of polymorphism
      • Notes
      • Remember
      • Casting
      • instanceof Operations
      • Remember
    • What is Polymorphism? (1)
      • OOP has 3 features:
        • Class encapsulation
        • Inheritance
        • Polymorphism
      • Polymorphism is a mechanism to allow a single variable to refer to objects from different classes.
    • What is Polymorphism? Example (2)
      • Assume we have GraduateStudent which inherits from Student . Here is an example.
        • public class Student{
        • public String getClassName() {
        • return "Student Class";
        • }
        • }
      Student +getClassName():String UndergraduateStudent +getClassName():String GraduateStudent +getClassName():String
    • What is Polymorphism? Example (3)
      • //Continue ...
        • public class GraduateStudent extends Student {
        • @Override public String getClassName() {
        • return "GraduateStudent Class";
        • }
        • }
        • public class UndergraduateStudent extends Student {
        • @Override public String getClassName() {
        • return “UndergraduateStudent Class";
        • }
        • }
    • What is Polymorphism? Test 1 (4)
      • //Test1 1 – Polymorphism
        • public class TestPoly1{
        • public static void main(String[] args){
        • Student s = new UndergraduateStudent();
        • System.out.println( s.getClassName() );
        • }
        • }
      • Q. What is output?
      • A. UnderGraduateStudent Class
      That’s polymorphism
    • What is Polymorphism? Test 2 (5)
      • //Example 2 – Without Polymorphism
        • public class TestNoPoly2 {
        • public static void main(String[] args){
        • GraduateStudent gs = new GraduateStudent();
        • displayUnder ( gs );
        • displayGraduate ( new UndergraduateStudent() );
        • }
        • static void displayUnder ( GraduateStudent gs ){
        • System.out.println(gs.getClassName());
        • }
        • static void displayGraduate ( UndergraduateStudent us ){
        • System.out.println(us.getClassName());
        • }
        • }
    • What is Polymorphism? Test 2 (6)
      • //Example 2 – With Polymorphism
        • public class TestPoly2 {
        • public static void main(String[] args){
        • display( new GraduateStudent() );
        • display( new UndergraduateStudent() );
        • }
        • //Polymorphic method
        • public static void display( Student stu ){
        • System.out.println( stu.getClassName() );
        • }
        • }
      • Why Polymorphism?
      • To choose which method from which class is called at runtime dynamically.
      • A variable of a parent type can refer to any child and grand child of the parent.
      • Student stu = new GraduateStudent();
      • stu.getClassName();
      Why Polymorphism? (1) Parent/Superclass Children/Subclass Student getClassName():String UndergraduateStudent getClassName():String GraduateStudent getClassName():String
    • Specific Uses of Polymorphism Methods (1)
      • Methods
      • If we don’t use polymorphism, you have to make a new method for every different parameter data type. Look at slide 8 .
      • But with polymorphism, you make only one method for every parameter which has the same parent. Look at slide 9 .
    • Specific Uses of Polymorphism Array (2)
      • Array: In Java, every element in an array has the same type, doesn’t it? E.g.
      • double[] scores = new double[10];
      • scores[0] = 1.4;
      • scores[1] = “Hi”; //Compile Error
      • Circle[] circles = new Circle[5];
      • circles[0] = new Circle(5);
      • circles[1] = new Circle(20);
      • circles[2] = new Student(); //Compile Error
    • Specific Uses of Polymorphism Array (3)
      • Q. If I do want to store different types of objects in one array, how can I do it?
      • Use polymorphism .
      • If the objects are inherited from the same parent , we can store them in the same array .
      • Example:
        • Student[] students = new Student[3];
        • students[0] = new Student();
        • students[1] = new GraduateStudent();
        • students[2] = new UndergraduateStudent();
    • Specific usages of Polymorphism Array (4)
        • public class TestPoly3 {
        • public static void main(String[] args){
        • Student[] s = new Student[3];
        • s[0] = new Student();
        • s[1] = new GraduateStudent();
        • s[2] = new UndergraduateStudent();
        • display(s); //Polymorphism
        • }
        • public static void display( Student [] s){
        • for(int i = 0; i<s.length; i++){
        • System.out.println(s[i].getClassName());
        • }
        • }
        • }
    • Note #1 (1)
      • Look at the codes again.
        • public class Student{
        • public String getClassName(){
        • return &quot;Student Class&quot;;
        • }
        • }
        • public class GraduateStudent extends Student{
        • @Override public String getClassName(){
        • return &quot;GraduateStudent Class&quot;;
        • }
        • }
        • public class UndergraduateStudent extends Student{
        • @Override public String getClassName(){
        • return “UndergraduateStudent Class&quot;;
        • }
        • }
      GraduateStudent and UndergraduateStudent override getClassName() method!
    • Note #1 (2)
      • Please note that the two subclasses of Student override getClassName() .
      • Then, we can use polymorphism to refer to getClassName() in the sub class.
        • public class TestPoly1{
        • public static void main(String[] args){
        • Student s;
        • s = new GraduateStudent();
        • System.out.println( s.getClassName() );
        • s = new UndergraduateStudent();
        • System.out.println( s.getClassName() );
        • }
        • }
    • Note #2 (1)
      • But now in a subclass GraduateStudent , we add a new method, say getDegree() .
        • public class GraduateStudent extends Student{
        • public String getClassName(){
        • return &quot;GraduateStudent Class&quot;;
        • }
        • public String getDegree(){
        • return &quot;Msc in Computer Science&quot;;
        • }
        • }
    • Note #2 (2)
      • And then we want to use polymorphism to call getDegree() in the subclass,
        • public class TestPoly1{
        • public static void main(String[] args){
        • Student s = new GraduateStudent();
        • System.out.println( s.getDegree() );
        • }
        • }
      • It will show a compile error because Student class doesn’t have getDegree() .
    • Note #3 (1)
      • What about if we want add a method, say getID() to the parent, Student .
      • public class Student{
        • public String getClassName(){
        • return &quot;Student Class&quot;;
        • }
        • public String getID(){
        • return “NPIC001&quot;;
        • }
        • }
    • Note #3 (2)
      • Then we want to call getID().
        • public class TestPoly1{
        • public static void main(String[] args){
        • Student s = new GraduateStudent();
        • System.out.println( s.getID() );
        • }
        • }
      • Q. Is it a compile error?
      • A. No . As long as getID() is in Student , we can call it without any question .
    • The bottom line (1)
      • As long as subclasses inherit from the same parent , you can declare a variable as the parent type and then refer to any subclasses .
      • Student stu; //stu is parent type
      • //stu refers to subclasses
      • stu = new UndergraduateStudent();
      • stu = new GraduateStudent();
      Student getClassName():String UndergraduateStudent getClassName():String GraduateStudent getClassName():String
    • The bottom line (2)
      • When you call a method which exists both in a parent and subclass, then it will dynamically refer to the method in the subclass. (This is the main reason to use Polymorphism) See slide 7 .
      • You cannot call methods that are NOT existed in parent. If you try it, you will get compile error. See slide 18 .
      • However, you can call every method in the superclass. See slide 19 & 20 .
    • Remember (1)
      • Polymorphism is a mechanism to enable us to choose a method at runtime dynamically.
      • Polymorphism always needs Inheritance .
      • Polymorphism always needs Overridden Methods .
      • There is no keyword to indicate Polymorphism.
      • You can recognise it whenever you see a class type that is different from its constructor . E.g.
        • Student s = new GraduateStudent() ;
      • You can also recognise it, when a class type is Object class. E.g.
        • private void aMethod( Object ob){...}
    • Remember (2)
      • Polymorphism is not as vital as inheritance. That is, without polymorphism, you still CAN make a Java program; however without inheritance, especially when using Java library code, you CANNOT achieve very much.
    • Casting Objects (1)
      • What is Casting?
      • Casting is a technique to convert a variable from one primitive type to another one. E.g.:
      • double d1 = 2.5;
      • double d2 = 12;
      • int i1 = 23;
      • int i2 = 22.5 ; // Compile Error
      • How to solve this error?
      • int i2 = (int) 22.5; // i2 = 22
      • //Casting from double 22.5 to integer.
    • Casting Objects (2)
      • To understand casting, let’s meet a group of animals studying polymorphism.
      CB is a curious student who always asks questions whereas SR is a smart student. She can help to answer CB’s questions. SR : Smart Rabbit CB: Curious Ball
    • Casting Objects (3)
      • CB : Hey Smart Rabbit! Can I ask you some questions?
      • SR: Yes, Of course. What can I do for ya?
      • CB: I have 2 classes, Grape inherits from Fruit .
    • Casting Objects (4)
      • SR: So what?
      • CB: Grape has four methods. And Fruit has only two methods. Then I want to use polymorphism like this:
      • Fruit f = new Grape();
      • So which methods can I call from f ?
        • f ._ _ _ ?
      • SR: Then you can call only those methods from Fruit class like isEatable() and getColor() , and, of course, other 9 methods from Object class.
    • Casting Objects (5)
      • CB: You know, usually when I define a variable with a parent type and refer to a constructor from the same class, I can call every method from it.
      • Grape g = new Grape();
      • g.getTaste(); // OK
      • g.getVitamin(); //OK
      • SR: Yeh, and what is your problem?
      • CB: But now when I use polymorphism, it seems to me that I couldn’t do what I used to do.
        • Fruit fruit = new Grape();
        • fruit .getTaste() ; // Compile Error
        • fruit .getVitamin() ; // Compile Error
    • Casting Objects (6)
      • CB: So do you have any solution, Rabbit?
      • SR: Why not? You can use “casting” to cast from Fruit to another Grape variable.
      • CB: Can you show me?
      • SR: Sure! Here it is:
        • Fruit fruit = new Grape();
        • Grape grape = (Grape) fruit; // Casting
        • grape .getTaste() ; //OK
        • grape .getVitamin() ; //OK
    • Casting Objects (6)
      • CB: Yeh... but you still create a variable that has Grape as its parent type. It doesn’t make sense to me?
      • SR: Why not?
      • CB: You know, it is much better if I just create a variable which has Grape as its type and refer to its constructor since the beginning like this:
      • Grape g = new Grape() ;
      • g.getTaste(); // OK
      • g.getVitamin(); //OK
    • Casting Objects (7)
      • SR: Well, but do you remember polymorphic method?
      • CB: Yes.
      • SR: So can I tell me some about it?
      • CB: polymorphic method is just like other methods but the type of parameters is always a superclass. For example:
      • public static void display( Object o){
      • JOptionPane.showMessageDialog(null, o);
      • }
      • SR: Yehh! You are good!
    • Casting Objects (8)
      • CB: Thank you. But how polymorphic method works with casting?
      • SR: OK! I’ll show you the differences when not using casting and when using casting.
      • public class TestNoCasting {
      • public static void main(String[] args){
      • showTaste(new Grape());
      • }
      • public static void showTaste(Fruit fruit){
      • JOptionPane.showMessageDialog(null,
      • fruit.getTaste() );
      • } //Error because Fruit has not getTaste()
      • }
    • Casting Objects (9)
      • SR: Here is codes when using casting.
      • public class TestCastingObject {
      • public static void main(String[] args){
      • showTaste(new Grape());
      • }
      • public static void showTaste(Fruit fruit){
      • Grape grape = (Grape) fruit;
      • JOptionPane.showMessageDialog(null,
      • grape.getTaste() ); //OK
      • }
      • }
    • Casting Objects (10)
      • CB: Wow! Now I got. Casting can help polymorphism more powerful. Both Java and you are very smart.
      • SR: Not yet dude!
      • CB: What else?
      • SR: What about if I add another class, say Apple inherits also from Fruit ? Let’s see it on the next slide.
    • Casting Objects (11)
    • Casting Objects (11)
      • SR: Then I pass in Apple object to showTaste() method.
      • public class TestCastingObject {
      • public static void main(String[] args){
      • showTaste( new Apple() );
      • }
      • public static void showTaste(Fruit fruit){
      • Grape grape = (Grape) fruit;
      • JOptionPane.showMessageDialog(null,
      • grape.getTaste());
      • }
      • } //Runtime Error: casting wrong class
    • instanceof Operation (1)
      • CB: Wo.. ho.. ho. I didn’t realize it.
      • SR: Don’t worry! Remember Java is number one in the world.
      • CB: So what is your solution?
      • SR: We can use instanceof to test whether it is correct object or not before we cast it.
      • CB: Can you show how?
      • SR: OK, Let’s go to the next slide.
    • instanceof Operation (2)
      • public static void main(String[] args) {
      • showTaste(new Apple());
      • }
      • public static void showTaste(Fruit fruit) {
      • if (fruit instanceof Grape ) {
      • Grape grape = (Grape) fruit; System.out.print(grape.getTaste());
      • } else if(fruit instanceof Apple ) {
      • Apple apple = (Apple) fruit; System.out.print(apple.getTaste());
      • }
      • }
    • instanceof Operation (3) CB: OK. It seems to me that I know them all, but I want to ask you, Smart Rabbit, whether the 3rd year students in NPIC who are watching us understand it or not. SR: This is a hard question. I’m not sure either. You’ve better ask them by yourself.
    • Remember (1)
      • Casting is a technique to convert a variable from one class type to another one within an inheritance hierarchy .
      • That is, if we cast a class to another class in different root, you will get run-time error . E.g:
      • Fruit fruit = new Grape();
      • Grape grape = (Grape) fruit ; // OK
      • Apple apple = (Apple) fruit ; //Runtime Error
    • Remember (2)
      • A keyword instanceof is an operation to check whether a class that we want to cast is in the correct hierarchy or not.
      • E.g.:
        • Fruit fruit = new Grape();
        • if(fruit instanceof Grape){
        • Grape grape = (Grape) fruit ;
        • } else if(fruit instanceof Apple){
        • Apple apple = (Apple) fruit ;
        • }
        • fruit.getColor();
        • fruit.getTaste();