Chapter 14 Object-Oriented Software Development

1
Chapter 14Object-Oriented Software Development
2
Object-Oriented Design
A technique for developing a program in which
the solution is expressed in terms of objects --
self- contained entities composed of data and
operations on that data.
3
Object Oriented Programming

• Programmer thinks about and defines the
  attributes and behavior of objects.
• Often the objects are modeled after real-world
  entities.
• Very different approach than function-based
  programming (like C).

4
Reasons for OOP

• Abstraction
• Polymorphism
• Inheritance
• Encapsulation
• Software Engineering Issues

5
Objects to Classes

• A class defines the pattern used when
  instantiating an object of that type.
• A class generally contains private data and
  public operations (called methods).

6
Class Object Types

• A C class is an object type.
• When you create the definition of a class you are
  defining the attributes and behavior of a new
  type.
• Attributes are data members.
• Behavior is defined by methods.

7
Creating an object

• Defining a class does not result in creation of
  an object.
• Declaring a variable of a class type creates an
  object. You can have many variables of the same
  type (class).
• Instantiation

8
Superclass and Subclass

• Inheritance enables us to define a new class
  (called a subclass) that inherits the properties
  of an already existing class.
• The newly derived class is then specialized by
  adding properties specific to it.
• The class being inherited from is the superclass.
• The class that inherits properties is the
  subclass.

9
Defining Objects

• An object-oriented program consists of many
  objects.
• An object is composed of identity, state
  (attributes, data, and their current values) and
  behavior (operations) .

10
Identity, State, Behavior

• Identity is the property of an object that
  distinguishes it from all other objects.
• The failure to recognize the difference between
  the name of the object and the object itself is
  the source of many errors in object-oriented (OO)
  programming.

11
Identity, State, Behavior

• The state of an object encompasses all of the
  (static) properties of the object plus the
  current (dynamic) values of each of these
  properties
• A property is an inherent or distinctive
  characteristic, trait, quality, or feature that
  contribute to making an object uniquely that
  object
• We will use the word attribute, or data member,
  to refer to the state of an object

12
Examples of State

• Properties
• Elevators travel up or down
• Vending machines accept coins
• Clocks indicate the current time
• Values
• Current floor
• Number of coins deposited
• The number of minutes since the last hour

13
Identity, State, Behavior

• Behavior is how an object acts and reacts, in
  terms of state changes and interactions with
  other objects.
• An operation is some action that one object
  performs upon another in order to elicit a
  reaction.
• We will use the word method to describe object
  behavior in C.
• Invoking a method causes the behavior to take
  place.

14
Classes

• Classes are the definitions (or blueprints) used
  to create objects. Id say descriptions of
  objects.
• To make a car the manufacturer must first have a
  design from which to build the first car. Then,
  once all the problems are worked out, the design
  is used to build all the cars of that model.

15
Objects

• An object is an instance of a class.
• If we have a class definition called Car, then we
  can think of Audi, BMW, and Corvette as each
  being an instance (object) of the class Car,
  i.e., they are each a type of car.

16
Object example
Audi 6
BMW Z3
Corvette
Car
Car
Car

• Notice that all objects are of the same type.
  All objects are cars!

17
Classes and Objects

• An object is an instance of exactly one class
• Corvette can not be an instance of a car class
  and an instance of a plane class at the same
  time.
• An instance of a class, an object, belongs to
  that particular class.
• A Corvette is a car ? Corvette belongs to the
  class Car.

18
Classes

• Once a class is defined you can create as many
  instances of the class (objects from the class)
  as you would like.
• Once a blue print is completed for the 2004
  Porsche 911, Porsche will use an assembly line to
  build as many instances of the 2004 Porsche 911
  as they wish.

19
Defining a class

• Properties are variables which describe the
  essential characteristics of an object.
• Properties of a car color, model, make, how many
  doors, transmission type, direction of movement,
  etc.
• Behaviors are methods that describe how the
  object behaves and how the properties may be
  modified.
• Behavior of a car braking, changing gears,
  opening doors, moving forwards or backwards, etc.

20
Instance variables

• The class definition will include parameter
  definitions (properties) that represent data
  about a particular object, instance variables.
• Example, Joe's car may have 4 gallons of gas in
  it while John's car has 10 gallons.
• The amount of gas in each car may change without
  affecting the amount of gas in the any other
  cars.
• All instances (objects) of a class will have a
  set of instance variables that are specific to
  that individual object.
• The combination of the values of these instance
  variables is known as the objects state.

