Inheritance

About This Presentation

Title:

Inheritance

Description:

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, or base class – PowerPoint PPT presentation

Number of Views:41

Avg rating:3.0/5.0

Slides: 53

Provided by: JOHNL211

Category:

more less

Transcript and Presenter's Notes

Title: Inheritance

1
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, or base class
The derived class is called the child class or
subclass.
As the name implies, the child inherits
characteristics of the parent
That is, the child class inherits the methods and
data defined for the parent class

2
Inheritance

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

3
Inheritance

Inheritance relationships often are shown
graphically in a UML class diagram, with an arrow
with an open arrowhead pointing to the parent
class

Inheritance should create an is-a relationship,
meaning the child is a more specific version of
the parent
4
Deriving Subclasses

In Java, we use the reserved word extends to
establish an inheritance relationship

class Car extends Vehicle // class
contents

See Words.java (page 384)
See Book.java (page 385)
See Dictionary.java (page 386)

5
Book and Dictionary

public class Book
protected int pages 1500
//---------------------------------------------
-
// Prints a message about the pages of this
book.
//---------------------------------------------
-
public void pageMessage ()
System.out.println ("Number of pages "
pages)

public class Dictionary extends Book
private int definitions 52500
//---------------------------------------------
-------
// Prints a message using both local and
inherited values.
//---------------------------------------------
-------
public void definitionMessage ()
System.out.println ("Number of definitions
" definitions)
System.out.println ("Definitions per page
" definitions/pages)

Dictionary websternew Dictionary() webster.page
Message() webster.definitionMessage()
6
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

7
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
Protected variables and methods can be shown with
a symbol preceding them in UML diagrams

8
UML Diagram for Words
9
ShrinkingBall
10
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
See Words2.java (page 388)
See Book2.java (page 389)
See Dictionary2.java (page 390)

11
Book and Dictionary

public class Book2
protected int pages
public Book2 (int numPages)
pages numPages
public void pageMessage ()
System.out.println ("Number of pages "
pages)

public class Dictionary2 extends Book2
private int definitions
public Dictionary2 (int numPages, int
numDefinitions)
super (numPages)
definitions numDefinitions
public void definitionMessage ()
System.out.println ("Number of definitions
" definitions)
System.out.println ("Definitions per page
" definitions/pages)

Dictionary2 webster new Dictionary2 (1500,
52500) webster.pageMessage() webster.definitionM
essage()
12
The super Reference

A childs constructor is responsible for calling
the parents constructor
The first line of a childs constructor should
use the super reference to call the parents
constructor
The super reference can also be used to reference
other variables and methods defined in the
parents class

13
Super use in ShrinkingBall

public class ShrinkingBall extends Ball
private double shrinkRate
public ShrinkingBall(Position pos, double
radius, double vx, double vy, double shRate)
super(pos, radius, vx, vy)
shrinkRate shRate
public void move(int tu)
super.move(tu)
if (tu shrinkRate gt radius)
radius tu shrinkRate
else
radius 0

14
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

15
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
See Messages.java (page 392)
See Thought.java (page 393)
See Advice.java (page 394)

16
Book and Dictionary

public class Thought
// Prints a message.
public void message()
System.out.println ("I feel like I'm
diagonally parked in a " "parallel universe.")
System.out.println()

public class Advice extends Thought
// Prints a message. This method overrides the
parent's version.
// It also invokes the parent's version
explicitly using super.
public void message()
System.out.println ("Warning Dates in
calendar are closer " "than they appear.")
super.message()

Thought parked new Thought() Advice dates
new Advice() parked.message() dates.message()
// overridden
17
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

18
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

19
Class Hierarchies

A child class of one parent can be the parent of
another child, forming a class hierarchy

20
Class Hierarchies

Two children of the same parent are called
siblings
Common features should be put as high in the
hierarchy as is reasonable (otherwise code is
duplicated)
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

21
Hierarchies

Lets say we want to create a MovingRectangle
class
A MovingRectangle has a Position, velocity,
height and width
We already have Position and Ball classes
How can we create a class hierarchy?
Notice that both Ball and Moving Rectangle has-a
Position
Positioned Object?

22
First Try

Although this is better than previous, vx, vy
and the code for move is duplicated

23
Second Try

This is an example of overdoing inheritane.
Too many layers

24
Third Try

Here, no code duplication, no unnecessary
layers.
Given the current requirements, this seems like
the best hierarchy

25
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

26
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 objects class together along with some
other information

27
The Object Class

All objects are guaranteed to have a toString
method via inheritance
Thus the println method can call toString for any
object that is passed to it
See Academia.java (page 398)
See Student.java (page 399)
See GradStudent.java (page 400)

28
toString() Example

public class Student
protected String name
protected int numCourses
public Student (String studentName, int
courses)
name studentName
numCourses courses
public String toString()
String result "Student name " name
"\n "Number of courses " numCourses
return result

public class GradStudent extends Student
private String source
private double rate
public GradStudent (String studentName, int
courses,
String support, double
payRate)
super (studentName, courses)
source support
rate payRate
public String toString()
String result super.toString()
result "\nSupport source " source
"\n"
result "Hourly pay rate " rate
return result

Student susan new Student ("Susan",
5) GradStudent frank new GradStudent ("Frank",
3, "GTA", 12.75) System.out.println
(susan) System.out.println (frank)
29
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 (as we've seen) 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

30
Equals() example

public boolean equals(Object obj)
Ball b (Ball) obj // gets an exception if obj
is not of type Ball
if (position.equals(b.getPosition()) radius
b.radius
vx b.getVx() vy b.getVy() )
return true
else
return false

31
Indirect Use of Members

A protected or public member can be referenced
directly by name in the child class, as if it
were declared in the child class
But even if a method or variable is private, it
can still be accessed indirectly through parent
methods
See FoodAnalysis.java (page 403)
See FoodItem.java (page 404)
See Pizza.java (page 405)

32
FoodItem

public class FoodItem
final private int CALORIES_PER_GRAM 9
private int fatGrams
protected int servings
public FoodItem (int numFatGrams, int
numServings)
fatGrams numFatGrams
servings numServings
private int calories()
return fatGrams CALORIES_PER_GRAM
public int caloriesPerServing()
return (calories() / servings)

public class Pizza extends FoodItem
// Sets up a pizza with the specified amount of
fat (assumes
// eight servings).
public Pizza (int fatGrams)
super (fatGrams, 8)

33
Polymorphism

Lets say a Vector v contains MovingRectangle and
Ball objects.
We want to move all the objects by one time unit

for (int i 0 i lt v.size() v)
Object o v.get(i)
if (o instanceof MovingRectangle)
MovingRectangle mr (MovingRectangle) o
mr.move(1)
else
Ball b (Ball) o
b.move(1)

34
Polymorphism

Regardless of the class of the object, we end up
calling the same method, Movingobject.setVx()
Cant we treat all objects simply as
MovingObjects?

for (int i 0 i lt v.size() i) MovingObject
mo (MovingObject)v.get(i) mo.move(1)
35
Polymorphism

The term polymorphism literally means "having
many forms"
A polymorphic reference is a variable that can
refer to different types of objects at different
points in time
The method invoked through a polymorphic
reference can change from one invocation to the
next
All object references in Java are potentially
polymorphic

36
Polymorphism

Suppose we create the following reference
variable
Occupation job
Java allows this reference to point to an
Occupation object, or to any object of any
compatible type
This compatibility can be established using
inheritance or using interfaces
Careful use of polymorphic references can lead to
elegant, robust software designs

37
References and Inheritance

An object reference can refer to an object of its
class, or to an object of any class related to it
by inheritance
For example, if the Holiday class is used to
derive a child class called Christmas, then a
Holiday reference could be used to point to a
Christmas object

Holiday day day new Christmas()
38
References and Inheritance

Assigning a predecessor object to an ancestor
reference is considered to be a widening
conversion, and can be performed by simple
assignment
Assigning an ancestor object to a predecessor
reference can be done also, but it is considered
to be a narrowing conversion and must be done
with a cast
The widening conversion is the most useful
An Object reference can be used to refer to any
object
An ArrayList is designed to hold Object references

39
The set of int values is a wider set than the set
of byte values, and contains all members of the
byte values set.
int
byte
byte b 2 int a b //widening conversion b
a // narrowing conversion, invalid b (byte) a
// this is ok Holiday h new Holiday() Christma
s ch h // invalid, not all //holidays
are christmas
Holiday
Christmas
40
Polymorphism via Inheritance

It is the type of the object being referenced,
not the reference type, that determines which
method is invoked
Suppose the Holiday class has a method called
celebrate, and the Christmas class overrides it
Now consider the following invocation
day.celebrate()
If day refers to a Holiday object, it invokes the
Holiday version of celebrate if it refers to a
Christmas object, it invokes the Christmas version

41
Polymorphism via Inheritance