Laboratory Exercises For Computer Science 151

Object-Oriented Programming

Goals: This laboratory exercise reviews some common approaches for tackling complex problems, providing a perspective on various types of abstraction. Object-oriented programming in the context of Scheme is introduced as an additional approach utilizing abstraction. The lab also provides experience with the case statement as a convenient construct for working within an object-oriented framework. Finally, the lab introduces stacks as an example.

Handling Complexity: Since many computer applications address complex problems, problem-solving with computers must include a consideration of the handling of complexity. Already in this course, we have seen several such strategies and use a variety of language capabilities.

Solutions can be built up using a sequence of procedures, where each procedure accomplishes a relatively simple task.
Local variables and parameters allow work within a procedure to focus on a narrow, tightly controlled task even if the procedure will be used within a more complex problem.
Using recursion, processing can focus on relatively simple base cases and the reduction of complex cases to simpler ones.
Data abstraction allows data to be viewed in logical groups and structures, such as lists, vectors, association lists, and records.
Procedural abstraction allows general procedures to be defined abstractly to cover many types of cases; mechanisms for variable arity procedures, procedure parameters, and currying give flexibility and allow general procedures to be tailored to specific needs.
Libraries allow commonly used operations to be developed once and reused in other applications.

Each of these topics allow us to organize a complex problem or task into relatively manageable parts and then to focus on those parts. Note that several of the items lists involve abstraction: we think of processing at a relatively high level, with details pushed aside to a separate procedure, structure, or file.

For example, association lists allow a natural matching of keyword and data, so we can focus upon the storage and retrieval of these information pairs. The assoc procedure retrieves relevant data, and we need not be bothered about the details of this retrieval. Similarly, the records lab shows how to think of data elements as part of a logical structure, with natural storage and retrieval operations.

Identify how you have used each of the above approaches or capabilities in the solving of at least two specific problems during this course.

Abstract Data Types: The notion of an abstract data type further extends the strategy of abstraction within problem solving. The term abstract data type or ADT describes both a collection of data values and operations on those values. Thus, an ADT utilizes both data abstraction and procedural abstraction.

Stacks as ADTs: Conceptually, the stack abstract data type mimics the information kept in a pile on a desk. Informally, we first consider materials on a desk, where we may keep separate piles for bills that need paying, magazines that we plan to read, and notes we have taken. These piles of materials have several properties. Each pile contains some papers (information). In addition, for each pile, we can do several tasks:

Start a new pile,
Place new information on the top of a pile,
Take the top item off of the pile,
Read the item on the top, and
Determine whether a pile is empty. (There may be nothing at the spot where the pile should be.)

These operations allow us to do all the normal processing of data at a desk. For example, when we receive bills in the mail, we add them to the pile of bills until payday comes. We then take the bills, one at a time, off the top of the pile and pay them until the money runs out.

When discussing these operations it is customary to call the addition of an item to the top of the pile a Push operation and the deletion of an item from the top a Pop operation.

More formally, a stack is defined as an abstract data type that can store data and that has the following operations:

