The Object Stack assignment requires you to implement the ObjectStackADT interface using a sequential representation based on the Vector class.

ADT

/*
 * ObjectStackADT.java
 */

package datatypes.stack;

public interface ObjectStackADT {
   public boolean emptyp();
   public boolean fullp();
   public Object top();
   public void push(Object data) throws ObjectStackOverflowException;
   public Object pop() throws ObjectStackUnderflowException;
   public String toString();   
}

Exception Classes

/*
 * ObjectStackOverflowException.java
 */

package datatypes.stack;

public class ObjectStackOverflowException extends java.lang.Exception {
    
    public ObjectStackOverflowException() {
    }
    
    
    public ObjectStackOverflowException(String msg) {
        super(msg);
    }
}

/*
 * ObjectStackUnderflowException.java
 */

package datatypes.stack;

public class ObjectStackUnderflowException extends java.lang.Exception {
    
    public ObjectStackUnderflowException() {
    }
    
    public ObjectStackUnderflowException(String msg) {
        super(msg);
    }
}

Implementation

/*
 * ObjectStack.java
 */

package datatypes.stack.sequential;

import java.util.*;
import datatypes.stack.*;

public class ObjectStack implements ObjectStackADT {
    
    // instance variables
    private Vector s;
    private int limit;
    
    // constructors
    
    // Use this constructor if you want Java to worry about
    // the stack being full
    
    public ObjectStack()
    {
        this.limit = -1;
        s = new Vector(0);
    }
    
    // Use this constructor if YOU want to worry about
    // the stack being full
    
    public ObjectStack(int limit)
    {
        this.limit = limit;
        s = new Vector(0);
    }
    
    // instance methods
    
    public boolean fullp()
    {
        return ( s.size() == limit );
    }
    
    public boolean emptyp()
    {
        return ( s.size() == 0 );
    }
    
    public Object top()
    {
        return s.elementAt(s.size()-1);
    }
    
    public void push(Object data) throws ObjectStackOverflowException
    {
        if ( fullp() ) {
            throw new ObjectStackOverflowException();
        }
        s.addElement(data);
    }
    
    public Object pop() throws ObjectStackUnderflowException
    {
        Object result = null;
        if ( emptyp() ) {
            throw new ObjectStackUnderflowException();
        } else {
            result = s.elementAt(s.size()-1);
            s.removeElementAt(s.size()-1);
        }
        return result;
    }
    
    private int size()
    {
        return s.size();
    }
    
    public String toString()
    {
        String result = "";
        result = result + "TOP of stack\n";                 
        for ( int i = s.size() - 1; i >= 0; i-- ) {
                result = result + s.elementAt(i).toString() + "\n";
        }
        result = result + "BOTTOM of stack";
        return result;
    }
    
}

Test Program and Demo

/*
 * ObjectStackTest.java
 */

package testers;

import datatypes.stack.*;
import datatypes.stack.sequential.*;

public class ObjectStackTest {
    
    public ObjectStackTest() {
    }
    
    public static void main(String[] args) {
        test_part1();
        test_part2();
        test_part3();
    }

    static private void test_part1()
    {
        System.out.println(">>> Testing unlimited stack constructor, push, pop, and toString");
        ObjectStack  stack = new ObjectStack();
        try {
            stack.push("A");
            stack.push("B");
            stack.push("C");
            stack.pop();
            stack.push("D");
            stack.push("E");
            stack.pop();
            stack.push("F");
            stack.push("G");
            stack.pop();
            stack.push("H");
        } catch ( ObjectStackOverflowException e ) {
            System.out.println("Stack overflow occurred");
            display(stack);
        } catch ( ObjectStackUnderflowException e ) {
            System.out.println("Stack overflow occurred");
            display(stack);
        }
        display(stack);
    }


    static private void test_part2()
    {
        System.out.println(">>> Testing limited stack constructor");
        ObjectStack  stack = new ObjectStack(4);
        System.out.println(">>> Testing overflow handling");
        try {
            stack.push("one");
            stack.push("two");
            stack.push("three");
            stack.push("four");
            stack.push("five");
        } catch ( ObjectStackOverflowException e ) {
            System.out.println("Stack overflow occurred");
            display(stack);
        } 
        System.out.println(">>> Testing underflow handling");
        try {
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();
            stack.pop();
        } catch ( ObjectStackUnderflowException e ) {
            System.out.println("Stack underflow occurred");
            display(stack);
        }
    }

    static private void test_part3()
    {
        System.out.println(">>> Testing emptyp, fullp, and top");
        ObjectStack  stack = new ObjectStack(3);
        try {
            stack.push("red");
            stack.push("yellow");
            stack.push("blue");
            display(stack);
            if ( stack.emptyp() ) {
                System.out.println("stack is empty");
            } else if ( stack.fullp() ) {
                System.out.println("stack is full");
            }
            System.out.println("top = " + stack.top());
            stack.pop();
            stack.pop();
            stack.pop();
            display(stack);
            if ( stack.emptyp() ) {
                System.out.println("stack is empty");
            } else if ( stack.fullp() ) {
                System.out.println("stack is full");
            }
        } catch ( ObjectStackOverflowException e ) {
            System.out.println("Stack overflow occurred");
            display(stack);
        } catch ( ObjectStackUnderflowException e ) {
            System.out.println("Stack overflow occurred");
            display(stack);
        }
    }

    static private void display(ObjectStack s)
    {
        System.out.println(s.toString());
    }

}

init:
deps-jar:
compile-single:
run-single:
>>> Testing unlimited stack constructor, push, pop, and toString
TOP of stack
H
F
D
B
A
BOTTOM of stack
>>> Testing limited stack constructor
>>> Testing overflow handling
Stack overflow occurred
TOP of stack
four
three
two
one
BOTTOM of stack
>>> Testing underflow handling
Stack underflow occurred
TOP of stack
BOTTOM of stack
>>> Testing emptyp, fullp, and top
TOP of stack
blue
yellow
red
BOTTOM of stack
stack is full
top = blue
TOP of stack
BOTTOM of stack
stack is empty
BUILD SUCCESSFUL (total time: 1 second)

Questions

1. Where will the ADT be packaged?
2. Where will the exception classes be packaged?
3. Where will the implementation class be packaged?
4. Where will the test program be packaged?