reverse for stacks??

[Shananne DuFrame]

Heres my code

 
public class StackClass1
{
    private  int maxStackSize;    //variable to store the maximum 
                                  //stack size
    private  int stackTop;        //variable to point to the top 
                                  //of the stack
    private  String[] list;  //array of reference variables 
 
        //default constructor
        //Create an array of size 100 to implement the stack.
        //Postcondition: The variable list contains the base
        //               address of the array, stackTop = 0, and
        //               maxStackSize = 100.
    public StackClass1()
    {
        maxStackSize = 100;
        stackTop = 0;         //set stackTop to 0
        list = new String[maxStackSize];   //create the array 
    }//end default constructor
 
        //constructor with a parameter
        //Create an array of size stackSize to implement the stack.
        //Postcondition: The variable list contains the base
        //               address of the array, stackTop = 0, and
        //               maxStackSize = stackSize.
    public StackClass1(int stackSize)
    {
        if(stackSize <= 0)
        {
           System.err.println("The size of the array to implement "
                            + "the stack must be positive.");
           System.err.println("Creating an array of size 100.");
 
           maxStackSize = 100;
        }
        else
           maxStackSize = stackSize;   //set the stack size to
                                       //the value specified by
                                       //the parameter stackSize
        stackTop = 0;    //set stackTop to 0
        list = new String[maxStackSize]; //create the array 
    }//end constructor
 
        //Method to initialize the stack to an empty state.
        //Postcondition: stackTop = 0
    public void initializeStack()
    {
        for(int i = 0; i < stackTop; i++)
            list[i] = null;
        stackTop = 0;
    }//end initializeStack
 

        //Method to determine whether the stack is empty.
        //Postcondition: Returns true if the stack is empty;
        //               otherwise, returns false.
    public boolean isEmptyStack()
    {
        return (stackTop == 0);
    }//end isEmptyStack
 
        //Method to determine whether the stack is full.
        //Postcondition: Returns true if the stack is full;
        //               otherwise, returns false.
    public boolean isFullStack()
    {
        return (stackTop == maxStackSize);
    }//end isFullStack
 
        //Method to add newItem to the stack.
        //Precondition: The stack exists and is not full.
        //Postcondition: The stack is changed and newItem
        //               is added to the top of stack.
        //               If the stack is full, the method throws
        //               StackOverflowException
    public void push(String newItem) throws StackOverflowException
    {
        if(isFullStack())
            throw new StackOverflowException();
 
        list[stackTop] = newItem; //add newItem at the
                                            //top of the stack
        stackTop++;                         //increment stackTop
    }//end push
 

        //Method to return the top element of the stack.
        //Precondition: The stack exists and is not empty.
        //Postcondition: If the stack is empty, the method throws
        //               StackUnderflowException; otherwise, a
        //               reference to a copy of the top element
        //               of the stack is returned.
    public String top() throws StackUnderflowException
    {
        if(isEmptyStack())
            throw new StackUnderflowException();
 
        String temp = list[stackTop - 1];
 
        return temp;
    }//end top
 
        //Method to remove the top element of the stack.
        //Precondition: The stack exists and is not empty.
        //Postcondition: The stack is changed and the top
        //               element is removed from the stack.
        //               If the stack is empty, the method throws
        //               StackUnderflowException
    public void pop() throws StackUnderflowException
    {
        if(isEmptyStack())
           throw new StackUnderflowException();
           
        stackTop--;       //decrement stackTop
        list[stackTop] = null;
    }//end pop
 

        //Method to make a copy of otherStack.
        //This method is used only to implement the methods
        //copyStack and copy constructor
        //Postcondition: A copy of otherStack is created and
        //               assigned to this stack.
    private void copy(StackClass1 otherStack)
    {
         list = null;
         System.gc();
 
         maxStackSize = otherStack.maxStackSize;
         stackTop = otherStack.stackTop;
 
         list = new String[maxStackSize];
 
               //copy otherStack into this stack
         for(int i = 0; i < stackTop; i++)
             list[i] = otherStack.list[i];
    }//end copy
 

         //copy constructor
    public StackClass1(StackClass1 otherStack)
    {
        copy(otherStack);
    }//end constructor
 
        //Method to make a copy of otherStack.
        //Postcondition: A copy of otherStack is created and
        //               assigned to this stack.
    public void copyStack(StackClass1 otherStack)
    {
        if(this != otherStack) //avoid self-copy
           copy(otherStack);
    }//end copyStack
 
 public String toString()
 {
  String tempString="";

   while (!isEmptyStack())
  {
tempString +=peek();
  }
  return  tempString;
 }

    public String peek()
 {
return list[stackTop];
 } 

Heres what I have so far for testing:

  //Program to test various operations of a stack
 
public class StackProgram
{
    public static void main(String[] args)
    {
        StackClass1 intStack = new StackClass1(5);
        StackClass1 tempStack = new StackClass1();
 
       try
       {
           System.out.println( intStack.isEmptyStack());
  intStack.push("a");
           intStack.push("b");
           intStack.push("c");
        }
       catch(StackOverflowException sofe)
       {
            System.out.println(sofe.toString());
            System.exit(0);
        }
 
        tempStack.copyStack(intStack);  //copy intStack 
                                        //into tempStack
 
        System.out.print("tempStack elements: ");
 
        while(!tempStack.isEmptyStack())  //print tempStack
        {
           System.out.print(tempStack.top() + " ");
            tempStack.pop();
        }
 
        System.out.println();
 
        System.out.println("The top element of intStack: "
                        + intStack.top());
    }
}
  

My problem is how do I reverseStack?

this is what i tried:

  public static void reverse (StackClass1 otherStack) 
 { 
 otherStack = new StackClass1();

if (!isEmptyStack())
otherStack.push(pop());  
 }    

these are the errors:
StackClass1.java:177: non-static method isEmptyStack() cannot be referenced from a static context
if ( !isEmptyStack())
^
StackClass1.java:178: non-static method pop() cannot be referenced from a static context
otherStack.push(pop());
^
StackClass1.java:178: 'void' type not allowed here
otherStack.push(pop());
^
3 errors

[Keith Lynn]

StackClass1.java:177: non-static method isEmptyStack() cannot be referenced from a static context
if ( !isEmptyStack())
^
StackClass1.java:178: non-static method pop() cannot be referenced from a static context
otherStack.push(pop());
^
StackClass1.java:178: 'void' type not allowed here
otherStack.push(pop());
^
3 errors

The first two errors mean that you are trying to call an instance method on your class, but you are calling it from the main method or another static method in the class.

In the third case, your pop() method has return type void. I expect you meant to make it something else.
[ March 20, 2007: Message edited by: Keith Lynn ]

[Gavin Tranter]

The error tells you exactly what the problem is; you are trying to call a non static method from a static method.

The reverse method appears to be static static.

[Shananne DuFrame]

I got it! In a loop I had to assign top() to a new variable, use the top() method to read the element, then pop() to get to the next element. Thanks.