slide1 l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Introduction to Classes and Objects Initializing Objects Making Use of Classes in Algorithms Class Examples PowerPoint Presentation
Download Presentation
Introduction to Classes and Objects Initializing Objects Making Use of Classes in Algorithms Class Examples

Loading in 2 Seconds...

play fullscreen
1 / 82

Introduction to Classes and Objects Initializing Objects Making Use of Classes in Algorithms Class Examples - PowerPoint PPT Presentation


  • 222 Views
  • Uploaded on

Lecture 18. Introduction to Classes and Objects Initializing Objects Making Use of Classes in Algorithms Class Examples. Introduction to Classes and Objects. The Scenario. We want to provide a “black box” approach to reusable components…. Don’t know how it works, but it works!. Input.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Introduction to Classes and Objects Initializing Objects Making Use of Classes in Algorithms Class Examples' - drew


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1

Lecture 18

Introduction to Classes and Objects Initializing Objects Making Use of Classesin Algorithms Class Examples

the scenario
The Scenario
  • We want to provide a “black box” approach to reusable components…

Don’t know howit works, but itworks!

Input

Output

the scenario4
The Scenario
  • We want to create reusable components for other programmers to use.
  • They are focused on their work and don’t want to know the details of how our component works.
  • They are also busy trying to do their work, so maybe they’ll take shortcuts and “hack.”
  • We want to provide services to them but protect the implementation details of our components.
classes
Classes
  • 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.
objects
Objects
  • 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.
classes and objects
Classes and Objects
  • A class is like a blueprint:
  • An object is an instantiated class (like a building):
classes vs objects
Classes vs. Objects

Class refers to the template by which we implement an ADT’s 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

classes allow for reuse
Classes 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!

components of a class
Components 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 stateof the object.
  • The operations (procedures and functions) that are provided by the class (and thus allowed on the data) are called the methodsof the class.
controlling visibility
Controlling Visibility
  • Recall we want to protect the implementation of the class.
    • Users shouldn’t need to know how it works
    • Users shouldn’t be able to violate the behaviors (may only do what we allow them).
  • Encapsulation allows us to hide the implementation details.
public vs protected
Public vs. Protected

Protected

Public

visibility within a class
Visibility Within a Class

The rest of the algorithm

Public Section (Interface)

Protected Section(Implementation)

anatomy of a class
Anatomy 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
public section
Public 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.
protected section
Protected Section
  • Contains the detailsof the implementation of the class
  • Cannot be seen by the client algorithm
  • Hides attributes and method implementation
  • Contains all method declarations and implementations.
interactions
Interactions

Client Algorithm

Public Module Definitionsand Contract

Supplier Object

Protected Data & Implementation of Modules

encapsulation and hiding
Encapsulation and Hiding

A client algorithm can see only the public section of the class. Aclient 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.

public vs protected methods
Public vs. Protected Methods

Clients may call any/all of the three public methods.

Clients don’t know the hidden method exists; they cannot call it.

Some Class

publicmethod 1

publicmethod 3

class data

publicmethod 2

a protectedmethod

protected methods
Protected 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 don’t even know it exists.

Such a method may only be called by other methods within the protected section.

structure of a class definition
Structure of a Class Definition

class <identifier>

public

<method definitions and contracts>

protected

<constants>

<type definitions>

<attribute declarations>

<method implementations>

endclass // <identifier>

a bus class example
A Bus Class Example

Bus

Initialize

MAX_PASSENGERS

Current

Add Passengers

Implementation

RemovePassengers

Number of Passengers

slide23
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 <- 0

endprocedure // Initialize

slide24
procedure AddPassengers (to_add iot in num)

if (current + to_add <= MAX_PASSENGERS) then

current <- current + to_add

endif

endprocedure // AddPassengers

function NumPassengers returnsa num

NunPassengers returns current

endfunction // NumPassengers

procedure RemovePassengers (to_remove iot in num)

if (current >= to_remove) then

current <- current – to_remove

endif

endprocedure // RemovePassengers

endclass // Bus

recipe for writing a class
Recipe 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
attribute visibility in the protected section
Attribute Visibility in the Protected Section

