INHERITANCE,
POLYMORPHISM, CLASS
HIERARCHIES AND GENERICS
Introduction to Inheritance and Class
Hierarchies
2




Popularity of OOP is that it enables programmers
to reuse previously written code saved as classes
All Java classes are arranged in a hierarchy,
starting with Object, which is the superclass of all
Java classes
Inheritance in OOP is analogous to inheritance in
humans
Inheritance and hierarchical organization allow you
to capture the idea that one thing may be a
refinement or extension of another
Introduction to Inheritance and Class
Hierarchies (continued)
3
Is-a Versus Has-a Relationships
4




One misuse of inheritance is confusing the has-a
relationship with the is-a relationship
The has-a relationship means that one class has the
second class as an attribute
We can combine is-a and has-a relationships
The keyword extends specifies that one class is a
subclass of another
A Superclass and a Subclass
5


Consider two classes: Computer and Laptop
A laptop is a kind of computer and is therefore a
subclass of computer
Initializing Data Fields in a Subclass
and the No-Parameter Constructor
6


Private data fields belonging to a base class must
be initialized by invoking the base class’s
constructor with the appropriate parameters
If the execution of any constructor in a subclass does
not invoke a superclass constructor, Java
automatically invokes the no-parameter constructor
for the superclass
 Initializes
that part of the object inherited from the
superclass before the subclass starts to initialize its part
of the object
Protected Visibility for Superclass Data
Fields
7



Private data fields are not accessible to derived
classes
Protected visibility allows data fields to be
accessed either by the class defining it or any
subclass
In general, it is better to use private visibility
because subclasses may be written by different
programmers and it is always good practice to
restrict and control access to the superclass data
fields
Method Overriding
8



If a derived class has a method found within its
base class, that method will override the base
class’s method
The keyword super can be used to gain access to
superclass methods overridden by the base class
A subclass method must have the same return type
as the corresponding superclass method
Method Overloading
9



Method overloading: having multiple methods with
the same name but different signatures in a class
Constructors are often overloaded
Example:
 MyClass(int
inputA, int inputB)
 MyClass(float inputA, float inputB)
Polymorphism
10




A variable of a superclass type can reference an
object of a subclass type
Polymorphism means many forms or many shapes
Polymorphism allows the JVM to determine which
method to invoke at run time
At compile time, the Java compiler can’t determine
what type of object a superclass may reference but
it is known at run time
Abstract Classes, Assignment, and
Casting in a Hierarchy
11

An interface can declare methods but does not
provide an implementation of those methods
 Methods
declared in an interface are called abstract
methods


An abstract class can have abstract methods, data
fields, and concrete methods
Abstract class differs from a concrete class in that
 An
abstract class cannot be instantiated
 An abstract class can declare abstract methods, which
must be implemented in its subclasses
Abstract Classes and Interfaces
12


Like an interface, an abstract class can’t be
instantiated
An abstract class can have constructors to initialize
its data fields when a new subclass is created
 Subclass

uses super(…) to call the constructor
May implement an interface but it doesn’t have to
define all of the methods declared in the interface
 Implementation
is left to its subclasses
Abstract Class Number and the Java
Wrapper Classes
13
Summary of Features of Actual Classes,
Abstract Classes, and Interfaces
14
Class Object, Casting and Cloning
15


Object is the root of the class hierarchy; every class
has Object as a superclass
All classes inherit the methods defined in class
Object but may be overridden
The Method toString
16


You should always override the toString method if
you want to represent an object’s state
If you do not override it, the toString method for
class Object will return a string…just not the string
you want or are expecting
Operations Determined by Type of
Reference Variable
17



A variable can reference an object whose type is a
subclass of the variable type
The type of reference, not the type of the object
referenced, determines what operations can be
performed
Java is a strongly typed language so the compiler
always verifies that the type of the expression
being assigned is compatible with the variable type
Casting in a Class Hierarchy
18





Java provides casting to enable us to process one
object referenced by one type through a reference
variable of its actual type
Casting does not change the object referenced; it
creates an anonymous reference to that object
Downcast: cast a higher type to a lower type
The instanceof operator can guard against
ClassCastException errors
You can downcast an interface reference to the
specific implementation type
The Method Object.equals
19



