Object-Oriented Programming

with Java
Inheritance

Quan Thanh Tho, Ph.D.

CSE – HCMUT
[email protected]
 Class Inheritance and Interfaces

! Superclasses and Subclasses

! Keywords: super
! Overriding methods
! The Object Class
! Modifiers: protected, final and
abstract
! Abstract classes
! Polymorphism and Object Casting
! Interfaces
! Inner Classes
Superclasses and Subclasses
Superclass Circle Circle Methods Circle Data

Inheritance

Cylinder Circle Methods Circle Data

Subclass
Cylinder Methods Cylinder Data

Superclass Subclass

Circle Cylinder
UML Diagram -radius
-length
+getRadius
+setRadius +getLength
+findArea +setLength
+findVolume
Creating a Subclass
Creating a subclass extends properties and
methods from the superclass. You can also:
! Add new properties
! Add new methods
! Override the methods of the superclass

Cylinder Class
 Example 8.1
Testing Inheritance
l Objective: Create a Cylinder object and
explore the relationship between the
Cylinder and Circle classes.

TestCylinder Run
Using the Keyword super
The keyword super refers to the superclass
of the class in which super appears. This
keyword can be used in two ways:
l To call a superclass constructor
l To call a superclass method
Example 8.2
Overriding Methods in the Superclass

The Cylinder class overrides the

findArea() method defined in the
Circle class.

Cylinder

TestOverrideMethods Run
The Object Class
l The Object class is the root of all Java
classes.

l The equals() method compares the

contents of two objects.

l The toString() method returns a string

representation of the object.

l The clone() method copy objects

The Object Class, cont.
The equals() method compares the
contents of two objects. The default
implementation of the equals
method in the Object class is
as follows:

public boolean equals(Object obj)

{
return (this == obj);
}
The Object Class, cont.
l The toString() method returns a string
representation of the object. The default
implementation returns a string
consisting of a class name of
which the object is an instance,
the at sign (@), and a number
representing this object.

The clone() method copy objects

 The Object Class, cont.
To create a new object with
separate memory space, you need to
use the clone() method, as follows:

newObject = someObject.clone();

NOTE: Not all objects can be

cloned. For an object to be
cloneable, its class must implement
the java.lang.Cloneable interface.
Interfaces are introduced in the
section "Interfaces," in this
 The protected Modifier

l The protected modifier can be applied on

data and methods in a class. A protected data
or a protected method in a public class can
be accessed by any class in the same
package or its subclasses, even if the
subclasses are in a different package.
The protected Modifier, cont.

pacakge p1 pacakge p2

class C1 class C2 extends C1

protected int x x can be read or

modified in C2

class C3 class C4

C1 c1; C1 c1;
c1.x can be read or c1.x cannot be read
modified nor modified
The final Modifier
l The final class cannot be extended:
final class Math
{...}

l The final variable is a constant:

final static double PI = 3.14159;

l The final method cannot be

modified by its subclasses.
The abstract Modifier
l The abstract class
¡Cannot be instantiated
¡Should be extended and implemented in
subclasses

l The abstract method

¡Method signature without
implementation
 Abstract Classes
UML Notation:
The abstract class name and the abstract
method names are italicized.
Circle Cylinder

Object GeometricObject -radius: double -length: double

-color: String +getRadius(): double +getLength(): double

-filled: boolean +setRadius(radius: double): void +setLength(length: double): void
+findVolume(): double
+getColor(): String
+setColor(String color): void
+isFilled(): boolean
+setFilled(boolean filled): void
+findArea(): double
Rectangle
+findPerimeter(): double
-width: double
-length: double

+getWidth(): double
+setWidth(width: double): void
+getLength(): double
+setLength(length: double): void

GeometricObject Circle Cylinder Rectangle

Polymorphism and Dynamic Binding

Polymorphism refers to the ability to

determine at runtime which code to run,
given multiple methods with the same
name but different operations in the
same class or in different classes. This
ability is also known as dynamic binding.
 Example 8.3
Testing Polymorphism

lObjective: This example creates two

