Query on Stack

Question

Could someone show me where I am going wrong in my incomplete answers to the following questions:
Question:
Software for a Web search engine requires the use of a class Stacker which just implements the functionality of a Stack associated with the methods empty(), peek(), pop(), and push(); it should not implement any of the functionality of the Vector class which Stack inherits from.
(i) What variables would you use in this class? Before answering this part of the question we would advise you to read the remainder of the question.
My answer:
//instance variables
private int count;//number of objects in the Stacker
private int maxSize;//maximum size of Stacker
private int top;//index of top of the Stack
private Object obj;
static variable;
private static final int noOfStackers; //maximum number of Stacker objects allowed to be created
Question:
Write down code for the four methods detailed above, their functionality is described below:
(ii) empty() � returns true if the Stacker is empty and false otherwise.
My Answer:
public boolean empty(){
return count= =0;
Question:
(iii) peek() � returns with the top object of the Stacker; this top object is not removed
My answer:
public Object peek(){
return Object obj;
Question:
(iv) pop() � removes the top object from the Stacker and returns it
My answer:
public Object pop(Object removedObj){
int i=top;
int j=top-1;
i=j;
count--;
return removedObj;
Question:
(v) push() � places and object in the Stacker
My answer:
public void push(Object addedObject){
top=addedObject;
count++;
Question
(vi) In addition to this the class should contain a constructor Stacker which has two int arguments. The first argument gives the maximum size of the Stacker and the second argument gives the maximum number of Stackers that may be created by a program.
My answer:
public Stacker(int max, int nos) {
maxSize=max;
noOfStackers =nos;
if (nos> noOfStackers)
Question:
(vii) Finally the class should contain a method setMaxStacks which has a single int argument which is the maximum number of Stackers that can be created
If the stack size is exceeded a StackOverflowException should be thrown; if a program creates more Stack objects than is allowed a TooMany StackersException is thrown
Do not write any code which caters for errors
My answer:
public void setMaxStacks(int maxNoStackers) throws StackOverFlowException, throws tooManyStackersException {
noOfStackers=maxNoStackers;
}

Answer 1

(i) What variables would you use in this class?You need to store more than the top object, which is all you currently store. I would suggest that instead of obj you have private Object[] stack. Now, building with the base of the stack at array offset 0, you don't need top because it's always the case that top == count - 1. Nor do you need maxSize, because maxSize == stack.length. And since there is a method setMaxStacks, noOfStackers should not be final. Also you need a static variable to count the number of Stackers which have been instantiated so far - e.g. private static int stackersInstantiated.
// Tidied up a bit
public boolean empty(){
return (count == 0);
}Correct.
peek() will need to look at the last defined element of the array stack, so peek() just returns stack[count - 1].
pop() is the same as peek, except that it decrements count. For tidiness' sake, you should remove the object from the stack. So public Object pop()
    Object popped = peek();
    stack[count - 1] = null;
    count--;
    return popped;
} A sensible spec would tell you to throw an exception if there is nothing to pop (and ditto for peek), but the one given doesn't. Unless that's what it means by
Do not write any code which caters for errorsLeft as an exercise for the reader.
The push method has to throw an exception if the stack size is exceeded. So public void push(Object obj) throws StackOverFlowException
    if (count == stack.length)
        throw new StackOverFlowException();
    stack[count++] = obj;
} Next, the constructor. This has two arguments and can throw a TooManyStackersException. The spec really breaks down into gibberish here. public Stacker (int maxSize, int newNoOfStackers) throws TooManyStackersException
    noOfStackers = newNoOfStackers; // I think this is the appropriate thing to do.  As I say, the spec is gibberish.
    if (stackersInstantiated >= noOfStackers)
        throw new TooManyStackersException();
    stack = new Object[maxSize];
    count = 0;
} Finally, the trivial setMaxStacks. public void setMaxStacks(int newNoOfStackers)
    noOfStackers = newNoOfStackers;