CSci 581: Obj.-Oriented Design & Programming
Spring Semester 1999
Lecture Notes

Implementing Objects with Classes

This Web document was based on a set of "slides" created by the instructor for use in the Fall 1997 offering of the object-oriented design and programming course. That set was, in turn, based on a set of slides created by Timothy Budd to supplement chapters 3 and 4 of his textbook An Introduction to Object-Oriented Programming, Second Edition (Addison-Wesley, 1997).

Encapsulation and Instantiation

Classes provide two very important capabilities:

Encapsulation --

purposeful hiding of information, thereby reducing the details that must be remembered and communicated

Instantiation --

creation of multiple instances of an abstraction

Java's package facility provides a larger-grained encapsulation mechanism

Encapsulation: Parnas's Principles

• The developer of a software component (e.g., class) must provide the intended user with all the information needed to make effective use of the services provided by the component, and should provide no other information.

• The developer of a software component must be provided with all the information necessary to carry out the given responsibilities assigned to the component, and should be provided no other information.

To achieve Parnas's principles, keep the interface (public face) of a class separate from the implementation (private face) of the class.

Object State -- Instance Variables

• Instance: a representative or example of a class

• Instance variable: the state, or data values, maintained internal to a class

• Record information about instance variables on back of CRC card (internal to class)

  • clients can see front of CRC card -- the interface

  • implementors can see back of CRC card -- the implementation

Example -- Playing Card

Below illustrates the front side of a CRC card for a playing card class.

Think of the front side of a card as being its public face -- the interface.

Playing Card Back -- Data Areas

The back can record information about the internal state of an instance.

Think of the back of the card being its private face -- the implementation.

Refinement of Playing Card

We refine the behavior by providing explicit function names and argument types.

Interface and Implementation

Distinction between interface and implementation is manifest in different ways:

• Separation between interface and implementation within class

  Example: public and private features in Java and C++

• Interface descriptions and implementation bodies appearing in separate places

  Example: Java interface definition and class that implements it

  Example: C++ .h and *.cpp files

Varieties of Classes

Data manager

principal responsibility is to maintain data values

Example: Playing card -- maintains suit and value information

Data sink or source

interface to data generator or consumer, no data itself

Example: Input/Output stream objects - files, I/O devices

View or observer class

display objects graphically, not the object itself

• Viewing tasks are different from data manipulation tasks

• An object might have many different views

Facilitator or helper class

maintain little/no state, but assist with complex tasks

Example: painting assistant (Pen, Canvas, Edit box) for graphics output device

Classes and Methods in Java

Java is similar to C++, but

• No preprocessor or enumerated data types (use static final variables)

• All functions, procedures, and variables defined in a class

• Methods always defined directly inside the class definitions

• All methods must specify a return type

• Keywords public and private applied individually to features

• Object references instead of pointers

Playing Card in Java

public class Card
{               // static values for colors
        static final public int red = 0;
        static final public int black = 1;

                // static values for suits
        static final public int spade = 0;
        static final public int heart = 1;
	static final public int diamond = 2;
	static final public int club = 3;

		// constructor
	public Card (int sv, int rv)
        {       suitValue = sv; 
                rankValue = rv; 
                faceup = false;
        }
		
		// mutators	
	public void flip() { faceup  = ! faceup; }

		// accessors
	public int suit() { return suitValue; }

	public int rank() { return rankValue; }

 	public int color () { 
		if (suit() == heart || suit() == diamond)
			return red;
		return black ;
        }

	public boolean faceUp() { return faceup; }
	
		// perform other actions
	public void draw (Graphics g, int x, int y)
	{	... /* omitted */ ...  }

		// data fields
	private boolean faceup;
	private int rankValue;
	private int suitValue;
}

Storage Allocation

How is space allocated to variables?

Static allocation

-- uses declaration statements

-- allocates variables before execution

Example: global variables in Fortran or C

Automatic allocation (sometimes called semidynamic allocation)

-- uses declaration statements

-- automatically allocates variables on entering scope

-- stack-based storage management

Example: local variables in Pascal or C

Dynamic allocation

-- often uses explicit directives

-- sometimes implicit as side-effect of other operations

-- heap-based storage management

Example: explicit new in Java and C++

Example: implicit side-effect of string concatenation in Java

Storage Deallocation

Explicit deallocation by programmer

-- programmer must return unneeded memory to system

Examples: C++ delete, Pascal dispose

Advantage: efficiency

Disadvantages:

• attempted use of memory not yet allocated or already freed
• multiple freeing of memory
• freeing of memory that is still needed
• memory leak -- allocated memory is never released

Implicit deallocation by runtime system

-- system detects when data unneeded, automatically recovers memory

-- garbage collection

Examples: Java, Smalltalk, Perl

Advantage: safety and convenience

Disadvantage: relative inefficiency / loss of programmer control

Java Storage Management

• "Static" allocation of class (static) variables upon initial loading of class

• Automatic, stack-based allocation of local variables in methods

  Local variables only contain primitive values or references to class instances

     int count;
     Card aCard;
  

• Dynamic, heap-based allocation of all class instances -- mostly using explicit directive

     aCard = new Card(Card.spade,5);
  

• Implicit deallocation of unused heap storage (garbage collection)

Object Creation and Initialization

Many OOP languages link object creation and initialization to:

• Avoid creating an object without properly initializing its fields

• Avoid creating an object and initializing its fields more than once

A constructor is a method that:

• is automatically invoked when an object is created

• computes the initial state of the object, given arguments

Constructors in Java

A constructor in Java (and C++) is a method that:

• has same name as the class

• can take argument lists, like other functions

• has no return type

• is invoked implicitly by new, explicitly by this in other constructors

• computes initial state of instance

   
   class newClass {
      ...
      newClass (int i) {
         ... // initialization
      }
   }

Object Deletion and Reclamation

A destructor is a method that:

• is automatically invoked whenever an object is deleted

• releases any resources the object instance has acquired (e.g., deletes subordinate objects, closes files)

In languages with explicit deallocation (e.g., C++), programmer-defined destructors reclaim object storage and other resources.

Destructors in Java

• Garbage collection recovers memory no longer referenced

• Method finalize(), if defined, called when reclaiming memory for object

  • Does any other housecleaning needed (e.g., close files)

  • Executes at unpredictable times

  • Should not be depended upon for correctness -- do critical housecleaning tasks explicitly

Message Passing

Message-passing:

• is the OOP term for invoking the instance methods (procedures and functions) of a class

• evokes the picture of two objects communicating with each other by exchanging "messages"

Message passing differs from a simple function call:

• Message always transmitted to specific instance---the receiver

• Instance's class decides particular method invoked

• When method invoked, receiver passed as implicit extra parameter

• Receiver accessible using pseudo-variable this in Java and C++

Message Passing Syntax

• Form in Java: receiver object, then period, then arguments

  Below Card instance aCard is implicit argument of flip and draw

     Card aCard:
     aCard = new Card( ... );
     aCard.flip();
     aCard.draw(x,y);
  

• Some languages (Smalltalk, C++) support user-defined operator symbols

  • defined as methods, often overloaded

  • left argument is receiver

  • right argument is method's single explicit argument

• Java does not support user-defined operator symbols or overloading

UP to CSCI 581 Lecture Notes root document?