Initial code for the Stack Lab

package umm.softwaredesign.stacklab;



/**
 * Implementation of the StackIF interface for a basic stack.
 *
 * @author Nic McPhee, last changed by $Author: elenam $
 * on $Date: 2005/08/28 21:49:44 $
 * @version $Revision: 1.1.1.1 $
 */
public class Stack implements StackIF {
    /**
     * Construct an empty stack.
     */
    public Stack() {
        super();
        throw new UnsupportedOperationException();
    }

    /**
     * Makes a (shallow) copy of the given stack.  "Shallow" here
     * means that we don't copy the items on the stack as well, so
     * both stacks contain references to the same items in the same
     * order.
     *
     * We need this for (at least) testing purposes, as we want to be
     * able to make copies of stacks before we manipulate them so we
     * can compare the stack at the end of a process to the stack we
     * had at the beginning.  There are also no doubt non-testing
     * contexts where cloning could be useful as well.
     *
     * @param stack the stack to copy
     */
    public Stack(final Stack stack) {
        throw new UnsupportedOperationException();
    }

    /**
     * Push the specified value onto the stack.
     *
     * @param value the value to be pushed.
     */
    // WARNING - this parameter should be final so you can't reassign to it
    // in the body of the method.  This should be flagged by Checkstyle/PMD.
    public final void push(final Object value) {
    // WARNING there are tabs in this method instead of
    // groups of spaces.  This should be flagged by Checkstyle/PMD.
    throw new UnsupportedOperationException();
    }

    /**
     * Return the value on top of the stack.  This does not change the
     * stack in any way.  If the stack is empty a StackUnderflowException
     * is thrown.
     *
     * @return the top value on the stack
     */
    public final Object top() {
        // This should throw a StackUnderflowException if the stack is empty.
        throw new UnsupportedOperationException();
    }

    /**
     * Removes the top value from the stack.  If the stack is empty a
     * StackUnderflowException is thrown.
     */
    // WARNING - this method should be declared as final to prevent it from
    // being overridden incorrectly in a subclass.  This should be flagged
    // by Checkstyle/PMD.
    public void pop() {
        // This should throw a StackUnderflowException if the stack is empty.
        throw new UnsupportedOperationException();
    }

    /**
     * Computes the size of the stack.
     *
     * @return the number of elements on the stack
     */
    public final int size() {
        throw new UnsupportedOperationException();
    }

    /**
     * Determines if a stack is empty.
     *
     * @return true if the stack is empty, false otherwise
     */
    public final boolean isEmpty() {
        throw new UnsupportedOperationException();
    }

    /**
     * Determines if a stack is full.
     *
     * If you use an appropriate Java library Container class to store
     * the stack elements, this should always return false.
     *
     * @return true if the stack is full, false otherwise
     */
    public final boolean isFull() {
        throw new UnsupportedOperationException();
    }

    /**
     * Determines if this stack is equal to another.  Two stacks are equal
     * if they have the same elements (as determined by the equals
     * on the underlying object) in the same order.
     *
     * @param other the object to compare to.  equals() will return false
     * if other isn't a Stack.
     *
     * @return true exactly when this stack is equal to other.
     */
    public final boolean equals(final Object other) {
        throw new UnsupportedOperationException();
    }

    /**
     * Computes a hash code for this stack.
     *
     * We need to override the default behavior for hashCode() because
     * we've overridden the default behavior of equals().  If we don't
     * also do hashCode(), then, e.g., containers like HashSet won't
     * won't work if we put stacks in them.  See Item 8 in Bloch's
     * Effective Java for more on this.
     *
     * @return a hashCode for this stack
     */
    public final int hashCode() {
        throw new UnsupportedOperationException();
    }

    /**
     * Generate a string representation of our stack.  A stack
     * containing elements [x0, x1, x2, ..., xn] (where x0 is the
     * bottom of the stack and x1 is the top) is represented by
     * the string "Stack[s0, s1, s2, ..., sn]", where the si are
     * the string (printed) representations of the elements xi.
     *
     * @return a string of this stack
     */
    public final String toString() {
        throw new UnsupportedOperationException();
    }
}


This is an example from CSci 3601 course.

The views and opinions expressed in this page are strictly those of the page author. The contents of this page have not been reviewed or approved by the University of Minnesota.