Object Oriented

Programming

Inheritance
 Inheritance
 Inheritance is a fundamental object-oriented
design technique used to create and organize
reusable classes
 We will focuses on:
 deriving new classes from existing classes
 the protected modifier
 creating class hierarchies
 abstract classes
 indirect visibility of inherited members
 designing for inheritance
8-2
 Outline
• Creating Subclasses
• Overriding Methods
• Class Hierarchies
• Inheritance and Visibility
• Designing for Inheritance
• Inheritance and GUIs
• The Timer Class

8-3
 Creating a Subclass

 A class is to an Object what a blueprint is to a house

 A class establishes the characteristics and the

behaviors of the object

 No memory space is reserved for the data (variables)

 Classes are the plan; objects are the embodiment of

that plan

 Many houses can be built from the same blueprint

8-4
 Inheritance

 Inheritance allows a software developer to derive a new class from an existing

one

 The existing class is called the parent class, or super class, or base class

 The derived class is called the child class or subclass

 As the name implies, the child inherits characteristics of the parent

8-5
 Inheritance

 That is, the child class inherits the methods and data defined
by the parent class

 We can refer to these inherited methods and variables as if

they were declared locally in the class

8-6
 Inheritance
 Inheritance relationships are shown in a UML
class diagram using a solid arrow with an unfilled
triangular arrowhead pointing to the parent class
Vehicle

Car
• Proper inheritance creates an is-a relationship,
meaning the child is a more specific version of the
parent

8-7
 Inheritance
 A programmer can tailor a derived class as needed
by adding new variables or methods, or by
modifying the inherited ones

 Software reuse is a fundamental benefit 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
8-8
 Deriving Subclasses
 In Java, we use the reserved word extends
to establish an inheritance relationship

class Car extends Vehicle

{
// class contents
}

8-9
8-10
8-11
8-12
 The protected Modifier
 Visibility modifiers affect the way that class members can
be used in a child class

 Variables and methods declared with private visibility

cannot be referenced by name in a child class

 They can be referenced in the child class if they are

declared with public visibility -- but public variables
violate the principle of encapsulation

 There is a third visibility modifier that helps in inheritance

situations: protected

8-13
 The protected Modifier
 The protected modifier allows a child class to reference
a variable or method directly in the child class

 It provides more encapsulation than public visibility, but is

not as tightly encapsulated as private visibility

 A protected variable is visible to any class in the same

package as the parent class

 The details of all Java modifiers are discussed in Appendix

E (Page 683) (Lotus Book)

8-14
 The protected Modifier
 Protected variables and methods can be shown with a hash (
# )symbol preceding them in UML diagrams

 NOTE:
 All methods & variables (even those declared private) are inherited by
the child class

 Their definitions exist and memory is reserved for the variables

 However they CANNOT be referenced by name

8-15
 Class Diagram for Words
Book
# pages : int

+ pageMessage() : void

Words Dictionary
- definitions : int
+ main (args : String[]) : void
+ definitionMessage() : void

© 2004 Pearson Addison-Wesley. All rights 8-16

reserved
 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

8-17
8-18
8-19
8-20
 The super Reference

 A child’s constructor is responsible for calling the parent’s

constructor

 If the child constructor invokes the parent (constructor) by

using the super reference, it
MUST be the first line of code of the constructor
 The super reference can also be used to reference other
variables and methods defined in the parent class

8-21
 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

8-22
 Overriding Methods

 A child class can override the definition of an inherited method in favor of its
own

 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

8-23
8-24
8-25
8-26
 Overriding
 A method in the parent class 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

8-27
 Overloading vs. 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
parameters

 Overriding lets you define a similar operation in different ways for different
object types

8-28
 Class Hierarchies
 A child class of one parent can be the parent of another
child, forming a class hierarchy
Business

RetailBusiness ServiceBusiness

KMart Macys Kinkos

8-29
 Class Hierarchies
 Two children of the same parent are called siblings

 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

8-30
 The Object Class
 A class called Object is defined in the java.lang 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

8-31
 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 define the toString method, we are actually
overriding an inherited definition
 The toString method in the Object class is defined to return a
string that contains the name of the object’s class along with some
other information.
8-32
 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
 As we've seen, the String class defines the equals method to
return true if two String objects contain the same characters
 The designers of the String class have overridden the equals
method inherited from Object in favor of a more useful version

8-33