Java Calculator Application Development and Implementation Report

Introduction

In this program, we have developed a basic calculator that performs addition, subtraction, multiplication, and division based on user input. The program takes two numbers entered by the user and prompts the user to select an operation (+, -, *, or /) using a switch case to perform the chosen operation on the entered numbers.

The Calculator program supports both fundamental and scientific operations. Users have the option to switch between Fundamental mode and Scientific mode. Depending on the user's choice, the application invokes the corresponding class, allowing the user to perform various mathematical operations as defined in each class.

A base class contains all the calculation methods, both basic and scientific. The program also performs input validation and provides relevant feedback when users provide incorrect input.

Program Objectives

The development of the Calculator application serves the following objectives:

• Create a basic Java console application.
• Understand object-oriented concepts such as inheritance, polymorphism, and information hiding.
• Develop applications that request user input, validate the input, process it, and produce the desired output.
  Get quality help now

  

  Bella Hamilton

  Verified writer

  Proficient in: Technology

  5 (234)

  “ Very organized ,I enjoyed and Loved every bit of our professional interaction ”

  

  +84 relevant experts are online

  Hire writer

• Utilize Java features including type casting, interfaces, interface inheritance, loops, branching, packages, and I/O classes.

Creating the Calculator Application

To build the Calculator program, we created a total of 5 Java files. We started by developing an interface named 'iCalc.java.' Next, we created the base class 'Calculate.java,' which contains all the calculation methods. Following the base class, we created two classes: 'Calculator.java' and 'ScientificCalculator.java.'

These classes invoke the methods specified in the base class 'Calculate.' An instance of the 'Calculate' class is included in the 'Calculator' class, while the 'ScientificCalculator' class inherits from 'Calculate' and utilizes its methods.

Once all these classes were created, we developed the main 'UseCalculate' class, named 'UseCalculate.java,' to provide instances of either 'Calculator' or 'ScientificCalculator' depending on the user's choice.

Creating Files in Java

The iCalc Interface (iCalc.java)

The 'iCalc' interface defines a set of methods that can be used in any calculator implementation. It includes the following required methods:

• doCalculation(): Declares a method for performing calculations.
• getResult(): Declares a method for obtaining the calculation result.

The Calculate Class (Calculate.java)

The business logic of the calculator application is encapsulated within the 'Calculate' class. This class includes methods for addition, division, and tangent to facilitate various mathematical operations. By implementing the 'iCalc' interface, 'Calculate' adheres to interface guidelines. The following methods are included in this class:

Method Description

• Calculate(): Default constructor with no arguments for the class.
• Calculate(Double dblNum, char cOperator): Constructor with two arguments used for scientific calculations.
• Calculate(int iFirstNum, char cOperator, int iSecondNum): Constructor with three arguments used for simple calculations.
• doCalculation(): Determines the result based on user-input numbers and operator, overriding the iCalc interface's doCalculation method.
• getResult(): Outputs the result of the calculation, overriding the iCalc interface's getResult method.
• checkSecondNum(): Verifies that the second number entered is not zero when performing division.
• checkInt(): Tests if simple calculations are performed with integer values.
• checkDouble(): Tests the accuracy of mathematical calculations involving floating-point numbers.

Calculator Class (Calculator.java)

The Calculator class handles basic mathematical operations such as addition, subtraction, multiplication, and division of two numbers. Users are prompted to input the first number, the desired operation, and the second number for the calculation.

Input is obtained using the Java BufferedReader class. Upon receiving the three arguments (First Number, Operator, and Second Number), the Calculator class creates an instance of the Calculate class. Subsequently, the doCalculation() method is invoked, followed by the getResult() method, which displays the calculation result to the user. The Calculator class often employs a do-while loop, allowing users to perform multiple calculations until they type 'n' to indicate the end of processing.

ScientificCalculator Class (ScientificCalculator.java)

The ScientificCalculator class handles scientific operations including sine, cosine, tangent, and logarithm. Users are prompted to input the operation to be performed and the number for the calculation.

Input is obtained using the Java BufferedReader class. To utilize the operations, the ScientificCalculator class inherits from the Calculate class. By invoking its constructor with two arguments (Operator and Number), the class passes the user-entered values to the Calculate class. The class then calls the doCalculation() method, followed by the getResult() method, displaying the calculation result to the user. Similar to the Calculator class, the ScientificCalculator class employs a do-while loop, offering users the option to perform multiple calculations until they type 'n' to conclude the processing.