The Object.equals method has a parameter of type
Object
Compares two objects to determine whether they
are equal
You must override the equals method if you want to
be able to compare two objects of a class
Cloning
20

The purpose of cloning in object-oriented
programming is analogous to cloning in biology
 Create


an independent copy of an object
Initially, both objects will store the same information
You can change one object without affecting the
other
The Shallow Copy Problem
21
The Object.clone method
22



Java provides the Object.clone method to help
solve the shallow copy problem
The initial copy is a shallow copy as the current
object’s data fields are copied
To make a deep copy, you must create cloned
copies of all components by invoking their
respective clone methods
Multiple Inheritance, Multiple
Interfaces, and Delegation
23


Multiple inheritance: the ability to extend more than
one class
Multiple inheritance is a language feature that is
difficult to implement and can lead to ambiguity
 Therefore,
Java does not allow a class to extend more
than one class
Using Multiple Interfaces to Emulate
Multiple Inheritance
24


If we define two interfaces, a class can implement
both
Multiple interfaces emulate multiple inheritance
Implementing Reuse Through
Delegation
25


You can reduce duplication of modifications and
reduce problems associated with version control
through a technique known as delegation
In delegation, a method of one class accomplishes
an operation by delegating it to a method of
another class
Packages
26





The Java API is organized into packages
The package to which a class belongs is declared by
the first statement in the file in which the class is defined
using the keyword package followed by the package
name
All classes in the same package are stored in the same
directory or folder
All the classes in one folder must declare themselves to
be in the same package
Classes that are not part of a package may access only
public members of classes in the package
Chapter 3: Inheritance and Class Hierarchies
The No-Package-Declared Environment
and Package Visibility
27

There exists a default package



Files that do specify a package are considered part of the
default package
If you don’t declare packages, all of your packages
belong to the same, default package
Package visibility sits between private and protected
Classes, data fields, and methods with package visibility are
accessible to all other methods of the same package but are not
accessible to methods outside of the package
 Classes, data fields, and methods that are declared protected are
visible to all members of the package

Chapter 3: Inheritance and Class Hierarchies
Visibility Supports Encapsulation
28




The rules for visibility control how encapsulation occurs
in a Java program
Private visibility is for members of a class that should
not be accessible to anyone but the class, not even the
classes that extend it
Package visibility allows the developer of a library to
shield classes and class members from classes outside
the package
Use of protected visibility allows the package
developer to give control to other programmers who
want to extend classes in the package
Visibility Supports Encapsulation
(continued)
29
A Shape Class Hierarchy
30
A Shape Class Hierarchy (continued)
31
A Shape Class Hierarchy (continued)
32
Introduction

Generics
 New
feature of J2SE 5.0
 Provide compile-time type safety
 Catch
invalid types at compile time
 Generic
methods
A
single method declaration
 A set of related methods
 Generic
A
classes
single class declaration
 A set of related clases
Motivation for Generic Methods

Overloaded methods
 Perform
similar operations on different types of data
 Overloaded printArray methods
array
 Double array
 Character array
 Integer
 Only
reference types can be used with generic methods
and classes
Motivation for Generic Methods (Cont.)

Study each printArray method
 Array
element type appears in two location
 Method
header
 for statement
 Combine
three printArray methods into one
 Replace the element types with a generic name E
 Declare one printArray method
 Display
array
the string representation of the elements of any
Generic Methods: Implementation and Compile-Time
Translation

Generic method declaration
 Type
parameter section
 Delimited
by angle brackets ( < and > )
 Precede the method’s return type
 Contain one or more type parameters

Also called formal type paramters
Generic Methods: Implementation and Compile-Time
Translation

Type parameter (Also known as type variable)




An identifier that specifies a generic type name
Used to declare return type, parameter types and local variable types
Act as placeholders for the types of the argument passed to the generic
method
 Actual type arguments
Can be declared only once but can appear more than once
public static < E > void printTwoArrays(
E[] array1, E[] array2 )
Generic Methods: Implementation and Compile-Time
Translation (Cont.)

