Design a sub-class of SimpleCalculator called Calculator using psudoecode that contains public methods named multiply(), and divide() and that defines private fields called num1 and num2. Each of the methods accepts two numeric arguments and returns a number that represents the result of the appropriate Calculator operation. Design a two-arg constructor Calculator() that sets the two values num1 and num2. Design a main() method that prompts the user for two numbers and reads them in. Then creates an instance of the Calculator class setting the input values via the Calculator constructor. The main() method then tries each of the four arithmetic methods. Assume that an CalculatorException is created and thrown if the user attempts to divide by 0. Display an appropriate message when an exception is caught. If no exception, display the results from each arithmetic method call.
Here's the pseudocode to implement the subclass of SimpleCalculator called Calculator:
```
class Calculator extends SimpleCalculator
private field num1
private field num2
constructor Calculator(num1, num2)
this.num1 = num1
this.num2 = num2
method multiply(num1, num2)
return num1 * num2
method divide(num1, num2)
if num2 is 0
throw CalculatorException("Division by zero is not allowed")
else
return num1 / num2
class CalculatorException
constructor CalculatorException(message)
super(message)
function main()
display "Enter the first number: "
read num1
display "Enter the second number: "
read num2
try
calculator = new Calculator(num1, num2)
result = calculator.multiply(num1, num2)
display "Multiplication result: " + result
result = calculator.divide(num1, num2)
display "Division result: " + result
catch CalculatorException as exception
display "Exception caught: " + exception.getMessage()
finally
display "Program finished."
```
Please note that this is pseudocode and may need to be adjusted based on the specific programming language you are using when implementing the Calculator class.
Here's a possible solution implementing the requirements using pseudocode:
```
class Calculator extends SimpleCalculator {
private num1
private num2
constructor Calculator(value1, value2) {
num1 = value1
num2 = value2
}
public multiply() {
return num1 * num2
}
public divide() {
if (num2 == 0) {
throw new CalculatorException("Error: Division by zero is not allowed")
} else {
return num1 / num2
}
}
}
function main() {
prompt user for value1
read value1 from user input
prompt user for value2
read value2 from user input
create an instance of Calculator with value1 and value2
try {
result = Calculator.multiply()
display result
} catch (CalculatorException) {
display "Error: Caught CalculatorException"
}
try {
result = Calculator.divide()
display result
} catch (CalculatorException) {
display "Error: Caught CalculatorException"
}
}
```
In this solution, we have a subclass called `Calculator` which extends the `SimpleCalculator` class. It has private fields `num1` and `num2` to store the input values.
The `Calculator` constructor is a two-argument constructor that sets the values of `num1` and `num2` based on the input.
The `multiply` method multiplies `num1` and `num2` and returns the result.
The `divide` method first checks if `num2` is equal to 0. If it is, it throws a `CalculatorException` indicating that division by zero is not allowed. Otherwise, it performs the division and returns the result.
In the `main` method, we prompt the user for two numbers (`value1` and `value2`) and read them in. Then, we create an instance of the `Calculator` class using these input values.
We then try to call the `multiply` method and display the result. If a `CalculatorException` is caught, we display an error message indicating that the exception was caught.
Similarly, we try to call the `divide` method and display the result. If a `CalculatorException` is caught, we display an error message indicating that the exception was caught.
I hope this helps! Let me know if you have any further questions.