UseCalculator Class (UseCalculator.java)

The UseCalculator class allows users to choose between Simple and Scientific modes in the Calculator application. Depending on the user's choice, an instance of the Calculator class is created for Simple Operations or an instance of the ScientificCalculator class is created for Scientific Operations.

The UseCalculator class frequently uses a do-while loop, providing users with the opportunity to perform multiple calculations until they type 'n' to indicate the end of processing.

Class Files Generation

Command to create the class files:

javac

The steps for generating class files for the Calculator application are as follows:

• Place all Java files in the 'Calculator' directory.
• In the command prompt, navigate to the directory where the Java files for the Calculator program are located.
• Compile the following Java files in the specified sequence using the Java files compilation command:
  • iCalc.java
  • Calculate.java
  • Calculator.java
  • ScientificCalculator.java
  • UseCalculator.java

Using the Calculator Application

To utilize the Calculator application, follow these steps:

1. 1. In the command prompt, navigate to the parent directory of the 'Calculator' folder, which contains the class files for the Calculator program.
   2. Run the Calculator program using the following command:

java UseCalculator

1. Choose between 'b' (for simple operations) or 's' (for scientific operations) based on the desired operations.
2. If 'b' is selected, provide the following input:
   • First Number
   • The Operator
   • The Second Number
3. The outcome will be displayed on the command prompt based on the provided values.
4. Type 'y' to continue or 'n' to exit the application.
5. If 's' is selected, provide the following input:
   • The Operator
   • Number
6. The outcome will be displayed on the command prompt based on the provided values.
7. Type 'y' to continue or 'n' to exit the application.

Calculator Application Code

iCalc.java

iCalc.java defines the basic methods for the Calculate class through the iCalc interface. This interface establishes a structure that can be used for any class performing calculations.

// Adds the Interface to the Package
package Calculator;

// Interface Definition
interface iCalc {
public void doCalculation();
public void getResult();
}

Calculate.java

Calculate.java is the class responsible for all calculation methods required by any calculator class. It implements the iCalc interface.

// Adds the Class to the Package
package Calculator;

// Class Definition
class Calculate implements iCalc {
// Member variables and constructors...
// Calculates the result based on the operator selected by the user
public void doCalculation() {
    // Calculation logic...
}

// Displays the result of the calculation to the user
public void getResult() {
    // Result display logic...
}

// Other methods for checking input...
}

Calculator.java

Calculator.java handles basic arithmetic operations such as addition, subtraction, multiplication, and division for two numbers. It utilizes the Calculate class by creating objects and invoking its methods.

// Adds the Class to the Package
package Calculator;

// Imports Required Packages
import java.io.*;

// Class Definition
class Calculator {
// Member variables and methods...
public void Calc() throws java.io.IOException {
    // User input and calculation logic...
}
}

ScientificCalculator.java

ScientificCalculator.java performs scientific calculations such as sine, cosine, tangent, and logarithm of a number. It inherits from the Calculate class, allowing it to directly call the methods of its superclass.

/ Adds the Class to the Package
package Calculator;

// Imports Required Packages
import java.io.*;

// Class Definition
class ScientificCalculator extends Calculate {
// Member variables and constructors...
public void Calc() throws java.io.IOException {
    // User input and scientific calculation logic...
}
}

UseCalculator.java

UseCalculator.java is the main class for the Calculator application. It provides users with options to choose between the Basic or Scientific Calculator.

// Adds the Class to the Package
package Calculator;

// Imports Required Packages
import java.io.*;

// Class Definition
class UseCalculator {
public static void main(String[] args) throws java.io.IOException {
// User input and application logic...
}
}

Conclusion

Through the completion of this project, we have gained valuable insights into Java programming. We have successfully created a Java console application, enhancing our understanding of essential programming concepts such as inheritance, polymorphism, and data hiding.

This project has enabled us to develop an application capable of interacting with users, receiving input, validating that input, processing it, and delivering the desired output. Additionally, we have become proficient in utilizing various features of the Java language, including type conversion, interfaces, interface inheritance, looping, branching, working with packages, and leveraging I/O classes for input and output operations.

In summary, this endeavor has equipped us with practical knowledge and skills in Java programming, enhancing our ability to create applications that engage with users, handle input effectively, and produce meaningful results.