Additional for extension

Additional.java

import java.util.Stack;
import java.util.Vector;

class Additional extends BasicCalculator {
	
	
	private String givenstring;
	private String substitute;

	private Vector<Content> infix = new Vector<Content>();
	private  Vector <Float> numbersObtained = new Vector<Float>();
	private  Vector<Content> postFix = new Vector<Content>();

	Additional ()
	{
	}

	Additional (String givenstring) 
	{
		this.givenstring = givenstring;
		this.substitute  = givenstring;
	}

	private class Content 
	{
		public float number;
		public char symbol;
		public boolean flag;

		Content () 
		{
		}
	}

	public boolean lowerPrecedence(char infixSymbol , char stackSymbol)
	{
		if((infixSymbol=='*'||infixSymbol=='/' || infixSymbol == '^')&&(stackSymbol=='+'||stackSymbol=='-')) return true;
		else return false;
	}

	public Content makeContentWithNumber (float numberObtained)
	{
		Content node = new Content();
		node.number = numberObtained;
		node.flag = true;
		return node;
	}

	public Content makeContentWithSymbol (char symbolFromInputStringArray)
	{
		Content node = new Content();
		node.symbol = symbolFromInputStringArray;
		node.flag = false;
		return node;
	}

	public void parsingInput () 
	{

		String temp1 = substitute.replaceAll("[+^*/-]"," ").replaceAll("[()]"	,"");
		
		this.substitute = substitute.replaceAll("[+^*/-]"," ").replaceAll("[()]"	," ");

		if(temp1.charAt(0) == ' ') temp1.replaceFirst(" ", "");
		
		
		String [] temp = temp1.split("[ ]");

		for(int i = 0 ; i < temp.length ; i++){
			numbersObtained.add(Float.parseFloat(temp[i]));
		}

		for(int i=0; i<givenstring.length(); i++)
		{
			if(substitute.charAt(i)== ' ')
			{
				if(i != 0)
				{
					if(substitute.charAt(i-1)!= ' ')
					{
						Content node = new Content();

						node = makeContentWithNumber(numbersObtained.elementAt(0));
						infix.add(node);
						numbersObtained.remove(0);
						
						node = makeContentWithSymbol(givenstring.charAt(i));
						infix.add(node);
					}
					else
					{
						Content node = new Content();
						node = makeContentWithSymbol( givenstring.charAt(i));
						infix.add(node);
					}
				}
				else
				{
					Content node = new Content();
					node = makeContentWithSymbol( givenstring.charAt(i));
					infix.add(node);
				}
			}
		}

		if(!numbersObtained.isEmpty())
		{
			Content node = new Content();
			node = makeContentWithNumber(numbersObtained.elementAt(0));
			infix.add(node);
			numbersObtained.remove(0);
		}


	}

	public void infixToPostfix()
	{
		Stack <Content> myStack = new Stack<>();

		Content node = new Content();

		node = makeContentWithSymbol('(');
		myStack.push(node);

		node = makeContentWithSymbol( ')');
		infix.add(node);

		for(int i=0; i<infix.size(); i++)
		{
			if(infix.elementAt(i).flag)
			{
				postFix.add(infix.elementAt(i));
			}
			else
			{
				if(infix.elementAt(i).symbol == '(')
				{
					myStack.push(infix.elementAt(i));
				}
				else if(infix.elementAt(i).symbol == ')')
				{
					while(true)
					{
						Content tempNode = new Content();
						tempNode = myStack.lastElement();

						if(tempNode.symbol == '(')
						{
							myStack.pop();
							break;
						}
						else
						{
							postFix.add(tempNode);
							myStack.pop();
						}
					}
				}
				else
				{
					while(true)
					{
						Content tempNode1 = new Content();
						tempNode1 = myStack.lastElement();
						if(lowerPrecedence(infix.elementAt(i).symbol, tempNode1.symbol)|| tempNode1.symbol == '(') break;
						postFix.add(tempNode1);
						myStack.pop();
					}
					myStack.push(infix.elementAt(i));
				}
			}
		}
	}

	public float evaluatePostfix()
	{
		Stack <Float> myStack = new Stack <>();

		for(int i=0; i<postFix.size(); i++)
		{
			if(postFix.elementAt(i).flag)
			{
				myStack.push(postFix.elementAt(i).number);
			}
			else
			{
				float stackTop0, stackTop1, result;
				stackTop0 = myStack.lastElement();
				myStack.pop();
				stackTop1 = myStack.lastElement();
				myStack.pop();
				result = evaluateBasicArithmetic(stackTop0, stackTop1, postFix.elementAt(i).symbol);
				myStack.push(result);
			}
		}
		return myStack.lastElement();
	}

	public float output(){
		parsingInput();
		infixToPostfix();
		return evaluatePostfix();
	}

	public float evaluateBasicArithmetic(float a, float b, char symbol)
	{
		switch(symbol)
		{
			case '+': return add(a, b);
			case '-': return subtract(b, a);
			case '*': return multiply(a, b);
			case '^': return exponent(b, a);
			default: return divide(b, a);
		}
	}

}