[In Java] Implement a calculator with the given skeleton code: Note: Addition.ja
ID: 3886195 • Letter: #
Question
[In Java] Implement a calculator with the given skeleton code:
Note: Addition.java , Subtraction.java, Multiply.java, Divide.java, Exponent.java, Parenthesis.java Will need to be created, implemented and added into the hashmap of the operator class.
Please refer to the comments in each section.
// Evalulator.java
import java.util.*;
public class Evaluator {
private Stack<Operand> operandStack;
private Stack<Operator> operatorStack;
private StringTokenizer tokenizer;
private static final String DELIMITERS = "+-*^/#! ";
public Evaluator() {
operandStack = new Stack<>();
operatorStack = new Stack<>();
}
public int eval( String expression ) {
String token;
// The 3rd argument is true to indicate that the delimiters should be used
// as tokens, too. But, we'll need to remember to filter out spaces.
this.tokenizer = new StringTokenizer( expression, DELIMITERS, true );
// initialize operator stack - necessary with operator priority schema
// the priority of any operator in the operator stack other than
// the usual mathematical operators - "+-*/" - should be less than the priority
// of the usual operators
// TODO Operator is abstract - this will need to be fixed:
// operatorStack.push( new Operator( "#" ));
// When is it a good time to add the "!" operator?
while ( this.tokenizer.hasMoreTokens() ) {
// filter out spaces
if ( !( token = this.tokenizer.nextToken() ).equals( " " )) {
// check if token is an operand
if ( Operand.check( token )) {
operandStack.push( new Operand( token ));
} else {
if ( ! Operator.check( token )) {
System.out.println( "*****invalid token******" );
System.exit( 1 );
}
// TODO Operator is abstract - these two lines will need to be fixed:
// The Operator class should contain an instance of a HashMap,
// and values will be instances of the Operators. See Operator class
// skeleton for an example.
Operator newOperator = new Operator( token );
while ( operatorStack.peek().priority() >= newOperator.priority() ) {
// note that when we eval the expression 1 - 2 we will
// push the 1 then the 2 and then do the subtraction operation
// This means that the first number to be popped is the
// second operand, not the first operand - see the following code
Operator oldOpr = operatorStack.pop();
Operand op2 = operandStack.pop();
Operand op1 = operandStack.pop();
operandStack.push( oldOpr.execute( op1, op2 ));
}
operatorStack.push( newOperator );
}
}
}
// Control gets here when we've picked up all of the tokens; you must add
// code to complete the evaluation - consider how the code given here
// will evaluate the expression 1+2*3
// When we have no more tokens to scan, the operand stack will contain 1 2
// and the operator stack will have + * with 2 and * on the top;
// In order to complete the evaluation we must empty the stacks (except
// the init operator on the operator stack); that is, we should keep
// evaluating the operator stack until it only contains the init operator;
// Suggestion: create a method that takes an operator as argument and
// then executes the while loop; also, move the stacks out of the main
// method
return 0;
}
}
// EvaluatorTester.java
public class EvaluatorTester {
public static void main(String[] args) {
Evaluator evaluator = new Evaluator();
for ( String arg : args ) {
System.out.format( "%s = %d ", arg, evaluator.eval( arg ) );
// System.out.println( arg + " = " + evaluator.eval( arg ) );
}
}
}
// Operand.java
public class Operand {
public Operand( String token ) {
}
public Operand( int value ) {
}
public int getValue() {
return 0;
}
public static boolean check( String token ) {
return false;
}
}
// EvalulatorUI.java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class EvaluatorUI extends JFrame implements ActionListener {
private TextField txField = new TextField();
private Panel buttonPanel = new Panel();
// total of 20 buttons on the calculator,
// numbered from left to right, top to bottom
// bText[] array contains the text for corresponding buttons
private static final String[] bText = {
"7", "8", "9", "+", "4", "5", "6", "- ", "1", "2", "3",
"*", "0", "^", "=", "/", "(", ")", "C", "CE"
};
private Button[] buttons = new Button[ bText.length ];
public static void main(String argv[]) {
EvaluatorUI calc = new EvaluatorUI();
}
public EvaluatorUI() {
setLayout( new BorderLayout() );
add( txField, BorderLayout.NORTH );
txField.setEditable( false );
add( buttonPanel, BorderLayout.CENTER );
buttonPanel.setLayout( new GridLayout( 5, 4 ));
//create 20 buttons with corresponding text in bText[] array
for ( int i = 0; i < 20; i++ ) {
buttons[ i ] = new Button( bText[ i ]);
}
//add buttons to button panel
for (int i=0; i<20; i++) {
buttonPanel.add( buttons[ i ]);
}
//set up buttons to listen for mouse input
for ( int i = 0; i < 20; i++ ) {
buttons[ i ].addActionListener( this );
}
setTitle( "Calculator" );
setSize( 400, 400 );
setLocationByPlatform( true );
setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE );
setVisible( true );
}
public void actionPerformed( ActionEvent arg0 ) {
//Needs to be implemented
}
// Operator.java
import java.util.HashMap;
public abstract class Operator {
// The Operator class should contain an instance of a HashMap
// This map will use keys as the tokens we're interested in,
// and values will be instances of the Operators.
//Implement hashmap here, add the Addition.java , Subtraction.java, Multiply.java, Divide.java, Exponent.java, Parenthesis.java classes into this hashmap.
public abstract int priority();
public abstract Operand execute( Operand op1, Operand op2 );
public static boolean check( String token ) {
return false;
}
}
Explanation / Answer
The code so far modified
// Evalulator.java
import java.util.*;
public class Evaluator {
private Stack<Operand> operandStack;
private Stack<Operator> operatorStack;
private StringTokenizer tokenizer;
private static final String DELIMITERS = "+-*^/#! ";
public Evaluator() {
operandStack = new Stack<>();
operatorStack = new Stack<>();
}
public int eval( String expression ) {
String token;
// The 3rd argument is true to indicate that the delimiters should be used
// as tokens, too. But, we'll need to remember to filter out spaces.
this.tokenizer = new StringTokenizer( expression, DELIMITERS, true );
// initialize operator stack - necessary with operator priority schema
// the priority of any operator in the operator stack other than
// the usual mathematical operators - "+-*/" - should be less than the priority
// of the usual operators
// TODO Operator is abstract - this will need to be fixed:
// operatorStack.push( new Operator( "#" ));
// When is it a good time to add the "!" operator?
while ( this.tokenizer.hasMoreTokens() ) {
// filter out spaces
if ( !( token = this.tokenizer.nextToken() ).equals( " " )) {
// check if token is an operand
if ( Operand.check( token )) {
operandStack.push( new Operand( token ));
} else {
if ( ! Operator.check( token )) {
System.out.println( "*****invalid token******" );
System.exit( 1 );
}
// TODO Operator is abstract - these two lines will need to be fixed:
// The Operator class should contain an instance of a HashMap,
// and values will be instances of the Operators. See Operator class
// skeleton for an example.
Operator newOperator = new Operator( token );
while ( operatorStack.peek().priority() >= newOperator.priority() ) {
// note that when we eval the expression 1 - 2 we will
// push the 1 then the 2 and then do the subtraction operation
// This means that the first number to be popped is the
// second operand, not the first operand - see the following code
Operator oldOpr = operatorStack.pop();
Operand op2 = operandStack.pop();
Operand op1 = operandStack.pop();
operandStack.push( oldOpr.execute( op1, op2 ));
}
operatorStack.push( newOperator );
}
}
}
// Control gets here when we've picked up all of the tokens; you must add
// code to complete the evaluation - consider how the code given here
// will evaluate the expression 1+2*3
// When we have no more tokens to scan, the operand stack will contain 1 2
// and the operator stack will have + * with 2 and * on the top;
// In order to complete the evaluation we must empty the stacks (except
// the init operator on the operator stack); that is, we should keep
// evaluating the operator stack until it only contains the init operator;
// Suggestion: create a method that takes an operator as argument and
// then executes the while loop; also, move the stacks out of the main
// method
return 0;
}
}
// EvaluatorTester.java
public class EvaluatorTester {
public static void main(String[] args) {
Evaluator evaluator = new Evaluator();
for ( String arg : args ) {
System.out.format( "%s = %d ", arg, evaluator.eval( arg ) );
// System.out.println( arg + " = " + evaluator.eval( arg ) );
}
}
}
// Operand.java
public class Operand {
public Operand( String token ) {
}
public Operand( int value ) {
}
public int getValue() {
return 0;
}
public static boolean check( String token ) {
return false;
}
}
// EvalulatorUI.java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class EvaluatorUI extends JFrame implements ActionListener {
private TextField txField = new TextField();
private Panel buttonPanel = new Panel();
// total of 20 buttons on the calculator,
// numbered from left to right, top to bottom
// bText[] array contains the text for corresponding buttons
private static final String[] bText = {
"7", "8", "9", "+", "4", "5", "6", "- ", "1", "2", "3",
"*", "0", "^", "=", "/", "(", ")", "C", "CE"
};
private Button[] buttons = new Button[ bText.length ];
public static void main(String argv[]) {
EvaluatorUI calc = new EvaluatorUI();
}
public EvaluatorUI() {
setLayout( new BorderLayout() );
add( txField, BorderLayout.NORTH );
txField.setEditable( false );
add( buttonPanel, BorderLayout.CENTER );
buttonPanel.setLayout( new GridLayout( 5, 4 ));
//create 20 buttons with corresponding text in bText[] array
for ( int i = 0; i < 20; i++ ) {
buttons[ i ] = new Button( bText[ i ]);
}
//add buttons to button panel
for (int i=0; i<20; i++) {
buttonPanel.add( buttons[ i ]);
}
//set up buttons to listen for mouse input
for ( int i = 0; i < 20; i++ ) {
buttons[ i ].addActionListener( this );
}
setTitle( "Calculator" );
setSize( 400, 400 );
setLocationByPlatform( true );
setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE );
setVisible( true );
}
public void actionPerformed( ActionEvent arg0 ) {
//Needs to be implemented
}
// Operator.java
import java.util.HashMap;
public abstract class Operator {
// The Operator class should contain an instance of a HashMap
// This map will use keys as the tokens we're interested in,
// and values will be instances of the Operators.
//Implement hashmap here, add the Addition.java , Subtraction.java, Multiply.java, Divide.java, Exponent.java, Parenthesis.java classes into this hashmap.
public abstract int priority();
public abstract Operand execute( Operand op1, Operand op2 );
public static boolean check( String token ) {
return false;
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.