Title: Introduction to Classes and Objects Initializing Objects Making Use of Classes in Algorithms Class Examples
1Introduction to Classes and Objects
Initializing Objects Making Use of Classesin
Algorithms Class Examples
Lecture 18
2Introduction to Classes and Objects
3The Scenario
- We want to provide a black box approach to
reusable components
Dont know howit works, but itworks!
Input
Output
4The Scenario
- We want to create reusable components for other
programmers to use. - They are focused on their work and dont want to
know the details of how our component works. - They are also busy trying to do their work, so
maybe theyll take shortcuts and hack. - We want to provide services to them but protect
the implementation details of our components.
5Classes
- A class is the fundamental unit of
object-oriented programming. - It allows us to implement ADTs, combining both
data and operations into one logical bundle.
6Objects
- Once we have a class defined, we can then declare
any number of objects of that class. - For example
- Once we have a queue class defined, we can then
declare any number of queue objects. - Each queue object will then have all the data and
procedural abstractions needed for a queue.
7Classes and Objects
- A class is like a blueprint
- An object is an instantiated class (like a
building)
8Classes vs. Objects
- Class refers to the template by which we
implement an ADTs functionality. Thus, it is
analogous to data type it is only a definition
or template. - Object refers to a specific instance of the
class. Thus, it is analogous to variable it is
an instance of a template. - Class Object Type Variable
9Classes Allow for Reuse!
- Algorithms which make use of the queue class (by
declaring instances of the queue, or objects) are
clients who obtain services - algorithm Movie_Theatre
- algorithm Restaurant
- algorithm Check-out_Line
-
- The authors of these algorithms can instantiate
and use queues without writing them!
10Components of a Class
- The individual data elements of a class are
referred to as attributes of the class. - The entire collection of data maintained within
an object is referred to as the state of the
object. - The operations (procedures and functions) that
are provided by the class (and thus allowed on
the data) are called the methods of the class.
11Controlling Visibility
- Recall we want to protect the implementation of
the class. - Users shouldnt need to know how it works
- Users shouldnt be able to violate the behaviors
(may only do what we allow them). - Encapsulation allows us to hide the
implementation details.
12Public vs. Protected
Protected
Public
13Visibility Within a Class
The rest of the algorithm
Public Section (Interface)
Protected Section(Implementation)
14Anatomy of a Class
- Classes have two sections
- Public - the specification of the "visible part
of the class - Protected - the specification of the "hidden
part of the class
15Public Section
- Contains everything that the client algorithm
needs to know to use the class - Is the visible part of the class
- Defines the interface and contract with the user
(algorithm) - Contains the header lines of those methods that
are available for clients of the class to call.
16Protected Section
- Contains the details of the implementation of the
class - Cannot be seen by the client algorithm
- Hides attributes and method implementation
- Contains all method declarations and
implementations.
17Interactions
Client Algorithm
Public Module Definitionsand Contract
Supplier Object
Protected Data Implementation of Modules
18Encapsulation and Hiding
- A client algorithm can see only the public
section of the class. A client has no idea what
is within the protected section. - A client algorithm can interact with an object
only by calling the methods listed in the public
section of the class. - A client algorithm cannot directly access any of
the data within an object. It may get at data
only via calls to public methods.
19Public vs. Protected Methods
Some Class
publicmethod 1
publicmethod 3
class data
publicmethod 2
a protectedmethod
- Clients may call any/all of the three public
methods. - Clients dont know the hidden method exists they
cannot call it.
20Protected Methods
- A protected method is one which is defined in the
protected section that does not have its header
line in the public section. - Clients dont even know it exists.
- Such a method may only be called by other methods
within the protected section.
21Structure of a Class Definition
- class ltidentifiergt
- public
- ltmethod definitions and contractsgt
- protected
- ltconstantsgt
- lttype definitionsgt
- ltattribute declarationsgt
- ltmethod implementationsgt
- endclass // ltidentifiergt
22A Bus Class Example
Bus
Initialize
MAX_PASSENGERS Current
Add Passengers
Implementation
RemovePassengers
Number of Passengers
23- class Bus
- public
- procedure Initialize
- // contract here
- procedure AddPassengers (to_add iot in num)
- // contract here
- function NumPassengers returnsa num
- // contract here
- procedure RemovePassengers (to_remove iot in
num) - // contract here
- protected
- MAX_PASSENGERS is 50
- current isoftype num
- procedure Initialize
- current lt- 0
- endprocedure // Initialize
24- procedure AddPassengers (to_add iot in num)
- if (current to_add lt MAX_PASSENGERS) then
- current lt- current to_add
- endif
- endprocedure // AddPassengers
- function NumPassengers returnsa num
- NunPassengers returns current
- endfunction // NumPassengers
- procedure RemovePassengers (to_remove iot in
num) - if (current gt to_remove) then
- current lt- current to_remove
- endif
- endprocedure // RemovePassengers
- endclass // Bus
25Recipe for Writing a Class
- Write shell/template
- Decide on what the user needs to know about -
PUBLIC - Specify the protected data
- Diagram think of sample algorithm
- Write public section with contract information
- Write protected section with implementation
details
26Attribute Visibility in the Protected Section
- Variables declared at the global level of the
protected section can be directly accessed
throughout the protected section without passing
them via parameter. - protected
- current isoftype num
- . . .
- procedure AddPassengers (to_add iot in num)
- if (current to_add lt MAX_PASSENGERS) then
- current lt- current to_add
- endif
- endprocedure // AddPassengers
- function NumPassengers returnsa num
- NunPassengers returns current
- endfunction // NumPassengers
- . . .
27Attribute Visibility in the Protected Section
- Allow direct access, bypassing parameters!
- May want clients of the class to be able to call
methods - Don't want clients to know the details of the
protected section's data representation. - If method parameter lists included data that's
protected, then would be telling the client about
that representation. - So, allow direct access within protected
- Still have encapsulation (the class itself)
28Summary
- Classes implement ADTs
- An object is an instance of a class
- Encapsulation allows for the protection of
details within the class - Public section provides interface
- Protected section provides implementation
- Attributes declared at the global level of the
protected section may be directly accessed within
any method in the protected section.
29Questions?
30Initializing Objects
31The Scenario
- Youve defined a Queue class and now want to
create an instance of that class. - There are some attributes which should be
initialized when an object is created. - Wed like to initialize our Head and Tail
pointers to NIL. - But the algorithm shouldnt know about the
pointers!
32Need to Initialize
- Our Queue class will thus need a method that
sets things up when an object is created. - Different languages handle this differently.
- Well use a normal method that must be invoked
like any other
33A Method By Any Other Name
- An initialization method is just like any other
method. - For clarity and convenience, we always use the
identifier Initialize for such methods.
34Initialize Common but Not Required
- Most classes have attributes that require some
initial values. - We expect most classes to have initialization
methods. - But its not required.
35Initialize In the Class Definition
- class Initialize_Example
- public
- . . .
- procedure Initialize (ltparametersgt)
- // contract information
- . . .
- protected
- . . .
- procedure Initialize (ltparametersgt)
- ltimplementationgt
- endprocedure // Initialize
- endclass
36Invoking the Initialize Method
- In the algorithm, we invoke (or call) the
Initialize method just as any other method. - It is assumed that Initialize is only called
once, but there is no rule to enforce this. - The algorithm must explicitly call the initialize
method for each object that has attributes that
need to be initialize.
37An Example
- In the algorithm
- MyQueue isoftype Queue
- MyQueue.Initialize
- In the class definition
- procedure Initialize
- head lt- NIL
- tail lt- NIL
- endprocedure // Initialize
38Another Example
- In the algorithm
- MyAirplane isoftype Plane
- MyAirplane.Initialize(Delta 955)
- In the class definition
- procedure Initialize(flight_name iot in string)
- altitude lt- 0
- current_flight lt- flight_name
- endprocedure // Initialize
39Summary
- Very often, objects have attributes that need
some initial values. - Thus these classes need some method to set these
attributes. - Different languages handle this differently
- Some have special methods that are
automatically executed. - Well treat the Initialize method like any other
method and call it from the algorithm for each
object created.
40Questions
41Making Use of Classesin Algorithms
42The Scenario
- You need to create a simulation of an airport.
- A coworker has developed an airplane class youd
like to use in your algorithm. - How do we get at the airplane class?
- Notice we dont have access to modify the class,
just make use of it.
43Importing the Class
- Algorithms and class definitions often reside in
separate computer files. - Recall that a benefit of Object-Oriented
Programming is re-use via class libraries - We need the ability to import a class into our
algorithm or another class - The uses clause allows this import.
44The Uses Clause
- algorithm ltAlgorithm Namegt
- uses ltClass Namegt, ltClass Namegt, . . .
- . . .
- endalgorithm // ltAlgorithm Namegt
- class ltClass Namegt
- uses ltOther Class Namegt
- . . .
- endclass // ltClass Namegt
45An Example
- Having previously defined an Airplane class, the
algorithm can make use of the class and create
objects of the class as follows - algorithm Airport
- uses Airplane
- Cessna, Prop isoftype Airplane
- . . .
46A More Complex Example
- algorithm BigAirport
- uses Airplane, Helicopter,
FlightController - Plane1, Plane2 isoftype Airplane
- ControlDeck isoftype FlightController
- . . .
- endalgorithm
47Classes and Objects
- A class is like a blueprint
- It is analogous to data type
- An object is an instantiated class (like a
building) - It is analogous to variable
- Class Object Type Variable
48Creating Objects
- Once the algorithm has imported the class
definition, then it can create objects of the
class. - Objects are created just as any variable
- ltObject Identifiergt isoftype ltClass Namegt
- For example
- MyPlane, YourPlane isoftype Airplane
- ControlDeck isoftype FlightController
49Accessing Methods of Objects
- After instantiating a class and creating an
object in the algorithm, we want to make use of
its methods. - There are many methods in the class, so how do we
access the one we want? - Just as fields of a record, we access the methods
in an object using the dot (.) operator.
50Invoking Methods of an Object
- algorithm Example
- uses MyClass
- MyObject isoftype MyClass
- MyObject.Initialize
- MyObject.ltAny Method in Public Sectiongt
- . . .
- endalgorithm
51An Airplane Class
Airplane
Initialize
TakeOff
ChangeAltitude
IsFlying
ServeSnack
Land
Fly
52An Example of Accessing Methods
- algorithm Flying
- uses Airplane
- MyAirplane isoftype Airplane
- MyAirplane.Initialize
- if (NOT MyAirplane.IsFlying) then
- MyAirplane.TakeOff
- MyAirplane.ChangeAltitude(30000)
- MyAirplane.Fly(Cincinnati)
- MyAirplane.Land
- else
- print(Sorry, that plane is already flying!)
- endalgorithm
Function
Procedures
53Only Access Public Methods
- The algorithm cannot access protected attributes
or protected methods. - The algorithm only has access to methods as
declared in the public section. - Examples of illegal use
- MyAirplane.Altitude lt- 30000
- print(MyAirplane.InTheAir)
- MyAirplane.ServeSnack // method call
54Summary
- Import class definitions using the uses clause.
- Declare objects as any other variable.
- Access public methods of objects using the dot
(.) operator.
55Questions?
56Class Examples
57Once Written, Its Easy!
- Once weve written the class
- We test it and validate that it works
- We can then make use of it in any algorithm
- Notice in the following algorithm examples how
little work is done - All manipulation is hidden from the algorithm
- All the details are abstracted into the object
58Airplane Example
- An Airplane knows how to
- Take off
- Land
- Fly to a destination (and serve a snack)
- Change its altitude
- It also has the following attributes
- Current altitude
- Whether its flying or not
59Airplane Symbolic Diagram
Airplane
Initialize
TakeOff
ChangeAltitude
IsFlying
ServeSnack
Land
Fly
60- class Airplane
- public
- procedure TakeOff
- // comments here
- procedure Land
- // comments here
- procedure ChangeAltitude (NewHeight iot in Num)
- // comments here
- function IsFying returnsa boolean
- // comments here
- procedure Initialize
- // comments here
- procedure Fly (destination iot in String)
- // comments here
- protected
- // create the persistent data
- InTheAir isoftype Boolean
- Altitude isoftype Num
61- // still in the protected section
- procedure Initialize
- InTheAir lt- FALSE
- Altitude lt- 0
- endprocedure // Initialize
- procedure TakeOff
- if InTheAir then
- print("I'm in the air!")
- else
- InTheAir lt- TRUE
- ChangeAltitude(3000)
- endif
- endprocedure // TakeOff
62- // still in the protected section
- procedure ChangeAltitude
(NewHeight iot in Num) - Altitude lt- NewHeight
- endprocedure // ChangeAltitude
- procedure Fly (destination iot in String)
- print(Im flying to, destination)
- ServeSnack
- endprocedure // Fly
- procedure ServeSnack
- // comments here
- MAKE PASSENGERS HAPPY
- endprocedure // ServeSnack
63- // still in the protected section
- function IsFlying returnsa boolean
- IsFlying returns InTheAir
- endfunction // IsFlying
-
- procedure Land
- if InTheAir then
- InTheAir lt- FALSE
- ChangeAltitude(0)
- else
- print("I'm not in the air!")
- endif
- endprocedure // Land
- endclass // Airplane
64Using the Airplane Class
- algorithm Airport
- uses Airplane
- Cessna1090 isoftype Airplane
- Cessna1090.Initialize
- Cessna1090.Takeoff
- Cessna1090.ChangeAltitude(30000)
- Cessna1090.Fly(Baltimore)
- Cessna1090.Land
- endalgorithm
65The Queue
Dequeue
- A collection with restricted set of operations to
change its state only modified by adding to one
end and deleting from the other.
Enqueue
66NumberQueue Symbolic Diagram
NumberQueue
Initialize
Enqueue
Dequeue
IsEmpty
IsFull
67- class NumberQueue
- public
- procedure Enqueue(value iot in Num)
- // contract information here
- procedure Dequeue(value iot out Num)
- // contract - queue not empty
- procedure Initialize
- // contract information here
- function IsEmpty returnsa Boolean
- // contract information here
- function IsFull returnsa Boolean
- // contract information here
- protected
- List_type definesa record
- data isoftype Num
- next isoftype Ptr toa List_type
- endrecord
- // create the persistent data
68- // still in the protected section
- procedure Enqueue(value iot in Num)
- temp isoftype Ptr toa List_type
- temp lt- new(List_type)
- temp.data lt- value
- temp.next lt- NIL
- if(IsEmpty) then
- head lt- temp
- else
- tail.next lt- temp
- endif
- tail lt- temp
- endprocedure // Enqueue
69- // still in the protected section
- procedure Dequeue (value iot out Num)
- if(IsEmpty) then
- // violates contract! Error!
- else
- value lt- head.data
- head lt- head.next
- if(IsEmpty) then
- tail lt- NIL
- endif
- endif
- endprocedure // Dequeue
70- // still in the protected section function
IsEmpty returnsa Boolean - IsEmpty returns (head NIL)
- endfunction // IsEmpty
- function IsFull returnsa Boolean
- IsFull returns FALSE // dynamic
- endfunction // IsFull
- procedure Initialize
- // initialize the persistent data
- head lt- NIL
- tail lt- NIL
- endprocedure // Initialize
- endclass // NumberQueue
71- algorithm Store
- uses NumberQueue
- temp isoftype num
- checkout isoftype NumberQueue
- checkout.Initialize
- . . .
- loop
- some people enter and leave store randomly
- exitif ((no people in store) AND
(closing_time)) - if (someone walks up for service) then
- checkout.Enqueue(persons number)
- endif
- if (NOT checkout.IsEmpty) then
- checkout.Dequeue(temp)
- print(Now servicing person, temp)
- endif
- endloop
- endalgorithm // Store
72Example Simulating the Lotto
- We want to define a class that will allow us to
simulate the lottery. - We want to place elements into random locations
in the collection. - When we get an item from the collection, we want
a random element.
73A Pile Class
- A data structure in which
- Items are inserted somewhere randomly in the
middle of the structure - Items are removed from a random location in the
structure
74Pile Symbolic Diagram
NumPile
Initialize
StickOn
DigOut
Random
IsEmpty
75- class NumPile
- public
- procedure StickOn (the_thing iot in Num)
- // purpose put an item on the pile.
- // pre none
- // post the pile has the item added to it
- procedure DigOut (the_thing iot out Num)
- // purpose get an item off of the pile.
- // pre the pile is not empty.
- // post the pile has a random element//
removed. - function IsEmpty returnsa boolean
- // comments here - contract
- procedure Initialize
- // comments here - contract
76- protected
- PileNode definesa Record
- thing isoftype Num
- next isoftype ptr to PileNode
- endrecord // PileNode
- head isoftype ptr toa PileNode
- num_of_things isoftype Num
- procedure Initialize
- num_of_things lt- 0
- head lt- NIL
- endprocedure // Initialize
- function IsEmpty returnsa boolean
- IsEmpty returns (head NIL)
- endfunction // IsEmpty
77- // still in the protected section
- function Random returnsa Num
- // returns a random number lt
- // num_of_things
- endfunction // Random
- procedure StickOn (thing isoftype in Num)
- place_to_insert isoftype Num
- place_to_insert lt- Random
- new_node isoftype ptr toa PileNode
- new_node lt- new(PileNode)
- // loop through pile until place-to-
- // insert is reached, then insert node
- num_of_things lt- num_of_things 1
- endprocedure // StickOn
78- // still in the protected section
- procedure DigOut (thing isoftype out Num)
- thing_to_snag isoftype Num
- place_to_get isoftype Num
- place_to_get lt- Random
- // code for looping through pile to
- // find right thing-to-snag, then
- // remove it
- num_of_things lt- num_of_things - 1
- thing lt- thing_to_snag
- endprocedure // Dig-Out
- endclass // NumPile
79Using the Pile Class
- algorithm Lotto
- uses NumPile
- lotto_pile isoftype NumPile
- lotto_pile.Initialize
- ticket isoftype Num
- loop
- exitif (All Entries Purchased)
- Get_Entry(ticket) // get input from user
- lotto_pile.StickOn(ticket)
- endloop
- // Now, find one winner
- lotto_pile.DigOut(ticket)
- print ("The winning number is", ticket)
- endalgorithm // Lotto
80Summary
- Writing classes involves considerable work in
- Design, Implementation, Testing
- But once done, algorithms may make use of the
classes - Instantiating objects and manipulating them
- Hiding the details and implementation
- Much of the work is done inside the object
81Questions?
82(No Transcript)