Variables declared at the global level of the protected section can be directlyaccessed throughout the protected section without passing them via parameter.

protected

current isoftype num

. . .

procedure AddPassengers (to_add iot in num)

if (current + to_add <= MAX_PASSENGERS) then

current <- current + to_add

endif

endprocedure // AddPassengers

function NumPassengers returnsa num

NunPassengers returns current

endfunction // NumPassengers

. . .

attribute visibility in the protected section27
Attribute 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 withinprotected
  • Still have encapsulation (the class itself)
summary
Summary
  • 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.
the scenario31
The Scenario
  • You’ve 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.
  • We’d like to initialize our Head and Tail pointers to NIL.
  • But the algorithm shouldn’t know about the pointers!
need to initialize
Need to Initialize
  • Our Queue class will thus need a method that “sets things up” when an object is created.
  • Different languages handle this differently.
  • We’ll use a normal method that must be invoked like any other…
a method by any other name
“A 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.
initialize common but not required
Initialize Common but Not Required
  • Most classes have attributes that require some initial values.
  • We expect most classes to have initialization methods.
  • But it’s not required.
initialize in the class definition
Initialize In the Class Definition

class Initialize_Example

public

. . .

procedure Initialize (<parameters>)

// contract information

. . .

protected

. . .

procedure Initialize (<parameters>)

<implementation>

endprocedure // Initialize

endclass

invoking the initialize method
Invoking 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.
an example
An Example

In the algorithm:

MyQueue isoftype Queue

MyQueue.Initialize

In the class definition:

procedure Initialize

head <- NIL

tail <- NIL

endprocedure // Initialize

another example
Another Example

In the algorithm:

MyAirplane isoftype Plane

MyAirplane.Initialize(“Delta 955”)

In the class definition:

procedure Initialize(flight_name iot in string)

altitude <- 0

current_flight <- flight_name

endprocedure // Initialize

summary39
Summary
  • 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.
    • We’ll treat the Initialize method like any other method and call it from the algorithm for each object created.
the scenario42
The Scenario
  • You need to create a simulation of an airport.
  • A coworker has developed an airplane class you’d like to use in your algorithm.
  • How do we “get at” the airplane class?
  • Notice we don’t have access to modify the class, just make use of it.
importing the class
Importing 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.
the uses clause
The “Uses” Clause

algorithm <Algorithm Name>

uses <Class Name>, <Class Name>, . . .

. . .

endalgorithm // <Algorithm Name>

class <Class Name>

uses <Other Class Name>

. . .

endclass // <Class Name>

an example45
An 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

. . .

a more complex example
A More Complex Example

algorithm BigAirport

uses Airplane, Helicopter, FlightController

Plane1, Plane2 isoftype Airplane

ControlDeck isoftype FlightController

. . .

endalgorithm

classes and objects47
Classes 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

creating objects
Creating Objects
  • Once the algorithm has imported the class definition, then it can create objects of the class.
  • Objects are created just as any variable:

<Object Identifier> isoftype <Class Name>

For example:

MyPlane, YourPlane isoftype Airplane

ControlDeck isoftype FlightController

accessing methods of objects
Accessing 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.
invoking methods of an object
Invoking Methods of an Object

algorithm Example

uses MyClass

MyObject isoftype MyClass

MyObject.Initialize

MyObject.<Any Method in Public Section>

. . .

endalgorithm

an airplane class
An Airplane Class

Airplane

Initialize

TakeOff

  • InTheAir
  • Altitude

ChangeAltitude

IsFlying

ServeSnack

Land

Fly

an example of accessing methods
An 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

only access public methods
Only 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 <- 30000

print(MyAirplane.InTheAir)

MyAirplane.ServeSnack // method call

summary54
Summary
  • Import class definitions using the uses clause.
  • Declare objects as any other variable.
  • Access public methods of objects using the dot (.) operator.
class examples

Class Examples

Airplane, Queue, Pile

once written it s easy
Once Written, It’s Easy!

Once we’ve 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
airplane example
Airplane 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 it’s flying or not
airplane symbolic diagram
Airplane Symbolic Diagram