Compile-time translation
 Erasure
 Remove
type parameter section
 Replace type parameters with actual types
 Default type is Object
Additional Compile-Time Translation Issues: Methods That Use
a Type Parameter as the Return Type

Application of Fig. 18.5



Generic method
Use Type parameters in the return type and parameter list
Generic interface


Specify, with a single interface declaration, a set of related
types
E.g., Comparable< T >

Method integer1.compareTo( integer2 )




Compare two objects of the same class
Return 0 if two objects are equal
Return -1 if integer1 is less than integer2
Return 1 if integer1 is greater than integer2
Additional Compile-Time Translation Issues: Methods That Use
a Type Parameter as the Return Type (Cont.)

Upper bound of type parameter
 Default
is Object
 Always use keyword extends
 E.g.,
T extends Comparable< T >
 When
compiler translates generic method to Java
bytecode
 Replaces
type parameter with its upper bound
 Insert explicit cast operation
e.g., line 23 of Fig. 18.5 I preceded by an Integer cast
(Integer) maximum( 3, 4, 5 )
Overloading Generic Method

Generic method may be overloaded
 By
another generic method
 Same
 By
non-generic methods
 Same

method name but different method parameters
method name and number of parameters
When compiler encounters a method call
 Search
 Exact
 Then
for most precise matching method first
method name and argument types
search for inexact but applicable matching
method
Generic Classes

Generic classes
 Use
a simple, concise notation to indicate the actual
type(s)
 At compilation time, Java compiler
 ensures
the type safety
 uses the erasure technique to enable client code to interact
with the generic class

Parameterized classes
 Also
called parameterized types
 E.g., Stack< Double >
Generic Classes (Cont.)

Generic class declaration
 Looks
like a non-generic class declaration
 Except class name is followed by a type parameter
section

The –Xlint:unchecked option
 Compiler
cannot 100% ensure type safety
Generic Classes (Cont.)

Generic class at compilation time
 Compiler
performs erasure on class’s type parameters
 Compiler replaces type parameters with their upper
bound

Generic class test program at compilation time
 Compiler
performs type checking
 Compiler inserts cast operations as necessary
Generic Classes (Cont.)

Creating generic methods to test class Stack< E
>

Method testPush


Perform same tasks as testPushDouble and
testPushInteger
Method testPop

Perform same tasks as testPopDouble and
testPopInteger
Wildcards in Methods That Accept Type Parameters

Data structure ArrayList
 Dynamically
 Method
resizable, array-like data structure
add
 Method toString
Wildcards in Methods That Accept Type Parameters

Motivation for using wildcards
 Implement
 Total
a generic method sum
the numbers in a collection
 Receive a parameter of type ArrayList< Number >
 Use method doubleValue of class Number to obtain the
Number’s underlying primitive value as a double value
Wildcards in Methods That Accept Type Parameters
(Cont.)

Implementing method sum with a wildcard type
argument in its parameter
is the superclass of Integer
 ArrayList< Number > is not a supertype of
ArrayList< Integer >
 Cannot pass ArrayList< Integer > to method
sum
 Number
Generics and Inheritance: Notes

Inheritance in generics
 Generic class can be derived from non-generic class
e.g., class Object is superclass of every generic class
 Generic class can be derived from another generic class
e.g., Stack is a subclass of Vector
 Non-generic class can be derived from generic class
e.g., Properties is a subclass of Hashtable
 Generic method in subclass can override generic method in superclass
 If both methods have the same signature
COLLECTIONS
Introduction

Java collections framework
 Contain
prepackaged data structures, interfaces,
algorithms
 Use generics
 Use existing data structures
 Example
 Provides
of code reuse
reusable components
Collections Overview

Collection
 Data
structure (object) that can hold references to other
objects

Collections framework
 Interfaces
declare operations for various collection
types
 Provide high-performance, high-quality implementations
of common data structures
 Enable software reuse
