Inheritance
Inheritance
Inheritance allows a software developer to derive a new class
from an existing one
The existing class is called the parent class or superclass
The derived class is called the child class or subclass.
Creates an is-a relationship
The subclass is a more
specific version of the Book
Original
(Remember has-a is
Dictionary Novel
aggregation.)
Mystery Romance 2
Inheritance
The child class inherits the methods and data
defined for the parent class
To tailor a derived class, the programmer can
add new variables or methods, or can modify the
inherited ones
Software reuse is at the heart of inheritance
By using existing software components to create
new ones, we capitalize on all the effort that
went into the design, implementation, and
testing of the existing software
Deriving Subclasses
In Java, we use the reserved word extends to
establish an inheritance relationship
class Dictionary extends Book {
// class contents
}
4
Dictionary webster = new Dictionary();
[Link](); Number of pages: 1500
[Link](); Number of definitions: 52500
Definitions per page: 35
public class Book {
protected int pages = 1500;
public String message() {
[Link](“Number of pages: ” + pages);
}
}
public class Dictionary extends Book {
private int definitions = 52500;
public void defMessage() {
[Link](“Number of definitions” +
definitions);
[Link](“Definitions per page: ” +
(definitions/pages));
}
}
Some Inheritance Details
An instance of a child class does not rely on an
instance of a parent class
Hence we could create a Dictionary object without
having to create a Book object first
Inheritance is a one-way street
The Book class cannot use variables or methods
declared explicitly in the Dictionary class
The protected Modifier
Visibility modifiers determine which class
members are inherited and which are not
Variables and methods declared with public
visibility are inherited; those with private
visibility are not
But public variables violate the principle of
encapsulation
There is a third visibility modifier that helps in
inheritance situations: protected
7
The protected Modifier
The protected modifier allows a member of a
base class to be inherited into a child
Protected visibility provides
more encapsulation than public visibility does
the best possible encapsulation that permits inheritance
8
The super Reference
Constructors are not inherited, even though they
have public visibility
Yet we often want to use the parent's constructor
to set up the "parent's part" of the object
The super reference can be used to refer to the
parent class, and often is used to invoke the
parent's constructor
9
The super Reference
A child’s constructor is responsible for calling the
parent’s constructor
The first line of a child’s constructor should use
the super reference to call the parent’s
constructor
The super reference can also be used to
reference other variables and methods defined
in the parent’s class
public class Book {
protected int pages;
Book(int numPages) {
pages = numPages;
}
}
public class Dictionary {
private int definitions;
Dictionary(int numPages, int numDefinitions) {
super(numPages);
definitions = numDefinitions;
}
}
Multiple Inheritance
Java supports single inheritance, meaning that a derived
class can have only one parent class
Multiple inheritance allows a class to be derived from two
or more classes, inheriting the members of all parents
Collisions, such as the same variable name in two
parents, have to be resolved
Java does not support multiple inheritance
In most cases, the use of interfaces gives us aspects of
multiple inheritance without the overhead.
Overriding Methods
When a child class defines a method with the same
name and signature as a method in the parent class, we
say that the child’s version overrides the parent’s version
in favor of its own.
Signature: method’s name along with number, type,
and order of its parameters
The new method must have the same signature as the
parent's method, but can have a different body
The type of the object executing the method determines
which version of the method is invoked
13
Overriding
A parent method can be invoked explicitly using
the super reference
If a method is declared with the final modifier,
it cannot be overridden
The concept of overriding can be applied to data
and is called shadowing variables
Shadowing variables should be avoided
because it tends to cause unnecessarily
confusing code
public class Book {
protected int pages;
Book(int numPages) {
pages = numPages;
}
public void message() {
[Link](“Number of pages: ” + pages);
}
}
public class Dictionary {
protected int definitions;
Dictionary(int numPages, int numDefinitions) {
super(numPages);
definitions = numDefinitions;
}
public void message() {
[Link](“Number of definitions” +
definitions);
[Link](“Definitions per page: ” +
(definitions/pages));
[Link]();
}
}
Overloading vs. Overriding
Don't confuse the concepts of overloading and overriding
Overloading deals with multiple methods with the same
name in the same class, but with different signatures
Overriding deals with two methods, one in a parent class
and one in a child class, that have the same signature
Overloading lets you define a similar operation in
different ways for different data
Overriding lets you define a similar operation in different
ways for different object types
16
Class Hierarchies
A child class of one parent can be the parent of
another child, forming a class hierarchy
Book
Dictionary Novel
Mystery Romance
17
Class Hierarchies
Two children of the same parent are called siblings
However they are not related by inheritance because
one is not used to derive another.
Common features should be put as high in the hierarchy
as is reasonable
An inherited member is passed continually down the line
Therefore, a child class inherits from all its ancestor
classes
There is no single class hierarchy that is appropriate for
all situations
18
The Object Class
A class called Object is defined in the
[Link] package of the Java standard class
library
All classes are derived from the Object class
If a class is not explicitly defined to be the child
of an existing class, it is assumed to be the child
of the Object class
Therefore, the Object class is the ultimate root
of all class hierarchies
19
The Object Class
The Object class contains a few useful methods, which
are inherited by all classes
For example, the toString method is defined in the
Object class
Every time we have defined toString, we have
actually been overriding an existing definition
The toString method in the Object class is defined to
return a string that contains the name of the object’s
class together along with some other information
Allobjects are guaranteed to have a toString
method via inheritance, thus the println method
can call toString for any object that is passed to it
The Object Class
The equals method of the Object class
returns true if two references are aliases
We can override equals in any class to define
equality in some more appropriate way
The String class defines the equals method
to return true if two String objects contain the
same characters
Therefore the String class has overridden the
equals method inherited from Object in favor
of its own version