Object Oriented Programming with Java

Chapter Five
Polymorphism

- Polymorphism allows programmers to send the same message to objects from

different classes. i.e., in its simplest from, polymorphism allows a single
variable to refer to objects from different classes.
- Polymorphism enables us to “program in the general” rather than “program in
the specific”. In particular, polymorphism enables us to write programs that
process objects of classes that are part of the same class hierarchy as if they are
all objects of their classes.
- With polymorphism, it is possible to design and implement systems that are easily
extensible. New classes can be added with little or no modification to the generic
portions of the program, as long as those classes are part of the inheritance
hierarchy that the program processes generically. The only parts of a program that
must be altered to accommodate new classes are those program components that
require direct knowledge of the new classes that the programmer adds to the
hierarchy.

Relationships among Objects in an inheritance hierarchy

- Here, we will examine the relationships among classes in a hierarchy. In this
section, we see that an object of a subclass can be treated as object of its
superclass. This enables various interesting manipulations. For example, a
program can create an array of superclass reference that refers to objects of
many subclass types. This is allowed despite that fact that the subclass objects
are of different types, because each subclass object is an object of its subclasses.
However, a superclass object is not an object of any of its subclasses. The “is-a”
relationship applies only from a subclass to its direct and indirect superclasses.

Assigning reference of a subclass to a superclass-type variable

- Let us see an example here:
public class Point3{
private int x;
private int y;

public Point3()
{
}

public Point3(int xValue,int yValue)

{
x=xValue;
y=yValue;
}

1
 Object Oriented Programming with Java

public void setX(int xValue)

{
x=xValue;
}

public void setY(int yValue)

{
y=yValue;
}

public int getX()

{
return x;
}

public int getY()

{
return y;
}

public String toString()

{
return “[“+getX()+ “, ”+getY()+ “]”;
}
}//end class

public class Circle4 extends Point3{

private double radius;

public Circle4(int xValue, int yValue, double rValue)

{
super(xValue,yValue);
setRadius(rValue);
}

public void setRadius(double rValue)

{
radius = (rValue < 0.0?0.0:rValue);
}

public double getRadius()

{
return radius;
}

2
 Object Oriented Programming with Java

public double getDiameter()

{
return 2*getRadius();
}

public double getCircumfrence()

{
return Math.PI*getDiameter();
}

public double getArea()

{
return Math.PI*getRadius()*getRadius();
}

public String toString()

{
return “Center = “+super.toString()+ “; Radius=”+getRadius();
}
}//end class

import javax.swing.*;
public class PolyTest1{
public static void main(String args[])
{
Point3 point = new Point3(30,50);
Circle4 circle = new Circle4(120,89,2.7);
String output = “Call Point3’s toString with superclass”+
“reference to superclass object:\n”+ point.toString();

output+= “\n\nCall Circle4’s toString with subclass

”+ “reference to subclass object:\n”+circle.toString();

Point3 pointRef = circle;

Output+= “\n\ncall Circle4’s toString with superclass ”+
“ refernce to subclass object:\n “+pointRef.toString();
JOptionPane.showMessageDialog(null,output);
System.exit(0);
}

}//end class

- In the above program, the statement Point3 pointRef = circle; assigns the
reference of subclass object circle to superclass-type variable pointRef. A
superclass-type variable that contains a reference to a subclass object calls the
subclass method; hence, pointRef.toString() actually calls class Circle4’s toString

3
 Object Oriented Programming with Java

method. The Java compiler allows this “crossover” because an object of

a subclass is an object of its superclass.

Assigning a superclass object’s reference to a subclass-type variable