21
Instance variables
Car
MaxSpeed
Audi 6
BMW Z3
Corvette
Car
Car
Car
MaxSpeed 155
MaxSpeed 165
MaxSpeed 145
22
Class variables

• The class definitions may also include parameter
  definitions that represent data that is shared by
  all class instances (objects), called class
  variables.
• In the case of the car class, we will define a
  maximum allowed speed, by the law (variable
  MaxSpeed). This will be the same for each
  individual car.

23
Class variables
Car
MaxSpeed MaxSpeed155
Audi 6
BMW Z3
Corvette
Car
Car
Car
MaxSpeed 155
MaxSpeed 165
MaxSpeed 145
24
Class variables

• Class variables may also be used to keep track of
  things such as how many instances of a class
  exist.
• Example lets create a counter the records how
  many cars are in the garage.

25
Class variables
Car
MaxSpeed MaxSpeed155 NumCars 3
Audi 6
BMW Z3
Corvette
Car
Car
Car
MaxSpeed 155
MaxSpeed 165
MaxSpeed 145
26
Messages
Audi 6 turnOnHazard()

• For Humans
• Who the message is for.
• What we want the person to do.
• What information is needed to do it.

• For Objects
• The object to whom the message is being sent.
• The name of the method that object is to execute.
• Any parameters (variables) needed by that method.

27
Messages and Methods

• In order to process a message, an object needs to
  have a method defined for the requested task.
• A method is a small, well-defined piece of code
  that completes a specific task.
• For our previous example, we need to define a
  method to turn on the car's hazard lights.

28
Messages and Methods
Car
MaxSpeed MaxSpeed155 NumCars 3 turnOnHazard()
Audi 6
BMW Z3
Corvette
Car
Car
Car
MaxSpeed 155 turnOnHazard()
MaxSpeed 165 turnOnHazard()
MaxSpeed 145 turnOnHazard()
29
Instance methods

• Each class can have methods that are specific to
  each object, called instance methods.
• These can only affect that object's parameters,
  i.e., its instance variables.
• Example If BMW has 4 gallons of gas and someone
  puts 6 more gallons of gas in his/her car, the
  car now has 10 gallons. The amount of gas in Audi
  and Corvette is unchanged.

30
Messages and Methods
Car
MaxSpeed MaxSpeed155 NumCars
3 turnOnHazard() addGass(amount)
Audi 6
BMW Z3
Corvette
Car
Car
Car
MaxSpeed 155 turnOnHazard() addGass(amount)
MaxSpeed 165 turnOnHazard() addGass(amount)
MaxSpeed 145 turnOnHazard() addGass(amount)
31
Methods

• It is also possible that you want information
  from an object in this case, you would define a
  method that sends (returns) a message back to the
  requester containing that information.
• We need to know how much gas is in our cars, so
  we will create a new method that returns the
  value of Gas-Level variable for our car.

32
Messages and Methods
Car
MaxSpeed GasLevel MaxSpeed155 NumCars 3
Audi 6
BMW Z3
Corvette
Car
Car
Car
MaxSpeed 155 GasLevel 4 turnOnHazard() addGass
(amount) getGasLevel()GasLevel
MaxSpeed 165 GasLevel 10
MaxSpeed 145 GasLevel 6 turnOnHazard() addGass
(amount) getGasLevel()GasLevel
33
Class methods

• Class methods are used to get or manipulate
  information about all objects created from the
  class.
• Typically, class methods are changing class
  variables. For example
• Each time we move the car in or out of the
  garage, we need to add/subtract one to the number
  of cars carIn( ) carOut( )
• Also, we may want to know how many cars are
  actually in the garage getNumCars( )

34
Messages and Methods
Car
carIn()
carOut()
turnOnHazard()
getNumCars()NumCars
addGass(amount)
getGasLevel()GasLevel
Audi 6
BMW Z3
Corvette
Car
Car
Car
MaxSpeed 155 GasLevel 4 turnOnHazard() addGass
(amount) getGasLevel()GasLevel
MaxSpeed 165 GasLevel 10 turnOnHazard() addGas
s(amount) getGasLevel()GasLevel
MaxSpeed 145 GasLevel 6 turnOnHazard() addGass
(amount) getGasLevel()GasLevel
35
Object Oriented Programming

• When writing object-oriented programs, first one
  must define the classes (like Car).
• Then, while the program is running, the instances
  of the classes (objects) (such as Audi, BMW,
  Corvette in our example) are created.

36
Object Oriented Programming - Benefits

• An object can be written and maintained
  separately from the rest of the program,
  modularity.
