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 arethmetic
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 DivideByZero 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 pseudo code for a sub-class of SimpleCalculator called Calculator that meets the requirements:

```
class Calculator extends SimpleCalculator {
private int num1;
private int num2;

public Calculator(int num1, int num2) {
this.num1 = num1;
this.num2 = num2;
}

public int multiply(int num1, int num2) {
return num1 * num2;
}

public int divide(int num1, int num2) throws DivideByZero {
if (num2 == 0) {
throw new DivideByZero("Attempted to divide by zero");
}
return num1 / num2;
}
}

class DivideByZero extends Exception {
public DivideByZero(String message) {
super(message);
}
}

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Enter the first number: ");
int num1 = scanner.nextInt();

System.out.print("Enter the second number: ");
int num2 = scanner.nextInt();

Calculator calculator = new Calculator(num1, num2);

try {
int result = calculator.multiply(num1, num2);
System.out.println("Result of multiplication: " + result);

result = calculator.divide(num1, num2);
System.out.println("Result of division: " + result);
} catch (DivideByZero e) {
System.out.println("Error: " + e.getMessage());
}
}
```

Explanation:
1. We define a sub-class called `Calculator` that extends `SimpleCalculator` and has private fields `num1` and `num2`.
2. The constructor `Calculator(int num1, int num2)` sets the values of `num1` and `num2`.
3. The `multiply` method multiplies two numbers and returns the result.
4. The `divide` method divides two numbers and returns the result. If the second number is zero, it throws a custom exception called `DivideByZero`.
5. The `DivideByZero` class is a custom exception that extends `Exception` and takes a message as a parameter.
6. In the `main` method, we prompt the user for two numbers and read them in using a `Scanner`.
7. We create an instance of `Calculator` by calling the constructor with the input values.
8. We try to call the `multiply` and `divide` methods of the `calculator` object.
9. If a `DivideByZero` exception is thrown, we catch it and display an error message. Otherwise, we display the results of each arithmetic operation.