- Let us consider the following example:
public class PolyTest2{
public static void main(String args[])
{
Point3 point = new Point3(30,50);
Circle4 circle;//subclass-type variable
//assign superclass reference to subclass-type
variable circle = point;
}
}//end class
- If you run this program, it will generate an error. Because the assignment is not
allowed (incompatible type). The Java compiler prevents this assignment,
because a Point3 is not a Circle4- the “is-a” relationship applies only between
the subclass and its superclass.
- It turn out that the Java compiler does allow this assignment if we explicitly cast
the superclass reference to the subclass type. In programs that process superclass
and subclass objects by using superclass reference, only methods of the superclass
can be invoked via the superclass reference. Casting superclass reference to subclass
reference (also known as downcasting) enables a program to invoke subclass
functionality to perform subclass-specific operations on subclass objects.
N.B. assigning the reference of a superclass object to a subclass-type variable
(without an explicit cast) is a compile-time error

Subclass Method calls via superclass-type variables

- Consider the following program:
public class PolyTest3{
public static void main(String args[])
{
Point3 point;
Circle circle = new Circle4(120,89,2.7);
point = circle;//aim superclass reference at subclass object.
int x = point.getX();
int y = point.getY();
point.setX(10);
point.setY(20);
point.toString();
//attempt to invoke subclass-only (Circle4) method on
//subclass object through superclass (Point3) reference
double radius = point.getRadius();
point.setRadius(33.33);
double diameter = point.getDiameter();
double circumference = point.getCircumfrence();

4
 Object Oriented Programming with Java

double area = point.getArea();

}
}//end class

- In the above code, we have such an assignment: point = circle; Java compiler
allows this because a Circle4 is a Point3 object. Using point reference, we can
only invoke superclass only methods. But when we try to invoke subclass only
methods using point, the Java compiler generates error on each of these lines,
because these are not methods of the superclass Point3. (in this case, using a
Point3 variable, we can invoke only Point3 methods getX, getY, setX, setY
and toString)

Summary of the allowed assignments between superclass and subclass variables

- Despite the fact that a subclass object also is a superclass object, the subclass and
superclass objects are indeed different. As we have discussed previously, subclass
objects can be treated as if they were superclass objects. This is a logical
relationship, because the subclass contains all the members of the superclass, but
the subclass can have additional subclass-only members. For this reason,
assigning a superclass reference to a subclass-type variable is not allowed without
an explicit cast; such an assignment would leave the subclass-only members
undefined for the subclass object.

- We have discussed four ways to assign superclass and subclass references to

variables of superclass and subclass types:

1. Assigning a superclass reference to a superclass-type variable is straight forward

2. Assigning a subclass reference to a subclass-type variable is straight forward.
3. Assigning a subclass object’s reference to a superclass type variable is safe, because
the subclass object is an object of its superclass. However, this reference can be
used to invoke only superclass methods. If this code refers to subclass-only members
through the superclass variable, the compiler generates an error.
4. Attempting to assign a superclass object’s reference to a subclass type variable is a
compile-time error. To avoid the error, the superclass reference must be cast to a
subclass type explicitly.

Multiple inheritance and Interfaces

- An interface is like a class that can’t be instantiated. Its purpose is to specify a set
of requirements for a class to implement. These requirements are regarded as a
“contract” between the implementing class and any client class that uses it.
- An interface is a description of a capability. It lists the methods that a class must
implement to carry out that capability.
- An interface typically consists of declarations of related methods, although an
interface also may contain static and final fields that represent constants. In any
case, all interface members are public. A class that implements an interface
typically provides definitions for the methods declared in the interface.

5
 Object Oriented Programming with Java

- A class that implements an interface must provide an implementation for all the
method signatures in the interface. An interface declaration introduces a new
reference type whose members are constants and abstract methods.
- An interface is typically used in place of an abstract class when there is no default
implementation to inherit. i.e., no instance variables and no default methods
implementations.
- A compile-time error occurs if the identifier naming an interface appears as the
name of any other class or interface in the same package.
- All interface methods are abstract regardless of whether the term abstract
occurs. In more basic terms, an interface is abstract because an interface can’t be
instantiated as an object.
- Let us see an example here:
public interface Shape{
public double getArea();
public double getVolume();
public String getName();
}//end interface

public class Point extends Object implements