• An object has a public face that it uses to
  communicate with other objects, but other objects
  can not directly access its instance variables,
  information hiding.

37
Information Hiding

• The interface to a class is the list of public
  data members and methods.
• The interface defines the behavior of the class
  to the outside world (to other classes and
  functions that may access variables of your class
  type).
• The implementation of your class doesn't matter
  outside the class only the interface.

38
Information Hiding (cont.)

• You can change the implementation and nobody
  cares! (as long as the interface is the same).
• You can use other peoples classes without fear!

39
Polymorphism

• The ability of different objects to respond to
  the same message in different ways.
• Tell an int to print itself cout ltlt i
• Now tell a double cout ltlt x
• Now tell the Poly cout ltlt poly

40
Inheritance

• You can create a new class that inherits from an
  existing class.
• You can add new members and methods.
• You can replace methods.
• The new class is a specialization of the existing
  class.

41
Inheritance

• All classes in C are organized into a class
  hierarchy.
• The highest level classes are very general and
  the lower level classes are more specific.
• The lower level classes are based upon the higher
  level classes and inherit instance variables and
  methods from those higher level class. They also
  may contain their own (new) instance variables
  and methods beyond the higher level class
  definition.

42
Inheritance

• A higher level class is called a superclass a
  lower level class is called a subclass.
• A subclass may also be a superclass
• Inheritance allows you to define certain
  behaviors once and then to reuse those behaviors
  over and over again in the subclasses. This is
  called reusability.

43
Inheritance Example

• Base class is shape, represents the abstract
  notion of a shape.
• Derived classes
• rectangle
• circle
• triangle.
• An object that is a circle is also a shape!

44
Inheritance Example

• Our Car class is very general.
• Let's define a new class called BMW that contains
  the parameters model, color, engine size.

45
Inheritance
Car
BMW
46
Inheritance

• Now let's define two new classes. One for the Z3
  and another for the 3 Series Sedan.
• What might be some of the differences between the
  two classes?
• Number of doors (3, 5)
• Roof (soft or hardtop)
• Therefore, we add variables NumDoors and Roof

47
Inheritance
Car
48
Views of the class

• A class can be viewed as a sort of contract that
  specifies what instances of the class can, and
  cannot do
• It is possible to distinguish between the outside
  and inside view of a class
• The interface of a class provides its outside
  view and emphasizes the abstraction
• The implementation of a class is its inside view

49
Access

• Most classes provide three levels of access to
  their members (state and behavior)
• Public
• The part of the class that is visible to all
  clients of the class
• Protected
• The part of the class that is only visible to
  subclasses of the class
• Private
• A part of the class that is not visible to any
  other classes

50
Private vs. Public

• Public data members and methods can be accessed
  outside the class directly.
• The public stuff is the interface.
• Private members and methods are for internal use
  only.

51
Protected Class members/methods

• We've already seen private and public.
• Protected means derived classes have access to
  data members and methods, but otherwise the
  members/methods are private.

52
Special Member Functions

• Constructors called when a new object is created
  (instantiated).
• can be many constructors, each can take different
  arguments.
• Destructor called when an object is eliminated
• only one, has no arguments.

53
Accessing Data Members

• Data members are available within each method (as
  if they were local variables).
• Public data members can be accessed by other
  functions using the member access operator "."
  (just like struct).

54
Accessing class methods

• Within other class methods, a method can be
  called just like a function.
• Outside the class, public methods can be called
  only when referencing an object of the class.

55
What happens here?

• class foo
• int i // elements in the array
• int a10 // array 10 at most
• // sum the elements
• int sum(void)
• int i, x0
• for (i0iltii)
• xai
• return(x)
• ...

which i is it ?
56
Class Scope Operator

• You can solve the previous problem using the ""
  operator classnamemembername.
• for (i0iltfooii)
• xai

57
Method names and

• Sometimes we put just a prototype for a member
  function within the class definition.
• The actual definition of the method is outside
  the class.
• You have to use to do this.

58
Example

• class foo
• ...
• int sum(void)
• int foosum(void)
• int sum0
• for (int i0iltfooii)
• sum ai
• return(sum)

59
Classes and Files

• The relationship between C class definitions
  and files depends on the compiler.
• In general you can put class definitions
  anywhere! Visual C wants one class per file.
• Most people do this
• class definition is in classname.h
• any methods defined outside of the class
  definition are in classname.cpp

60
static methods

• A static method is a class method that can be
  called without having an object.
