Scientific calculator using Java packages

import java.util.Scanner;
import java.util.Locale;
import calc.basic;
import calc.advanced;
import print.display;

Scanner and Locale come from java.util. basic and advanced are classes in calc, and display is in print. These imports connect the driver to separately compiled source files; they do not copy class code into Test.

public class Test {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in).useLocale(Locale.ROOT);
        System.out.println("1 Add | 2 Subtract | 3 Multiply | 4 Divide | 5 Power | 6 Sqrt | 7 Natural log | 0 Exit");

The public class name Test matches Test.java. main creates a scanner and displays choices 1–7 plus 0 for exit.

        while(in.hasNextLine()) {
            try {
                int choice=Integer.parseInt(in.nextLine().trim());if(choice==0)return;
                if(choice<1 || choice>7)throw new IllegalArgumentException("Invalid choice.");

Continue while another input line exists. Parse the choice; 0 returns from main. Reject choices outside 1–7 before attempting operands.

                if(!in.hasNextLine())throw new IllegalArgumentException("Missing operand.");
                double a=Double.parseDouble(in.nextLine().trim()),b=0;
                if(choice<=5){if(!in.hasNextLine())throw new IllegalArgumentException("Missing operand.");b=Double.parseDouble(in.nextLine().trim());}
                if(!Double.isFinite(a)||!Double.isFinite(b))throw new IllegalArgumentException("Finite operands required.");

Require a first operand. Addition through power need a second operand, while square root and log need only one. Reject NaN and infinities before dispatching the operation.

                double value;
                switch(choice){case 1:value=basic.add(a,b);break;case 2:value=basic.subtract(a,b);break;case 3:value=basic.multiply(a,b);break;case 4:value=basic.divide(a,b);break;case 5:value=advanced.power(a,b);break;case 6:value=advanced.sqrt(a);break;default:value=advanced.log(a);}
                display.result(value);

The switch assigns value using a static method in basic or advanced. Case 7 reaches the default log branch because the choice was already validated. display.result applies final-result validation and formatting.

            } catch(IllegalArgumentException|ArithmeticException e){System.out.println("Error: "+e.getMessage());}
        }
        System.out.println("End with choice 0.");
    }
}

The multi-catch prints input-domain or arithmetic errors. After the current iteration, the loop can read another available choice line. Reaching EOF without explicit 0 prints the final instruction. The braces close main and Test.

package calc;
public final class advanced {
    private advanced() { }

The class belongs to calc. It is final with a private constructor, so the intended use is through public static methods.

    public static double power(double a,double b) { return Math.pow(a,b); }

Return a raised to b. This method itself does not reject every non-finite result; the driver passes its result through display.result, which performs that check.

    public static double sqrt(double a) { if(a<0)throw new IllegalArgumentException("Square root needs a nonnegative value.");return Math.sqrt(a); }

Negative inputs throw IllegalArgumentException. Zero and positive inputs return Math.sqrt(a). This method consumes only one operand.

    public static double log(double a) { if(a<=0)throw new IllegalArgumentException("Natural log needs a positive value.");return Math.log(a); }
}

Require a strictly positive argument before calling Math.log, which uses base e. The final brace closes advanced.

package calc;
public final class basic {
    private basic() { }

package calc requires this file to live in the calc package structure. The public final class cannot be subclassed, and its private constructor prevents ordinary callers from creating an instance.

    public static double add(double a,double b) { return a+b; }
    public static double subtract(double a,double b) { return a-b; }
    public static double multiply(double a,double b) { return a*b; }

Each public static method takes two doubles and returns the indicated arithmetic result. Callers use basic.add or similar without an object. A non-finite result is checked by the shared display helper.

    public static double divide(double a,double b) { if(b==0)throw new ArithmeticException("Division by zero.");return a/b; }
}

Throw ArithmeticException for b == 0; otherwise return a/b as double. The final brace closes basic.

package print;
import java.util.Locale;
public final class display {
    private display() { }

package print matches its directory. Locale is imported for consistent formatting. The final class and private constructor make this a static utility rather than an object intended for construction.

    public static void result(double value) { if(!Double.isFinite(value))throw new ArithmeticException("Non-finite result.");System.out.printf(Locale.ROOT,"Result: %.4f%n",value); }
}

Double.isFinite rejects NaN or infinity produced by calculations. Otherwise print Result with four decimal places and a newline. This is why domain or overflow problems can be caught by the driver even after a calculation method returns.