Converting Operand<T> to Integer

Question

I'm creating a Postfix evaluator method using a self implemented Linked List and i'm really stuck at the end here. I need to return the final stack value via pop. In my method my return type must be an Integer. I attempted a solution and it tells me "cannot convert from Operand<Integer> to Integer". I assume I need to convert it somehow, but I don't know how to go about it, any help would be appreciated.

I could not find anything helpful so I apologize if this is a duplicate.

Here is my method:

public class ArithPostfixEvaluator implements PostfixEvaluator<Integer> {

    private final StackInterface<Operand<Integer>> stack;

    /**
     * Constructs an {@link ArithPostfixEvaluator}
     */
    public ArithPostfixEvaluator(){
        //Initialize the LinkedStack
        stack = new LinkedStack<>();
    }

    public Integer evaluate(String expr) throws IllegalPostfixExpressionException {

        ArithPostfixParser parser = new ArithPostfixParser(expr);
        for (Token<Integer> token : parser) {
            Type type = token.getType();
            switch(type){ 
            case OPERAND:
            //What to do when we see an operand?
                //create an operand variable
                Operand<Integer> operand = token.getOperand();
                //push the operand onto the stack
                stack.push(operand);
                break;
            case OPERATOR:
            //What to do when we see an operator?
                //create an operator variable
                Operator<Integer> operator = token.getOperator();
                //make a new operand called result
                Operand<Integer> result;   
                //pop 2 operands
                Operand<Integer> op1 = stack.pop();
                Operand<Integer> op2 = stack.pop();
                //the first operand goes in the second position
                operator.setOperand(2, op1);
                operator.setOperand(1, op2);
                //perform operation on result
                result = operator.performOperation();
                //push the result back onto the stack
                stack.push(result);
                break;
            default:
                throw new IllegalStateException("Parser returned an invalid Type: " + type);
            }                       
        }       
        // what to return?

        ///////////PROBLEM AREA////////////////

        Integer Finalval = stack.pop();
        //pop the remaining element on the stack
        return Finalval ;
    }

Here is my linked list:

public class LinkedStack<T> implements StackInterface<T> {

    private LLNode<T> head;
    private int size;

    public T pop() throws StackUnderflowException {
    if(isEmpty()) throw new StackUnderflowException("Stack Underflow yo");
    T temp = head.getData();
    head = head.getNext();
    return temp;
    }

    public T top() throws StackUnderflowException {
        if(isEmpty()) throw new StackUnderflowException("Stack Underflow yo");
    return head.getData();
    }

    public boolean isEmpty() {
    return (head == null);
    }

    public int size() {
    return size;
    }

    public void push(T elem) {
        LLNode<T> newnode = new LLNode<T>(elem);
        newnode.setNext(head);
        head = newnode;
        size++;
    }

}

And my Operand and Operator classes:

public class Operand<T> {
    private final T value;

    public Operand(T value){
        this.value = value;
    }
    public T getValue(){
        return value;
    }
    public String toString() {
        return value.toString();
    }
}


public interface Operator<T> {

    public int getNumberOfArguments();

    public Operand<T> performOperation();

    public void setOperand(int position, Operand<T> operand);

}

Answer 1

private final StackInterface<Operand<Integer>> stack;

The stack contains Operand<Integer>s, so you can't do this:

Integer Finalval = stack.pop();

That tries to store an Operand<Integer> in an Integer variable. You could do:

Integer Finalval = stack.pop().getValue();