Polymorphism
SZABIST
Islamabad
Polymorphism
Pre-‐requisites
• Following
are
the
post
condi?ons
that
must
be
met
in
code
in
which
you
want
to
exploit
polymorphism:
– Inheritance
There
should
exist
a
hierarchy
where
some
classes
are
parent
of
the
child
classes
– Overriding
It
is
utmost
important
that
you
should
have
overridden
a
method
in
all
of
these
classes.
– It
is
for
this
method
you
will
observe
polymorphic
behavior.
Polymorphism:
Class
Diagram
Inheritance
Overriding
What
is
leI………..
1-‐-‐-‐-‐-‐-‐>Subsitu?on
Person
p
=
new
Student();
//
child
object
assigned
to
a
parent
type
2-‐-‐-‐-‐-‐-‐>
Method
Calling
p.toString();
//will
s?ll
call
student’s
toString()
Method
output
is
polymorhic
i.e.
even
though
the
object
reference
is
of
person
type,
it
has
the
capability
to
call
toString
of
all
its
child
classes.
Polymorphism 1
§ The is-a relationship between a superclass and a subclass has an
important implication. For example:
§ A cow is an animal
§ Therefore all cows are animals.
§ So you can substitute an object of the subclass Cow for an object of
the superclass Animal, because a cow is, after all, an animal.
§ For example, the following code is valid:
Animal a = new Animal(); // Variable a points to an object of Animal
a = new Cow(); // Now, a points to an object of Cow.
However, note that the reverse is not true: not all animals are cows.
Therefore, the following line of code is not valid:
Cow c = new Animal(); // not valid
Polymorphism 2
§ A superclass can have multiple subclasses
§ For example,
§ a cow is an animal
§ a buffalo is also an animal
§ This means you can substitute either a cow or a buffalo
for an animal
§ This is an example of polymorphism
§ Polymorphism means giving different meaning to the
same thing
§ Greek: poly = many, and morph = form
Polymorphism 3
1. public class TestPoly { 17. class Cow extends Animal {
2. public static void main(String [] 18. public void saySomething() {
args) { 19.// super.saySomething();
3. Animal heyAnimal = new Animal(); 20. System.out.println("Moo!");
4. Cow c = new Cow(); 21. }
5. Buffalo b = new Buffalo(); 22. }
6. heyAnimal=c;
7. heyAnimal.saySomething(); 23. class Buffalo extends Animal{
8. heyAnimal=b; 24. public void saySomething() {
9. heyAnimal.saySomething(); 25. // super.saySomething();
10. } 26. System.out.println("Bah!");
11.} 27. }
28. }
12.class Animal {
13. public void saySomething() {
14. System.out.println("Umm..."); The output from this code is:
15. }
16.} Moo!
Bah!
Polymorphism 4
§ Note that invoking two calls from the same object to the same method (lines
7 and 9), saySomething(), has different effects.
§ This is made possible by:
§ Assigning objects of different subclasses of Animal, cow and buffalo, to
the object reference of Animal,
§ And by having different implementations of the saySomething() method
in the subclasses (lines 18 and 24).
§ Note: The compiler only knows about the declared object reference types.
However, at runtime, the JVM knows what the referred object really is.
§ Note that the capability to convert an object reference from one type (Animal
in our example) to another type (say Cow) is at the heart of polymorphism.
§ This conversion can happen to both kinds of data types: primitives and
object
8
references.
Polymorphism 5
§ Polymorphism does not apply to the static class
members.
§ For example:
§ You have a static method with identical signatures
defined in the parent class and its subclass
§ You assign an instance of the subclass to the
reference variable of the parent class
§ The variable invokes this static method
§ In this case the parent version of the method will be
executed.
Conversion of Object Reference Types 1
§ An object reference is a variable that points (refers) to
the object (data),
§ A primitive variable holds the value (data) itself.
§ There are three kinds of object reference types:
§ A class
§ An interface
§ An array
§ Just like primitive types, object reference types can
also go through conversion in two ways:
§ Implicit conversion
§ Explicit conversion
Conversion of Object Reference Types 2
Assignment Conversion:
§ Implicit conversion of an object reference type in an
assignment operation typically looks like the following:
<sourceType> s = new <sourceType>();
<targetType> t = s; // Implicit conversion of <sourceType> to
<targetType>.
§ This is the general form of implicit conversion from
<sourceType> to <targetType> in assignment.
§ The <sourceType> and <targetType> may be a class, an
interface, or an array.
§ This creates nine possible cases for conversion.
Conversion of Object Reference Types 3
12
Conversion of Object Reference Types 4
§ A class type may be converted to another class type if one of the following is true:
§ The <sourceType> is a subclass of the <targetType>
§ The <sourceType> implements the <targetType>
§ An interface type may be converted to one of the following:
§ Another interface if the <sourceType> is a subinterface of the <targetType>
§ The Object type if the <targetType> is an object.
§ An array may be converted to one of the following:
§ Another array if the following conditions are true: both <sourceType> and <targetType> are
arrays of object reference types, and the object reference type of <sourceType> array
elements is convertible to the object reference types of <targetType> array elements.
§ The interface: Cloneable or Serializable.
§ The class Object.
Conversion of Object Reference Types 5
14
Conversion of Object Reference Types 6
§ As an example, consider the following lines of code:
Lab lab1 = new Lab();
ClassRoom csroom = lab1;
§ This code would work because the class Lab is being converted into
the class ClassRoom, and
Lab is a subclass of ClassRoom.
§ On the other hand, the following code will generate a compiler error:
ClassRoom croom = new ClassRoom();
Lab cslab = croom; // compiler error.
§ The compiler error will be generated because an attempt is being
made to convert ClassRoom
into Lab, but ClassRoom is not a subclass of Lab.
Conversion of Object Reference Types 7
§ Further, consider the following code:
1. LectureHall lh174 = new LectureHall();
2. Facilities facil174 = lh174;
3. LectureHall lh158 = facil174; // compiler error.
§ Line 2 will work because:
§ The class LectureHall is being converted into the interface Facilities
§ LectureHall extends ClassRoom
§ ClassRoom implements Facilities.
§ However, line 3 would generate a compiler error because
§ The interface Facilities is being converted into LectureHall
§ Facilities is not a subinterface of LectureHall.
Conversion of Object Reference Types 8
1. public class ObjectRefConversion{
2. public static void main(String[] args) {
3. ClassRoom[] crooms = new ClassRoom[10];
4. Room[] rooms;
5. Lab[] labs;
6. for (int i = 0; i<5; i++) {
7. crooms[i] = new ClassRoom();
8. }
9. rooms = crooms;
10. labs = crooms; // compiler error
11. } //end main
12. } //end class ObjectRefConversion
13.
16. class Room {
14. interface Facilities { 17. } .
15. }
18. class ClassRoom extends Room implements Facilities{
19. }
20. class Lab extends ClassRoom {
21. }
17
Conversion of Object Reference Types 9
§ The conversion in line 9 will work because:
§ rooms and crooms are both arrays
§ the element type of crooms (that is, ClassRoom) is convertible to
the element type of rooms (that is, Room).
§ On the other hand, line 10 will generate a compiler error because
§ the type of elements of array crooms (that is, ClassRoom) is not
convertible to the type of elements of array labs (that is, Lab).
18
Conversion of Object Reference Types 10
Method Call Conversion:
§ The rules for method call conversion are the
same as the rules for assignment conversion.
§ The point to remember here is that the
passed-in argument types are converted into
the method parameter types when the
conversion is valid.
Conversion of Object Reference Types 11
§ The general rule of thumb is that converting to a
superclass is permitted and converting to a subclass is
not permitted.
§ To see how the rules make sense in the context of
method calls, consider the extremely useful
java.lang.Vector class.
§ You can store anything you like in a vector (anything
nonprimitive,
that is) by calling the method add (Object ob).
§ For example, the following code stores a Tangelo in a
vector:
1. Vector myVec = new Vector();
2. Tangelo tange = new Tangelo();
3. myVec.add (tange);
Conversion of Object Reference Types 12
§ The tange argument will automatically be converted to type
Object.
§ The automatic conversion means that the people who wrote
the java.lang.Vector class didn’t have to write a separate
method for every possible type of object that anyone might
conceivably want to store in a vector.
§ This is fortunate: the Tangelo class was developed years
after the invention of the vector, so the developer of the
Vector class could not possibly have written specific
Tangelo-handling code.
§ An object of any class (and even an array of any type) can
be passed into the single add (Object ob) method.
Conversion of Object Reference Types 13
Explicit Conversion of Object Reference Types:
§ Explicit conversion of object reference types is also called
object reference casting.
§ The syntax is the same as that of primitive data type casting.
§ Any conversion that is allowed implicitly is also allowed
explicitly.
§ However, explicit conversion exhibits its real power when
we use it for conversions that are not allowed implicitly.
Conversion of Object Reference Types 14
§ To understand explicit conversion of object references, you must
understand that complete information may not be available at compile
time, unlike with the primitive types.
§ For example, consider the following lines of code:
Lab lab1 = new Lab();
ClassRoom csroom = lab1;
§ Here, csroom is an object reference of type ClassRoom.
§ This information is available at compile time.
§ However, it refers to the object lab1, which will be created at runtime.
§ Therefore, at compile time we do not know to which object type this
reference variable csroom refers.
Conversion of Object Reference Types 15
§ For Example:
Lab lab1;
if (cmdLineArg=1){
lab1 = new Lab();
}
else
{
lab1 = new SmallLab(); \\ if we assume a class SmallLab
}
ClassRoom csroom = lab1;
§ Again at compile time we do not know to which object type this
reference variable csroom refers
Conversion of Object Reference Types 16
§ Because object reference conversion may involve reference
types and object types, the rules of object reference casting
are much broader (than for primitives):
§ Some of the casting rules relate to the reference type
(which is known at compile time) and therefore can be
enforced at compile time.
§ Some of the casting rules relate to the object type
(which is not known at compile time) and therefore can
only be enforced at runtime
Conversion of Object Reference Types 17
§ At compile time, the following rules must be obeyed:
§ When both the source type and target type are classes, one
class must be a subclass of the other.
§ When both the source type and target type are arrays, the
elements of both the arrays must be object reference types
and not primitive types. Also, the object reference type of the
source array must be convertible to the object reference type
of the target array.
§ The casting between an interface and an object that is not
final is always allowed.
Conversion of Object Reference Types 18
As an example, consider the following code fragment:
1. Auditorium a1,a2;
2. ClassRoom c;
3. LectureHall lh;
4. a1 = new Auditorium();
5. c = a1; //legal implicit conversion.
6. a2 = (Auditorium) c; // Legal cast.
7. lh = (LectureHall) c; // Illegal
Conversion of Object Reference Types 19
§ Note that the code fragment has four object references, namely a1,
a2, c, and lh.
§ A single object is created and assigned to the reference a1 in line 4.
§ The assignment in line 5 represents a legal conversion because the
class of a1 is a subclass of the class of c.
§ In line 6, the compiler cannot determine the class of the object to
which c refers.
§ Therefore, line 6 would be fine at compile time because the
compiler would look at c as a ClassRoom, and Auditorium is a
subclass of ClassRoom.
§ Line 6 will also be fine at execution time because c already refers to
an object of Auditorium, and a2 is also of type Auditorium.
Conversion of Object Reference Types 18
§ In line 7, the compiler cannot determine the class of the object to which c
refers.
§ However, c is an abject reference of class ClassRoom, and LectureHall is a
subclass of ClassRoom. Therefore, line 7 will be fine at compile time.
§ However, at execution time, the JVM knows that c refers to an object of class
Auditorium (due to line 5).
§ Auditorium type cannot be converted to LectureHall.
§ Thus, the conversion in line 7 is illegal, and will generate an exception at
runtime.
§ For this to be legal, the class of the object to which c refers has to be either
LectureHall or a subclass of it.
§ When an attempt to cast a reference variable to a type is illegal, the JVM
throws the
ClassCastException