Some collection framework interfaces.
Interface
Description
Collection
The root interface in the collections hierarchy from which interfaces Set,
Queue and List are derived.
A collection that does not contain duplicates.
An ordered collection that can contain duplicate elements.
Associates keys to values and cannot contain duplicate keys.
Typically a first-in, first-out collection that models a waiting line; other
orders can be specified.
Set
List
Map
Queue
Class Arrays

Class Arrays
 Provides
static methods for manipulating arrays
 Provides “high-level” methods
 Method
binarySearch for searching sorted arrays
 Method equals for comparing arrays
 Method fill for placing values into arrays
 Method sort for sorting arrays
Interface Collection and Class Collections

Interface Collection
Root interface in the collection hierarchy
 Interfaces Set, Queue, List extend interface Collection

Set – collection does not contain duplicates
 Queue – collection represents a waiting line
 List – ordered collection can contain duplicate elements


Contains bulk operations


Adding, clearing, comparing and retaining objects
Provide method to return an Iterator object

Walk through collection and remove elements from collection
Interface Collection and Class Collections
(Cont.)

Class Collections
 Provides
static methods that manipulate collections
 Implement
 Collections


algorithms for searching, sorting and so on
can be manipulated polymorphically
Synchronized collection
Unmodifiable collection
Software Engineering Observation

The collections framework algorithms are
polymorphic. That is, each algorithm can operate
on objects that implement specific interfaces,
regardless of the underlying implementations.
Lists

List
 Ordered
Collection that can contain duplicate
elements
 Sometimes called a sequence
 Implemented via interface List
 ArrayList
 LinkedList
 Vector
Performance Tip

ArrayLists behave like Vectors without
synchronization and therefore execute faster than
Vectors because ArrayLists do not have the
overhead of thread synchronization.
Software Engineering Observation

LinkedLists can be used to create stacks,
queues, trees and dequeus (double-ended
queues, pronounced “decks”). The collections
framework provides implementations of some of
these data structures.
ArrayList and Iterator

ArrayList example
 Demonstrate
Collection interface capabilities
 Place two String arrays in ArrayLists
 Use Iterator to remove elements in ArrayList
LinkedList

LinkedList example
 Add
elements of one List to the other
 Convert Strings to uppercase
 Delete a range of elements
Linkedlist (Cont.)

static method asList of class Arrays
 View
an array as a List collection
 Allow programmer to manipulate the array as if it were
a list
 Any modification made through the List view change
the array
 Any modification made to the array change the List
view
 Only operation permitted on the view returned by
asList is set
Vector

Class Vector
 Array-like
data structures that can resize themselves
dynamically
 Contains a capacity
 Grows by capacity increment if it requires additional
space
Performance Tip


Inserting an element into a Vector whose current size is less than its
capacity is a relatively fast operation.
Inserting an element into a Vector that needs to grow larger to
accommodate the new element is a relatively slow operation.
Collections Algorithms

Collections framework provides set of algorithms
 Implemented
 List






as static methods
algorithms
sort
binarySearch
reverse
shuffle
fill
copy
Collections Algorithms
 Collection





min
max
addAll
frequency
disjoint
algorithms
Collections algorithms.
Algorithm
Description
sort
Sorts the elements of a List.
binarySearch
Locates an object in a List.
reverse
Reverses the elements of a List.
shuffle
Randomly orders a List’s elements.
fill
Sets every List element to refer to a specified object.
Copy
Copies references from one List into another.
min
Returns the smallest element in a Collection.
max
Returns the largest element in a Collection.
addAll
Appends all elements in an array to a collection.
frequency
Calculates how many elements in the collection are equal to the
specified element.
disjoint
Determines whether two collections have no elements in common.
Algorithm sort

sort

Sorts List elements




Sorting in ascending order


Collections method sort
Sorting in descending order


Order is determined by natural order of elements’ type
List elements must implement the Comparable interface
Or, pass a Comparator to method sort
Collections static method reverseOrder
Sorting with a Comparator

Create a custom Comparator class
Algorithm binarySearch

binarySearch
 Locates
object in List
 Returns
index of object in List if object exists
 Returns negative value if Object does not exist



Calculate insertion point
Make the insertion point sign negative
Subtract 1 from insertion point