• Must use the operator to identify the method.
• Method can't access non-static data members!
  (they don't exist unless we have an object).

61
Static Data Members

• It is possible to have a single variable that is
  shared by all instances of a class (all the
  objects).
• declare the variable as static.
• Data members that are static must be declared and
  initialize outside of the class.
• at global or file scope.

62
Static data member example

• class foo
• private
• static int cnt
• public
• foo()
• foocount
• cout ltlt "there are now " ltlt cnt
• ltlt " foo objects ltlt endl
• ...

63
Friends

• A Class can declare other classes as "friend
  classes".
• A Class can declare external functions as
  "friends".
• friends can access private members and methods.

64
Friend Declaration

• class foo
• private
• int i,j
• friend class fee
• friend int printfoo( foo f1)

65
Two Programming Paradigms
Structural (Procedural) Object-Oriented
PROGRAM PROGRAM
66
Object-Oriented Programming Language Features

• 1. Data abstraction
• 2. Inheritance of properties
• 3. Dynamic binding of operations to objects

67
OOP Terms C Equivalents

• Object Class object or class instance
• Instance variable Private data member
• Method Public member function
• Message passing Function call ( to a public
  member function )

68
What is an object?
OBJECT
set of methods (public member functions) interna
l state (values of private data members)
Operations Data
69
Inheritance Hierarchy Among Vehicles
Every car is a wheeled vehicle.
70
Inheritance

• is a mechanism by which one class acquires
  (inherits) the properties (both data and
  operations) of another class
• the class being inherited from is the Base Class
  (Superclass)
• the class that inherits is the Derived Class
  (Subclass)
• the derived class is then specialized by adding
  properties specific to it

71
class Time Specification

• // SPECIFICATION FILE ( time.h )
• class Time
• public
• void Set ( int hours , int minutes ,
  int seconds )
• void Increment ( )
• void Write ( ) const
• Time ( int initHrs, int initMins, int
  initSecs ) // constructor
• Time ( ) // default
  constructor
• private
• int hrs
• int mins
• int secs

71
72

Class Interface Diagram
Time class
Set
Private data hrs mins secs
Increment
Write
Time
Time
73
Using Inheritance to Add Features

• // SPECIFICATION FILE ( exttime.h)
• include time.h
• enum ZoneType EST, CST, MST, PST, EDT, CDT,
  MDT, PDT
• class ExtTime public Time
  // Time is the base class
• public
• void Set ( int hours, int minutes,
  int seconds ,
• 
  ZoneType timeZone )
• void Write ( ) const
• ExtTime ( int initHrs , int initMins ,
  int initSecs ,
• ZoneType initZone )
  // constructor
• ExtTime ( ) // default
  constructor
• private
• ZoneType zone // added data member

73
74
class ExtTime public Time

• says class Time is a public base class of the
  derived class ExtTime
• as a result, all public members of Time (except
  constructors) are also public members of ExtTime
• in this example, new constructors are provided,
  new data member zone is added, and member
  functions Set and Write are overridden

75

Class Interface Diagram
ExtTime class
Set
Set
Private data hrs mins secs
Increment
Increment
Write
Write
Time
ExtTime
Time
ExtTime
Private data zone
76
Client Code Using ExtTime

• include exttime.h
• .
• .
• .
• ExtTime thisTime ( 8, 35, 0, PST )
• ExtTime thatTime // default
  constructor called
• thatTime.Write( ) // outputs
  000000 EST
• cout ltlt endl
• thatTime.Set (16, 49, 23, CDT)
• thatTime.Write( ) // outputs
  164923 CDT
• cout ltlt endl
• thisTime.Increment ( )
• thisTime.Increment ( )
• thisTime.Write ( ) // outputs
  083502 PST
• cout ltlt endl

76
77
Constructor Rules for Derived Classes

• at run time, the base class constructor is
  implicitly called first, before the body of the
  derived classs constructor executes
• if the base class constructor requires
  parameters, they must be passed by the derived
  classs constructor

78
Implementation of ExtTime Default Constructor

• ExtTime ExtTime ( )
• // Default Constructor
• // Postcondition
• // hrs 0 mins 0 secs
  0
• // (via an implicit call to base
  class default constructor )
• // zone EST
• zone EST

79
Implementation of Another ExtTime Class
Constructor

• ExtTime ExtTime ( / in / int
  initHrs,
• / in / int
  initMins,
• / in / int
  initSecs,
• / in /
  ZoneType initZone )
• Time (initHrs, initMins, initSecs)
  // constructor initializer
• // Precondition 0 lt initHrs lt 23 0
  lt initMins lt 59
• // 0 lt initSecs lt 59 initZone is
  assigned