Shape{ private int x;
private int y;

public Point(int xValue,int yValue)

{
x = xValue;
y = yValue;
}

public void setX(int xValue)

{
x=xValue;
}

public void setY(int yValue)

{
y=yValue;
}

public int getX()

{
return x;
}

6
 Object Oriented Programming with Java

public int getY()

{
return y;
}

public double getArea()

{
return 0.0;
}

public double getVolume()

{
return 0.0;
}

public String getName()

{
return “Point”;
}

public String toString()

{
return “[”+getX()+ “, ”+getY()+ “]”;
}
}//end class

Use the Circle4 program and the following Cylinder class for the coming illustration

public class Cylinder extends Circle4{

private double height;

public Cylinder(int x,int y,double radius,double heightValue)

{
super(x,y,radius);
setHeight(heightValue);
}

public void setHeight(double heightValue)

{
height = (heightValue <0.0?0.0:heightValue);
}

public double getHeight()

{
return height;
}

7
 Object Oriented Programming with Java

public double getArea()

{
return 2 * super.getArea() + getCircumfrence() * getHeight();
}

public double getVolume()

{
return super.getArea() * getHeight();
}

public String getName()

{
return “Cylinder”;
}

public String toString()

{
return super.toString()+ “; Height = ” + getHeight();
}
}//end class

import javax.swing.*;
import java.text.*;

public class InterfaceTest{

public static void main(String args[])
{
DecimalFormat twoDigits = new DecimalFormat(“0.00”);
Point point =new Point(7,11);
Circle4 circle = new Circle4(22,8,3.5);
Cylinder cylinder = new Cylinder(20,30,3.3.3,10.75);
String output = point.getName()+ “:”+point+ “\n”+ circle.getName()
+ “:”+circle+ “\n”+ cylinder.getName() + “:”+cylinder+ “\n”;

Shape arrayOfShapes[] = new Shape[3];//create shape array

arrayOfShape[0] = point;
arrayOfShape[1] = circle;
arrayOfShape[2] = cylinder;

for(int i=0; i<arrayOfShapes.length;i++)

{
output += ”\n\n ”+arrayOfShapes[i].getName()+ “:” +

8
 Object Oriented Programming with Java

arrayOfShapes[i].toString()+ “\nArea =
”+twoDigits.format(arrayOfShapes[i].getArea())+ “\nVolume = ”+
twoDigits.format(arrayOfShapes[i].getVolume()); }

JOptionPane.showMessageDialog(null,output);
System.exit(0);
}
}//end class

- When a class implements an interface, the same “is-a” relationship provided

by inheritance applies. For example, class Point implements Shape. Therefore,
a Point object is a Shape. In fact, objects of any class that extends Point are
also Shape object.

Multiple inheritances
- A class can be derived from more than one superclass. This concept is called
multiple inheritance. But such a notion can’t be directly used in Java. Therefore,
one has to use an interface if a class is expected to inherit behaviors from more
than one superclass. For instance, Let us see the declaration of class Point:

public class Point extends Object implements

Shape{ }//end class

- In Java, all classes inherit from class Object. So whether we write the statement
“Point extends Object” or not, the Java compiler processes the inheritance
relationship among Point and Object classes. Therefore, our class Point will have
both the functionality of class Object and that of Shape, hence multiple
inheritance. The point to be underlined here is, multiple inheritance is only
possible through the use of interfaces.
- To summarize the discussion of interface; lets see the following comparison.

Unlike a class, an interface:

- Declares only method headers and public constants;
- Has no constructors
- Can’t be instantiated
- Can be implements by a class
- Can’t be implemented by an interface
- Can’t extends a class
- Can extend several other interfaces.

- Interface are very useful for specifying what a class should be able to do, while
deferring to a later time how the contract should be implemented. But in some
cases, interfaces are too restrictive. They allow no variable definitions (except
public final constants) or executable statements. Often, it is better to proceed with
a partial class implementation, deferring only those methods that depend directly
upon the backing data structure. That is when an abstract class should be used.