James T. Streib

Using contour diagrams and JIVE to illustrate object-oriented semantics in the Java programming language

Organick, Forsythe, and Plummer extensively used contour diagrams to illustrate the semantics of procedural and functional programming languages. However, many of the benefits of contour diagrams can still be utilized in explaining the semantics of object-oriented languages and is evident in the software JIVE created by Gestwicki and Jayaraman. This paper illustrates the use of both contour diagrams and JIVE to help students understand passing objects via parameters, returning objects from methods, comparing objects, and using inheritance in the Java programming language. The results from a small informal survey are included. This paper is useful to those teaching Java in a first-year computer science sequence.

Queues Using Arrays

Unlike stacks where items can only be pushed or popped from the top, a queue has two access points and can only have items added at the rear called enqueue or removed from the front called dequeue. A queue is known as a first-in, first-out or FIFO data structure and is implemented using arrays. A queue is used to simulate a simple scheduler in an operating system in the complete program.

Lists Using Arrays

Unlike stacks that have one access point at the top where an item can be pushed or popped and queues which can only have items enqueued at the rear or dequeued from the front, a list can have items inserted or deleted from the front, rear, or anywhere in between. In this chapter arrays are used to implement ordered lists. The insert and delete methods in addition to the search method are discussed. In the complete program recursion is used to print strings stored in the list.

Stacks and Queues Using References

This chapter revisits stack and queues. Instead of using arrays as done in Chaps. 2 and 3, it uses references to implement the structures which illustrates the ideas of data and procedural abstraction. The chapter also reinforces the ideas presented in Chaps. 5 and 6. The complete program uses a graphical user interface to implement an undo button using a stack.

Lists Using Objects and References

The creation of lists using references and objects is introduced in this chapter. First references and simple objects are reviewed followed by the creation of a node class. Then a simple linked list is created which is then output both iteratively in the test program and recursively in the complete program.

Stacks Using Arrays

Stacks, whose property is known as last-in, first-out or LIFO, is introduced and implemented using arrays. Some of the common operations for stacks such adding and removing an item, push and pop, are discussed. Using stacks, elements in the list can easily be reversed and strings can be checked for a palindrome. Further, prefix and postfix expressions are discussed where postfix expressions can be evaluated using stacks.

Ordered Linked Lists

Ordered linked lists are discussed in this chapter. The insert method is created by carefully looking at inserting in the middle, end, and beginning of a linked list, as well as in an empty list. The delete method is examined and is left as an exercise. Doubly linked lists as well as an inner class are introduced and the complete program implements a list of user defined objects.

Guide to Java

class RegPolygon { If it is possible to create an abstract class, is it also possible to create an abstract method? The answer again is yes. When creating an abstract method, the heading is declared in the superclass, but the body of the method is not defined as in the following: public abstract double calcArea(); Again, note that there is no body to the method and the first line of the method ends in a semicolon. If the heading is in the superclass and there is no body to the method, where is the body defined? The complete method is defined in the subclass as it was before and as shown below: public double calcArea() { double area; area 1⁄4 Math.sqrt(3.0) * calcRegPolyArea() / 4.0; return area; } If the above method is the same as before, what is the advantage of doing this? The advantage is that it allows different subclasses to have different methods using 9.3 Abstract Classes 277

Objects: Inheritance and Polymorphism

This chapter returns to objects and explores the concepts of inheritance. Contours are used to explain how a subclass is extended and inherits data members and methods from a superclass. Further, protected variables and methods along with abstract classes are discussed. Another object-oriented programming concept, polymorphism, which is a useful tool for developing software, is introduced. A complete program implementing inheritance and polymorphism is included.

Objects: An Introduction

This chapter introduces classes and objects. Public and private data members along with value-returning methods and void methods with parameters are discussed. How objects are created and how methods are invoked are illustrated using contour diagrams. Contours help the reader have a better understanding of object-oriented concepts by providing visual representation of objects. Constructors are introduced along with multiple objects and classes. Lastly, UML (Universal Modeling Language) class diagrams are illustrated and a complete program implementing a simple class and client program is provided.