• // Postcondition
• // zone initZone Time set by base class
  constructor
• zone initZone

79
80
Implementation of ExtTimeSet function

• void ExtTime Set ( / in / int
  hours,
• / in / int
  minutes,
• / in / int
  seconds,
• / in /
  ZoneType time Zone )
• // Precondition 0 lt hours lt 23 0 lt
  minutes lt 59
• // 0 lt seconds lt 59 timeZone is
  assigned
• // Postcondition
• // zone timeZone Time set by base class
  function
• Time Set (hours, minutes,
  seconds)
• zone timeZone

80
81
Implementation of ExtTimeWrite Function

• void ExtTime Write ( ) const
• // Postcondition
• // Time has been output in form HHMMSS ZZZ
• // where ZZZ is the time zone
  abbreviation
• static string zoneString8
• EST, CST, MST, PST, EDT,
  CDT, MDT, PDT
• Time Write ( )
• cout ltlt ltlt zoneString zone

81
82
Composition (or Containment)

• is a mechanism by which the internal data (the
  state) of one class includes an object of another
  class

83
A TimeCard object has a Time object

• include time.h
• class TimeCard
• public
• void Punch ( / in / int hours,
• / in / int
  minutes,
• / in /
  int seconds )
• void Print ( ) const
• TimeCard ( / in / long idNum,
• / in / int initHrs,
• / in / int initMins,
• / in / int
  initSecs )
• TimeCard ( )
• private
• long id
• Time timeStamp

84

TimeCard Class
TimeCard has a Time object
Private data id timeStamp
Print . . .
Private data hrs mins secs
Set
Increment
Write . . .
TimeCard
TimeCard
85
Implementation of TimeCard Class Constructor

• TimeCard TimeCard ( / in / long idNum,
• / in / int initHrs,
• / in / int initMins,
• / in
  / int initSecs )
• timeStamp (initHrs, initMins, initSecs)
  // constructor initializer
• // Precondition 0 lt initHrs lt 23 0
  lt initMins lt 59
• // 0 lt initSecs lt 59 initNum is
  assigned
• // Postcondition
• // id idNum timeStamp set by its
  constructor
• id idNum

85
86
Order in Which Constructors are Executed

• Given a class X,
• if X is a derived class its base class
  constructor is executed first
• next, constructors for member objects (if any)
  are executed (using their own default
  constructors if none is specified)
• finally, the body of Xs constructor is executed

87
In C . . .

• When the type of a formal parameter is a
• parent class, the argument used can be
• the same type as the formal parameter,
• or,
• any descendant class type.

88
Static Binding

• is the compile-time determination of which
  function to call for a particular object based on
  the type of the formal parameter
• when pass-by-value is used, static binding occurs

89
Static Binding Is Based on Formal Parameter Type

• void Print ( / in / Time someTime )
• cout ltlt Time is
• someTime.Write ( )
• cout ltlt endl
• CLIENT CODE OUTPUT
• Time startTime ( 8, 30, 0 ) Time is
  083000
• ExtTime endTime (10, 45, 0, CST) Time is
  104500
• Print ( startTime )
• Print ( endTime )

90
Virtual Functions

• A virtual function is a method in a base class
  that can be overridden by a derived class method.
• In the time example, we would like each time
  object to "know" which write() method to use.
• Declare the base class write method virtual, and
  this happens!

91
Dynamic Binding

• is the run-time determination of which function
  to call for a particular object of a descendant
  class based on the type of the argument
• declaring a member function to be virtual
  instructs the compiler to generate code that
  guarantees dynamic binding

92
Virtual Member Function

• // SPECIFICATION FILE ( time.h )
• class TimeType
• public
• . . .
• virtual void Write ( ) const
  // for dynamic binding
• . . .
• private
• int hrs
• int mins
• int secs

93
Dynamic binding requires pass-by-reference

• void Print ( / in / Time someTime )
• cout ltlt Time is
• someTime.Write ( )
• cout ltlt endl
• CLIENT CODE OUTPUT
• Time startTime ( 8, 30, 0 )
  Time is 083000
• ExtTime endTime (10, 45, 0, CST)
  Time is 104500 CST
• Print ( startTime )
• Print ( endTime )

94
Using virtual functions in C

• dynamic binding requires pass-by-reference when
  passing a class object to a function
• in the declaration for a virtual function, the
  word virtual appears only in the base class
• if a base class declares a virtual function, it
  must implement that function, even if the body is
  empty
• a derived class is not required to re-implement a
  virtual function. If it does not, the base class
  version is used

95
End of Lecture