Airplane

Initialize

TakeOff

  • InTheAir
  • Altitude

ChangeAltitude

IsFlying

ServeSnack

Land

Fly

slide60
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

slide61
// still in the protected section

procedure Initialize

InTheAir <- FALSE

Altitude <- 0

endprocedure // Initialize

procedure TakeOff

if InTheAir then

print("I'm in the air!")

else

InTheAir <- TRUE

ChangeAltitude(3000)

endif

endprocedure // TakeOff

slide62
// still in the protected section

procedure ChangeAltitude (NewHeight iot in Num)

Altitude <- NewHeight

endprocedure // ChangeAltitude

procedure Fly (destination iot in String)

print(“I’m flying to”, destination)

ServeSnack

endprocedure // Fly

procedure ServeSnack

// comments here

MAKE PASSENGERS HAPPY

endprocedure // ServeSnack

slide63
// still in the protected section

function IsFlying returnsa boolean

IsFlying returns InTheAir

endfunction // IsFlying

procedure Land

if InTheAir then

InTheAir <- FALSE

ChangeAltitude(0)

else

print("I'm not in the air!")

endif

endprocedure // Land

endclass // Airplane

using the airplane class
Using the Airplane Class

algorithm Airport

uses Airplane

Cessna1090 isoftype Airplane

Cessna1090.Initialize

Cessna1090.Takeoff

Cessna1090.ChangeAltitude(30000)

Cessna1090.Fly(“Baltimore”)

Cessna1090.Land

endalgorithm

the queue
The Queue

Dequeue

A collection with restricted set of operations to change its state: only modified byadding to one end and deleting from the other.

Enqueue

numberqueue symbolic diagram
NumberQueue Symbolic Diagram

NumberQueue

Initialize

  • head
  • tail

Enqueue

Dequeue

IsEmpty

IsFull

slide67
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

head, tail isoftype Ptr toa List_type

slide68
// still in the protected section

procedure Enqueue(value iot in Num)

temp isoftype Ptr toa List_type

temp <- new(List_type)

temp^.data <- value

temp^.next <- NIL

if(IsEmpty) then

head <- temp

else

tail^.next <- temp

endif

tail <- temp

endprocedure // Enqueue

slide69
// still in the protected section

procedure Dequeue (value iot out Num)

if(IsEmpty) then

// violates contract! Error!

else

value <- head^.data

head <- head^.next

if(IsEmpty) then

tail <- NIL

endif

endif

endprocedure // Dequeue

slide70
// 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 <- NIL

tail <- NIL

endprocedure // Initialize

endclass // NumberQueue

slide71
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(person’s number)

endif

if (NOT checkout.IsEmpty) then

checkout.Dequeue(temp)

print(“Now servicing person”, temp)

endif

endloop

endalgorithm // Store

example simulating the lotto
Example: 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.
a pile class
A “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
pile symbolic diagram
Pile Symbolic Diagram

NumPile

Initialize

  • Head
  • num_of_things

StickOn

DigOut

Random

IsEmpty

slide75
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

slide76
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 <- 0

head <- NIL

endprocedure // Initialize

function IsEmpty returnsa boolean

IsEmpty returns (head = NIL)

endfunction // IsEmpty

slide77
// still in the protected section

function Random returnsa Num

// returns a random number <=

// num_of_things

endfunction // Random

procedure StickOn (thing isoftype in Num)

place_to_insert isoftype Num

place_to_insert <- Random

new_node isoftype ptr toa PileNode

new_node <- new(PileNode)

// loop through pile until place-to-

// insert is reached, then insert node

num_of_things <- num_of_things + 1

endprocedure // StickOn

slide78
// still in the protected section

procedure DigOut (thing isoftype out Num)

thing_to_snag isoftype Num

place_to_get isoftype Num

place_to_get <- Random

// code for looping through pile to

// find right thing-to-snag, then

// remove it

num_of_things <- num_of_things - 1

thing <- thing_to_snag

endprocedure // Dig-Out

endclass // NumPile

using the pile class
Using 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

summary80
Summary
  • 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