Polymorphism
Polymorphism
Polymorphism
The ability of a reference variable to change
behavior according to what object it is holding.
This allows multiple objects of different
subclasses to be treated as objects of a single
superclass, while automatically selecting the
proper methods to apply to a particular object
based on the subclass it belongs to.
Polymorphism
Given the parent class Person and the
subclass Student of the previous examples,
we add another subclass of Person which is
Employee.
Below is the class hierarchy for that,
Polymorphism
In Java, we can create a reference that is of
type superclass to an object of its subclass.
For example,
public static main( String[] args ) {
Person ref;
Student studentObject = new Student();
Employee employeeObject = new Employee();
ref = studentObject; //Person reference points to a
// Student object
}
Polymorphism
Now suppose we have a getName method
in our superclass Person, and we override
this method in both the subclasses Student
and Employee.
public class Student {
public String getName(){
System.out.println(“Student Name:” + name);
return name;
}
}
public class Employee {
public String getName(){
System.out.println(“Employee Name:” + name);
return name;
}
}
Polymorphism
Going back to our main method, when we
try to call the getName method of the
reference Person ref, the getName method
of the Student object will be called.
Now, if we assign ref to an Employee
object, the getName method of Employee
will be called.
Polymorphism
1 public static main( String[] args ) {
2 Person ref;
3 Student studentObject = new Student();
4 Employee employeeObject = new Employee();
5 ref = studentObject; //Person ref. points to a
6 // Student object
7 //getName of Student class is called
8 String temp=ref.getName();
9 System.out.println( temp );
10 ref = employeeObject; //Person ref. points to an
11 // Employee object
12
13 //getName of Employee class is called
14 String temp = ref.getName();
15 System.out.println( temp );
16 }
Polymorphism
Another example that illustrates
polymorphism is when we try to pass
references to methods.
Suppose we have a static method
printInformation that takes in a Person
reference as parameter.
public static printInformation( Person p ){
....
}
Polymorphism
We can actually pass a reference of type
Employee and type Student to the
printInformation method as long as it is a
subclass of the class Person.
public static main( String[] args )
{
Student studentObject = new Student();
Employee employeeObject = new Employee();
printInformation( studentObject );
printInformation( employeeObject );
}
Abstract Classes
Abstract class
a class that cannot be instantiated.
often appears at the top of an object-oriented
programming class hierarchy, defining the
broad types of actions possible with objects of
all subclasses of the class.
Abstract Classes
abstract methods
methods in the abstract classes that do not
have implementation
To create an abstract method, just write the
method
public declaration without the body and use
abstract void someMethod();
the abstract keyword
For example,
Sample Abstract Class
public abstract class LivingThing {
public void breath(){
System.out.println("Living Thing breathing...");
}
public void eat(){
System.out.println("Living Thing eating...");
}
/**
* abstract method walk
* We want this method to be overridden by subclasses of
* LivingThing
*/
public abstract void walk();
}
Abstract Classes
When a class extends the LivingThing
abstract class, it is required to override the
abstract method walk(), or else, that
subclass will also become an abstract class,
public class Human extends LivingThing {
and therefore cannot be instantiated.
public void walk(){
System.out.println("Human walks...");
For example,
}
}
Coding Guidelines
Use abstract classes to define broad types
of behaviors at the top of an object-
oriented programming class hierarchy, and
use its subclasses to provide
implementation details of the abstract
class.
Interfaces
Interfaces
An interface
is a special kind of block containing method signatures
(and possibly constants) only.
defines the signatures of a set of methods, without the
body.
defines a standard and public way of specifying the
behavior of classes.
allows classes, regardless of their locations in the class
hierarchy, to implement common behaviors.
NOTE: interfaces exhibit polymorphism as well, since
program may call an interface method, and the proper
version of that method will be executed depending on
the type of object passed to the interface method call.
Why do we use Interfaces?
To have unrelated classes implement
similar methods
Example:
Class Line and MyInteger
Not related
Both implements comparison methods
isGreater
isLess
isEqual
Why do we use Interfaces?
To reveal an object's programming interface
without revealing its class
To model multiple inheritance which allows
a class to have more than one superclass
Creating Interfaces
To create an interface, we write:
public interface
[InterfaceName] {
//some methods without
the body
}
Creating Interfaces
As an example, let's create an interface that defines
relationships between two objects according to the “natural
order” of the objects.
public interface Relation
{
public boolean isGreater( Object a, Object b);
public boolean isLess( Object a, Object b);
public boolean isEqual( Object a, Object b);
}
Creating Interfaces
To use an interface, we use the implements keyword.
For example,
/**
* This class defines a line segment
*/
public class Line implements Relation {
private double x1;
private double x2;
private double y1;
private double y2;
public Line(double x1, double x2, double y1, double y2){
this.x1 = x1;
this.x2 = x2;
this.y1 = y1;
this.y2 = y2;
Creating Interfaces
public double getLength(){
double length = Math.sqrt((x2-x1)*(x2-x1) +
(y2-y1)* (y2-y1));
return length;
}
public boolean isGreater( Object a, Object b){
double aLen = ((Line)a).getLength();
double bLen = ((Line)b).getLength();
return (aLen > bLen);
}
public boolean isLess( Object a, Object b){
double aLen = ((Line)a).getLength();
double bLen = ((Line)b).getLength();
return (aLen < bLen);
public boolean isEqual( Object a, Object b){
double aLen = ((Line)a).getLength();
double bLen = ((Line)b).getLength();
return (aLen == bLen);
}
}
Creating Interfaces
When your class tries to implement an interface, always
make sure that you implement all the methods of that
interface, or else, you would encounter this error,
Line.java:4: Line is not abstract and does not override abstract method
isGreater(java.lang.Object,java.lang.Object) in Relation
public class Line implements Relation
^
1 error
Interface vs. Abstract Class
ALL Interface methods have no body
Some Abstract classes have method with
implementation
An interface can only define constants
An abstract class is just like an ordinary class that can
declare variables
Interfaces have no direct inherited relationship with any
particular class, they are defined independently
Abstract classes can be subsclassed
Interface vs. Class
Common:
Interfaces and classes are both types
This means that an interface can be used in places
where a class can be used
For example:
PersonInterface pi = new Person();
Person pc = new Person();
Difference:
You cannot create an instance from an interface
For example:
PersonInterface pi = new PersonInterface(); //ERROR!
Interface vs. Class
Common:
Interface and Class can both define methods
Difference:
Interface does not have any implementation of the methods
Extending Classes vs.
Implementing Interfaces
A class can only EXTEND ONE super class, but it can
IMPLEMENT MANY interfaces.
For example:
public class Person implements PersonInterface,
LivingThing,
WhateverInterface {
//some code here
}
Extending Classes vs. Implementing
Interfaces
Another example:
public class ComputerScienceStudent extends Student
implements PersonInterface,
LivingThing {
//some code here
}
Inheritance among Interfaces
Interfaces are not part of the class
hierarchy. However, interfaces can have
inheritance relationship among themselves
For example:
public interface PersonInterface {
...
}
public interface StudentInterface extends PersonInterface {
...
}
Summary
Inheritance (superclass, subclass)
Using the super keyword to access fields
and constructors of superclasses
Overriding Methods
Final Methods and Final Classes
Polymorphism (Abstract Classes, Interfaces)