Make-Stack
Create a new, empty stack object.
Empty
The Empty returns true or false (#t or #f), depending upon whether the stack contains any items or not.
Push
If the stack is not full, Push adds the specified item to the top of the stack.
If the stack is full, nothing is added, and an error is reported.
Pop
If the stack is not empty, Pop removes the top item from the stack, and this item is returned.
If the stack is empty, nothing is returned, and an error is reported.
Top
If the stack is not empty, the top item is returned, but the contents of the stack are not changed.
If the stack is empty, nothing is returned, and an error is reported.

This specification says nothing about how we will program the various stack operations; rather, it tells us how stacks can be used. We can also infer some limitations on how we can use the data. For example, stack operations allow us to work with only the top item on the stack. We cannot look at other pieces of data lower down in the stack without first using Pop operations to clear away items above the desired one.

A Push operation always puts the new item on top of the stack, and this is the first item returned by a Pop operation. Thus, the last piece of data added to the stack will be the first item removed.

Classes, Objects, and Messages: One approach to problem solving involves an initial focus on data elements, operations on those elements, and relationships among data. Within computer science, such an approach motivates the viewpoint of object-oriented programming or OOP. When working within a OOP framework, it is useful to distinguish between the general notion of an abstract data type and specific uses of the ADT with definite data values. (For example, in Scheme we have found it useful to distinguish between an integer type and specific integer values.) Within OOP, the definition of an ADT (involving data variables and operations) is called a class, and specific instances of an ADT (with specific data values) are called objects.

Utilizing the notion of abstraction, we think of objects as self-contained entities, just as we might consider each pile on a desk as an separate, independent collection of material. To support this image, processing involving objects consists of sending messages to the objects, letting the object react to the object in an appropriate way, and receiving responses back. Within an OOP context, a mechanism for interpreting messages is called a method. For example, if our desk had two piles -- one for magazines and one for bills, we might have the following interaction:


> (define mag-pile (make-stack))     ; make stack for magazines
> (define bill-pile (make-stack))    ; make stack for bills
> (bill-pile 'push! "mortgage")      ; send push message to bill-pile
> (bill-pile 'push! "doctor's bill")
> (bill-pile 'push! "credit card")
> (bill-pile 'empty?)                ; send empty? message to bill-pile
#f                                   ; response from empty? message
> (mag-pile 'empty?)
#t
> (mag-pile 'push! "Communications of the ACM - April 1997")
> (mag-pile 'push! "CS Education Bulletin - Spring 1997")
> (bill-pile 'top)                   ; send top message to bill-pile
"credit card"                        ; data returned as message response
> (mag-pile 'top)
"CS Education Bulletin - Spring 1997"
> (bill-pile 'pop!)
"credit card"
> (bill-pile 'top)
"doctor's bill"

Stacks in Scheme: To implement an abstract data type within Scheme, we must define appropriate local variables for the data and provide a framework for an object to respond to messages. Both of these tasks are accomplished by the following code. (The code is based on Springer and Friedman's program 12.12, with adaptations by John Stone and further simplifications by Henry Walker):


(define make-stack
   (lambda ()
     (let ((stk '()))
        (lambda (message . args)
           (case message   ;; identify and respond to various messages
                ((empty?) (null? stk))

                ((push!) (set! stk (cons (car args) stk)))

                ((top) (if (null? stk)
                           (error 'stack-adt "top: The stack is empty")
                           (car stk)))

                ((pop!) (if (null? stk)
                          (error 'stack-adt "pop!: The stack is empty")
                          (let ((result (car stk)))
                            (set! stk (cdr stk))
                            result)))

                ;; It is an error to send the stack any other message.
                (else (error 'stack-adt "stack: unrecognized message")))))))

Data Within A Stack: In this code, note that the variable stk is allocated outside of the lambda-expression for the procedure being returned. This ensures that it will persist between calls to that procedure. Further, note that a new local variable is created for stk each time make-stack is invoked.

Operations On A Stack: Beyond the declaration of a local variable, a stack responds to various messages. Following Scheme's syntax for procedures of variable arity, a stack requires a message as a first parameter. The processing of some messages may require further information, so additional parameters, if any, are collected in the args list.

Define two stacks and perform some operations on them, following the script given earlier in this lab. In each case, be sure you have a conceptual understanding of the results.

The Case Statement: Before responding to a message, the stack must determine which message has been sent. One way to accomplish this would be to use a cond expression:


(cond ((eq? message 'empty?) ...)
       (eq? message 'push!)  ...)
       (eq? message 'top)    ...)
       (eq? message 'pop)    ...)
       (else                 ...))
)

While this construction provides a mechanism to determine which message is present, the case special form shown in the above program does this work a bit more cleanly. As you can see, the general form of a case special form is:


(case message
     ((empty)     ...)
     ((push!)     ...)
     ((pop!)      ...)
     ((top)       ...)
     (else        ...)
)

Here, message is compared with the choices empty, push!, ..., with these options being in parentheses. When a match is found, the corresponding action is taken.

As an example, the following uses the case statement to return the office number and telephone extension for members of the Mathematics and Computer Science Department:


(define find-info
   (lambda (person)
       (case person
          ((Adelberg)    '(2405 4201))
          ((Chamberland) '(2410 4207))
          ((Ferguson)    '(2401 4661))
          ((Herman)      '(2403 4202))
          ((Jepsen)      '(2407 4203))
          ((EMoore)      '(2416 4205))
          ((TMoore)      '(2414 4206))
          ((Rebelsky)    '(2427 4410))
          ((Stone)       '(2418 3181))
          ((Walker)      '(2420 4208))
          ((Wolf)        '(2412 4209))
          (else          '(non in department))
       )
   )
)

Test find-info with the following data:


(find-info 'Chamberland)
(find-info 'Moore)
(find-info 'Walker)

Define a procedure vowel-or-consonant, which has a single parameter ch, and which returns:
- the symbol vowel if ch is a, e, i, o, or u,
- the symbol consonant if ch is a consonant,
- the symbol digit if ch is 0, 1, 2, 3, 4, 5, 6, 7, 8, or 9, and
- the symbol other otherwise.
In writing your procedure you must use a case statement, and you may not use if or cond statements.

Check your procedure with various test cases.
Expand the stack ADT by adding
- a size method which will return the number of items currently on the stack,
- a print method which will print all of the current elements on the stack, and
- an nth method which takes one parameter (an index) and returns the item at that position from the top in the current stack.

This document is available on the World Wide Web as

http://www.math.grin.edu/~walker/courses/151/lab-oop.html

created April 28, 1997
last revised November 15, 2000