Chapter 8 Class Inheritanc and Interfaces

Chapter 8 Class Inheritance and
Superclasses and Subclasses
Keywords: super
Overriding methods
The Object Class
Modifiers: protected, final and abstract
Abstract classes
Polymorphism and Object Casting
Inner Classes
Superclasses and Subclasses
Circle Methods
Circle Data
UML Diagram
Circle Methods
Cylinder Methods
Circle Data
Cylinder Data
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
Create a Cylinder object and
explore the relationship between the
Cylinder and Circle classes.
 Objective:
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:
To call a superclass constructor
To call a superclass method
You must use the keyword
super to call the superclass
constructor. Invoking a
superclass constructor’s name
in a subclass causes a syntax
error. Java requires that the
statement that uses the
keyword super appear first in
the constructor.
A constructor is used to
construct an instance of a
class. Unlike properties and
methods, a superclass's
constructors are not
inherited in the subclass.
They can only be invoked from
the subclasses' constructors,
using the keyword super. If
the keyword super is not
Example on Calling Superclass’s
public class C1 extends C2 {
public static void main(String[] args) {
new C1();
public C1() {
System.out.println("C1's default constructor is
class C2 extends C3 {
public C2() {
System.out.println("C2's default constructor is
class C3 {
public C3() {
System.out.println("C3's default constructor is
If a superclass defines
constructors other than a
default constructor, the
subclass cannot use the
default constructor of the
superclass, because in this
case the superclass does not
have a default constructor.
Example on the Impact of a Superclass with
no Default Constructor
public class A extends B {
class B {
public B(String name) {
System.out.println("B's constructor is
Example 8.2
Overriding Methods in the Superclass
The Cylinder class overrides the
findArea() method defined in the
Circle class.
An instance method can be
overridden only if it is
accessible. Thus a private
method cannot be overridden,
because it is not accessible
outside its own class. If a
method defined in a subclass
is private in its superclass,
the two methods are
completely unrelated.
Like an instance method, a
static method can be
inherited. However, a static
method cannot be overridden.
If a method defined in the
superclass is redefined in a
subclass, the method defined
in the superclass is hidden.
The Object Class
 The
Object class is the root of all Java classes.
 The
equals() method compares the
contents of two objects.
 The
toString() method returns a string
representation of the object.
 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 == comparison operator is
used for comparing two primitive
data type values or for
determining whether two objects
have the same references. The
equals method is intended to
test whether two objects have
the same contents, provided that
the method is modified in the
defining class of the objects.
The Object Class, cont.
 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
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
The protected Modifier, cont.
pacakge p1
class C1
protected int x
class C3
C1 c1;
c1.x can be read or
pacakge p2
class C2 extends C1
x can be read or
modified in C2
class C4
C1 c1;
c1.x cannot be read
nor modified
A subclass may override a
protected method in its
superclass and change its
visibility to public.
However, a subclass cannot
weaken the accessibility of
a method defined in the
superclass. For example, if
a method is defined as
public in the superclass, it
The modifiers are used on
classes and class members
(data and methods), except
that the final modifier can
also be used on local
variables in a method. A
final local variable is a
constant inside a method.
The final Modifier
The final class cannot be extended:
final class Math {
The final variable is a constant:
final static double PI = 3.14159;
The final method cannot be
modified by its subclasses.
The abstract Modifier
 The
abstract class
– Cannot be instantiated
– Should be extended and implemented in
 The
abstract method
– Method signature without
Abstract Classes
UML Notation:
The abstract class name and the abstract
method names are italicized.
-color: String
-filled: boolean
+getColor(): String
+setColor(String color): void
+isFilled(): boolean
+setFilled(boolean filled): void
+findArea(): double
+findPerimeter(): double
-radius: double
-length: double
+getRadius(): double
+setRadius(radius: double): void
+getLength(): double
+setLength(length: double): void
+findVolume(): double
-width: double
-length: double
+getWidth(): double
+setWidth(width: double): void
+getLength(): double
+setLength(length: double): void
An abstract method cannot be
contained in a nonabstract
class. If a subclass of an
abstract superclass does not
implement all the abstract
methods, the subclass must
be declared abstract. In
other words, in a
nonabstract subclass
extended from an abstract
An abstract class cannot be
instantiated using the new
operator, but you can still
define its constructors,
which are invoked in the
constructors of its
subclasses. For instance,
the constructors of
GeometricObject are invoked
in the Circle class and the
A class that contains
abstract methods must be
abstract. However, it is
possible to declare an
abstract class that contains
no abstract methods. In this
case, you cannot create
instances of the class using
the new operator. This class
is used as a base class for
A subclass can be abstract
even if its superclass is
concrete. For example, the
Object class is concrete,
but its subclasses, such as
GeometricObject, may be
A subclass can override a
method from its superclass
to declare it abstract. This
is rare, but useful when the
implementation of the method
in the superclass becomes
invalid in the subclass. In
this case, the subclass must
be declared abstract.
You cannot create an
instance from an abstract
class using the new
operator, but an abstract
class can be used as a data
type. Therefore, the
following statement, which
creates an array whose
elements are of
GeometricObject type, is
Cylinder inherits the
findPerimeter method from Circle.
If you invoke this method on a
Cylinder object, the perimeter of
a circle is returned. This method
is not useful for Cylinder
objects. It would be nice to
remove or disable it from
Cylinder, but there is no good way
to get rid of this method in a
subclass once it is defined as
Polymorphism, Dynamic Binding
and Generic Programming
Polymorphism refers to the ability to determine at
runtime which code to run, given multiple methods
with the same name in different classes in an
inheritance hierarchy. This ability is also known as
dynamic binding.
Polymorphism allows methods to be used
generically for a wide range of object arguments.
This is known as generic programming.
Example 8.3
Testing Polymorphism
 Objective:
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
Matching a method signature
and binding a method
implementation are two
issues. The compiler finds a
matching method according to
parameter type, number of
parameters, and order of the
parameters at compilation
time. A method may be
implemented in several
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.
 What
Is an Interface?
 Creating
an Interface
 Implementing
 What
an Interface
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;
return o2;
Example 8.5
Using Interfaces
 Objective:
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.
The interface name and the
method names are italicized.
The dashed lines and hollow
triangles are used to point to
the interface.
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
Interfaces vs. Abstract Classes,
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,
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
 Objective:
uses the Cloneable interface to
mark classes cloneable and uses the clone
method to copy objects.
Example 8.6
Cloning Objects, cont.
c1: CloneableCircle
radius = 5
creator =
{"Yong", ‘D’, "Liang")
c2: CloneableCircle
radius = 5
creator =
{"Yong", ‘D’, "Liang")
creator: Name
firstname = "Yong"
mi = ‘D’
firstname = "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.
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 inner
Inner Classes (cont.)
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.
Event-driven programming is introduced in
Chapter 8, "Getting Started with Graphics
An inner class is only for supporting the work of
its containing outer class, and it cannot be used
by other classes.

similar documents