geometric objects: a circle, and a
rectangle, invokes the equalArea method
to check if the two objects have equal area,
and invokes the displayGeometricObject
method to display the objects.

TestPolymorphism Run
Casting Objects
It is always possible to convert a subclass to a
superclass. For this reason, explicit casting can be
omitted. For example,
Circle myCircle = myCylinder

is equivalent to
Circle myCircle = (Circle)myCylinder;
Casting from
Superclass to Subclass
Explicit casting must be used when casting an
object from a superclass to a subclass. This
type of casting may not always succeed.

Cylinder myCylinder = (Cylinder)myCircle;

The instanceof Operator
Use the instanceof operator to test whether
an object is an instance of a class:
Circle myCircle = new Circle();

if (myCircle instanceof Cylinder)

{
Cylinder myCylinder = (Cylinder)myCircle;
...
}
 Example 8.4
Casting Objects
This example creates two geometric objects:
a circle, and a cylinder, invokes the
displayGeometricObject method to display the
objects. The displayGeometricObject displays
the area and perimeter if the object is a circle,
and displays area and volume if the object is a
cylinder.

TestCasting Run
Interfaces
lWhat Is an Interface?
lCreating an Interface
lImplementing an Interface
lWhat is Marker Interface?
Creating an Interface
modifier interface InterfaceName
{
constants declarations;
methods signatures;
}
 Example of Creating an Interface

// This interface is defined in

// java.lang package
public interface Comparable
{
public int compareTo(Object o);
}
Generic max Method
public class Max
{
// Return the maximum between two objects
public static Comparable max
(Comparable o1, Comparable o2)
{
if (o1.compareTo(o2) > 0)
return o1;
else
return o2;
}
}
 Example 8.5
Using Interfaces

lObjective: Use the max method to find a

find the maximum circle between two
circles and a maximum cylinder between
two cylinders.
 Example 8.5, cont.
Notation:
The interface name and the
method names are italicized.
The dashed lines and hollow GeometricObject Circle Cylinder
triangles are used to point to - -
the interface.
java.lang.Comparable ComparableCircle ComparableCylinder
- -
compareTo

TestInterface Run
Interfaces vs. Abstract Classes

In an interface, the data must be

constants; an abstract class can have all
types of data.
Each method in an interface has only a
signature without implementation; an
abstract class can have concrete
methods. An abstract class must contain
at least one abstract method or inherit
from another abstract method.
Interfaces vs. Abstract Classes,
cont.

Since all the methods defined in an

interface are abstract methods, Java
does not require you to put the abstract
modifier in the methods in an interface,
but you must put the abstract modifier
before an abstract method in an abstract
class.
 Interfaces vs. Abstract Classes,
cont.

Interface1_2 Interface2_2

Interface1_1 Interface1 Interface2_1

Object Class1 Class2

The Cloneable Interfaces

Marker Interface: An empty interface.

A marker interface does not contain
constants or methods, but it has a special
meaning to the Java system. The Java
system requires a class to implement the
Cloneable interface to become cloneable.
public interface Cloneable
{
}
 Example 8.6
Cloning Objects

lObjective: uses the Cloneable interface to

mark classes cloneable and uses the
clone method to copy objects.

TestCloneable Run
Example 8.6
Cloning Objects, cont.

Memory

c1: CloneableCircle 5
radius = 5
creator = reference creator: Name
{"Yong", ‘D’, "Liang")
firstname = "Yong"
mi = ‘D’
firstname = "Liang"

c2: CloneableCircle 5
radius = 5
creator = reference
{"Yong", ‘D’, "Liang")
Inner Classes
Inner class: A class is a member of another
class.
Advantages: In some applications, you can
use an inner class to make programs
simple.
l An inner class can reference the data and
methods defined in the outer class in which
it nests, so you do not need to pass the
reference of the outer class to the
constructor of the innerShowInnerClass
class.
Inner Classes (cont.)
l Inner classes can make programs simple
and concise. As you see, the new class is
shorter and leaner. Many Java development
tools use inner classes to generate
adapters for handling events.
l An inner class is only for supporting the
work of its containing outer class, and it
cannot be used by other classes.