Goodrich 6e Ch02 ObjectOriented
Goodrich 6e Ch02 ObjectOriented
Terminology
Each object created in a program is an instance ()
of a class.
Each class presents to the outside world a concise and
consistent view of the objects that are instances of
this class, without going into too much unnecessary
detail or giving others access to the inner workings of
the objects.
The class definition typically specifies instance
variables, also known as data members, that the
object contains, as well as the methods, also known
as member functions, that the object can execute.
2
Goals
Robustness
We want software to be capable of handling
unexpected inputs that are not explicitly defined
for its application.
Adaptability
Software needs to be able to evolve over time in
response to changing conditions in its
environment.
Reusability
The same code should be usable as a component
of different systems in various applications.
3
Abstract Data Types
Abstraction is to distill a system to its most
fundamental parts.
Applying the abstraction paradigm to the design of data
structures gives rise to abstract data types (ADTs).
An ADT is a model of a data structure that specifies the
type of data stored, the operations supported on
them, and the types of parameters of the operations.
An ADT specifies what each operation does, but not
how it does it.
The collective set of behaviors supported by an ADT is
its public interface.
4
Object-Oriented Design Principles
Modularity
Abstraction
Encapsulation
5
Interfaces and Abstract Classes
The main structural element in Java that enforces an
application programming interface (API) is an interface.
An interface is a collection of method declarations with
no data and no bodies.
Interfaces do not have constructors and they cannot be
directly instantiated.
When a class implements an interface, it must implement all of
the methods declared in the interface.
An abstract class also cannot be instantiated, but it can
define one or more common methods that all
implementations of the abstraction will have.
6
Design Patterns
Algorithmic patterns: Software design
Recursion patterns:
Amortization Iterator
Divide-and-conquer Adapter
Prune-and-search Position
Brute force Composition
Dynamic programming Template method
The greedy method Locator
Factory method
7
Object-Oriented Software Design
Responsibilities: Divide the work into different
actors, each with a different responsibility.
Independence: Define the work for each class
to be as independent from other classes as
possible.
Behaviors: Define the behaviors for each class
carefully and precisely, so that the consequences
of each action performed by a class will be well
understood by other classes that interact with it.
8
Unified Modeling Language (UML)
A class diagram has three portions.
1. The name of the class
2. The recommended instance variables
3. The recommended methods of the class.
9
Class Definitions
A class serves as the primary means for abstraction in
object-oriented programming.
In Java, every variable is either a base type or is a
reference to an instance of some class.
A class provides a set of behaviors in the form of
member functions (also known as methods), with
implementations that belong to all its instances.
A class also serves as a blueprint for its instances,
effectively determining the way that state information
for each instance is represented in the form of
attributes (also known as fields, instance variables,
or data members).
10
Constructors
A user can create an instance of a class by
using the new operator with a method
that has the same name as the class.
Such a method, known as a constructor,
has as its responsibility is to establish the
state of a newly object with appropriate
initial values for its instance variables.
11
Inheritance
A mechanism for a modular and hierarchical
organization is inheritance.
This allows a new class to be defined based upon an
existing class as the starting point.
The existing class is typically described as the base
class, parent class, or superclass, while the newly
defined class is known as the subclass or child class.
There are two ways in which a subclass can
differentiate itself from its superclass:
A subclass may specialize an existing behavior by providing a new
implementation that overrides an existing method.
A subclass may also extend its superclass by providing brand new
methods.
12
Inheritance and Constructors
Constructors are never inherited in Java; hence, every
class must define a constructor for itself.
All of its fields must be properly initialized, including any
inherited fields.
The first operation within the body of a constructor
must be to invoke a constructor of the superclass,
which initializes the fields defined in the superclass.
A constructor of the superclass is invoked explicitly by
using the keyword super with appropriate parameters.
If a constructor for a subclass does not make an
explicit call to super or this as its first command, then
an implicit call to super( ), the zero-parameter version
of the superclass constructor, will be made.
13
An Extended Example
A numeric progression is a sequence of numbers,
where each number depends on one or more of the
previous numbers.
An arithmetic progression determines the next number
by adding a fixed constant to the previous value.
A geometric progression determines the next number by
multiplying the previous value by a fixed constant.
A Fibonacci progression uses the formula Ni+1=Ni+Ni-1
14
The Progression Base Class
15
The Progression Base Class, 2
16
ArithmeticProgression Subclass
17
GeometricProgression Subclass
18
FibonacciProgression Subclass
19
Exceptions
Exceptions are unexpected events that occur during the
execution of a program.
An exception might result due to an unavailable
resource, unexpected input from a user, or simply a
logical error on the part of the programmer.
In Java, exceptions are objects that can be thrown by
code that encounters an unexpected situation.
An exception may also be caught by a surrounding
block of code that “handles” the problem.
If uncaught, an exception causes the virtual machine to
stop executing the program and to report an appropriate
message to the console.
20
Catching Exceptions
The general methodology
for handling exceptions is
a try-catch construct in
which a guarded fragment
of code that might throw
an exception is executed.
If it throws an exception, then that exception is
caught by having the flow of control jump to a
predefined catch block that contains the code to
apply an appropriate resolution.
If no exception occurs in the guarded code, all catch
blocks are ignored.
21
Throwing Exceptions
Exceptions originate when a piece of Java code finds
some sort of problem during execution and throws an
exception object.
This is done by using the throw keyword followed by
22
The throws Clause
When a method is declared, it is possible to explicitly
declare, as part of its signature, the possibility that a
particular exception type may be thrown during a call to
that method.
The syntax for declaring possible exceptions in a method
signature relies on the keyword throws (not to be
confused with an actual throw statement).
For example, the parseInt method of the Integer class
has the following formal signature:
public static int parseInt(String s) throws NumberFormatException;
23
Casting
Casting with Objects allows for conversion
between classes and subclasses.
A widening conversion occurs when a type
T is converted into a “wider” type U:
T and U are class types and U is a superclass of T.
T and U are interface types and U is a
superinterface of T.
T is a class that implements interface U.
Example:
CreditCard card = new PredatoryCreditCard(...);
24
Narrowing Conversions
A narrowing conversion occurs when a type
T is converted into a “narrower” type S.
T and S are class types and S is a subclass of T.
T and S are interface types and S is a subinterface
of T.
T is an interface implemented by class S.
In general, a narrowing conversion of
reference types requires an explicit cast.
Example:
PredatoryCreditCard pc = (PredatoryCreditCard) card;
25
Generics
Java includes support for writing generic classes and
methods that can operate on a variety of data types
while often avoiding the need for explicit casts.
The generics framework allows us to define a class in
terms of a set of formal type parameters, which can
then be used as the declared type for variables,
parameters, and return values within the class
definition.
Those formal type parameters are later specified when
using the generic class as a type elsewhere in a
program.
26
Syntax for Generics
Types can be declared using generic names:
27
Nested Classes
Java allows a class definition to be nested inside the
definition of another class.
The main use for nesting classes is when defining a
class that is strongly affiliated with another class.
This can help increase encapsulation and reduce undesired
name conflicts.
Nested classes are a valuable technique when
implementing data structures, as an instance of a
nested use can be used to represent a small portion
of a larger data structure, or an auxiliary class that
helps navigate a primary data structure.
28