Java How to Program Fourth Edition - DCC

Chapter 19 Data Structures 1109
occurs, the successive return addresses are pushed onto the stack in last-in, first-out order
so that each method can return to its caller. Stacks support recursive method calls in the
same manner as they do conventional nonrecursive method calls.
The program execution stack contains the memory for local variables on each invocation
of a method during a program’s execution. When the method returns to its caller, the
memory for that method’s local variables is popped off the stack and those variables are no
longer known to the program.
Compilers use stacks to evaluate arithmetic expressions and generate machine language
code to process the expressions. The exercises in this chapter explore several applications
of stacks, including using them to develop a complete working compiler. The
java.util package of the Java API contains class Stack for implementing and manipulating
stacks that can grow and shrink during program execution. We will discuss class
Stack in Chapter 20.
We take advantage of the close relationship between lists and stacks to implement a
stack class by reusing a list class. We demonstrate two different forms of reusability. First,
we implement the stack class by extending class List of Fig. 19.3. Then we implement an
identically performing stack class through composition by including a List object as a
private member of a stack class. The list, stack and queue data structures in this chapter
are implemented to store Object references to encourage further reusability. Thus, any
object type can be stored in a list, stack or queue.
The application of Fig. 19.10 and Fig. 19.11 creates a stack class by extending class
List of Fig. 19.3. We want the stack to have methods push, pop, isEmpty and print.
Essentially, these are the methods insertAtFront, removeFromFront, isEmpty
and print of class List. Of course, class List contains other methods (such as
insertAtBack and removeFromBack) that we would rather not make accessible
through the public interface to the stack class. It is important to remember that all
methods in the public interface of class List class also are public methods of the subclass
StackInheritance (Fig. 19.10). When we implement the stack’s methods, we
have each StackInheritance method call the appropriate List method—method
push calls insertAtFront and method pop calls removeFromFront. Class
StackInheritance is defined as part of package com.deitel.jhtp4.ch19 for
reuse purposes. Note that StackInheritance does not import List, because both
classes are in the same package.
1 // Fig. 19.10: StackInheritance.java
2 // Derived from class List
3 package com.deitel.jhtp4.ch19;
4
5 public class StackInheritance extends List {
6
7 // construct stack
8 public StackInheritance()
9 {
10 super( "stack" );
11 }
12
Fig. Fig. 19.10 19.10 Class StackInheritance extends class List (part 1 of 2).