Salary slips using a nonstatic inner class

import java.util.*;

public class Main {
    private static final Scanner IN = new Scanner(System.in).useLocale(Locale.ROOT);

java.util.* imports utility type names such as Scanner, Locale and collections. Main is the public class matching Main.java. The private static final IN field holds one shared Scanner for System.in; final prevents replacing that reference. The scanner uses Locale.ROOT.

    static String text() {
        if (!IN.hasNextLine()) throw new IllegalArgumentException("Incomplete input.");
        String value = IN.nextLine().trim();
        if (value.isEmpty() || value.length() > 200) throw new IllegalArgumentException("Text must have 1–200 characters.");
        return value;
    }

text checks whether a line exists, reads it and removes leading/trailing whitespace. Reject empty text and lengths above 200 by throwing IllegalArgumentException. Otherwise return the string. One field is read per line, so these helpers do not mix nextInt with leftover newlines.

    static int integer(int low, int high) {
        int value = Integer.parseInt(text());
        if (value < low || value > high) throw new IllegalArgumentException("Integer out of range.");
        return value;
    }

Integer.parseInt converts the returned string to int or throws NumberFormatException, a subtype of IllegalArgumentException. Reject values outside the caller’s inclusive low/high limits, then return the accepted integer.

    static double number(double low, double high) {
        double value = Double.parseDouble(text());
        if (!Double.isFinite(value) || value < low || value > high) throw new IllegalArgumentException("Number out of range.");
        return value;
    }

Double.parseDouble reads the string as a double. Double.isFinite rejects NaN and infinities as well as the explicit low/high range check. Return only a finite accepted value; exceptions transfer control to a matching catch block.

    static void money(String label, double value) { System.out.printf(Locale.ROOT, "%s: %.2f%n", label, value); }

money is a formatting helper: %s prints the label, %.2f prints two decimal places, and %n ends the line. Locale.ROOT fixes locale-sensitive formatting. The helper can also display non-currency quantities; it does not change the stored value.

static class Employee {
        private final int id;
        private final String name, department;
        private final double baseSalary;

Employee is static relative to Main. Its identity and base salary fields belong to each Employee instance and are final after construction.

        Employee() { this(0, "Unassigned", 0, "Unassigned"); }
        Employee(int id, String name) { this(id, name, 0, "Unassigned"); }
        Employee(int id, String name, double baseSalary, String department) {
            if (!Double.isFinite(baseSalary) || baseSalary < 0 || baseSalary > 1000000) throw new IllegalArgumentException("Invalid salary.");
            this.id=id; this.name=name; this.baseSalary=baseSalary; this.department=department;
        }

The no-argument and two-argument constructors call the full constructor with defaults. The full constructor validates salary and assigns fields. Overloading is chosen by argument list at compile time.

        void displayEmployeeDetails() { System.out.println(id + " | " + name + " | " + department); }
        double calculateSalary() { SalaryBreakup breakup = new SalaryBreakup(); breakup.computeBreakup(); return breakup.netPay; }
        void generateSlip() { displayEmployeeDetails(); SalaryBreakup breakup = new SalaryBreakup(); breakup.computeBreakup(); breakup.printBreakup(); }

The methods print identity or create a new SalaryBreakup, compute its values and return net pay or print the slip. Each helper is attached to the Employee instance whose method created it.

        class SalaryBreakup {
            double hra, da, pf, tax, netPay;
            void computeBreakup() {
                hra=baseSalary*0.20; da=baseSalary*0.10; pf=baseSalary*0.12; tax=baseSalary*0.05;
                netPay=baseSalary+hra+da-pf-tax;
            }

SalaryBreakup can read its enclosing Employee’s baseSalary without receiving a separate employee argument. It computes HRA 20%, DA 10%, PF 12% and tax 5%, then adds allowances and subtracts deductions.

            void printBreakup() { money("Base",baseSalary); money("HRA",hra); money("DA",da); money("PF",pf); money("Tax",tax); money("Net pay",netPay); }
        }
    }

printBreakup formats each component and net pay. The following braces close SalaryBreakup and Employee. These rates are illustrative values in this exercise, not statutory payroll rules.

    // id/name/base-salary/department. Rates are illustrative, not statutory rules.
    public static void main(String[] args) {
        try {
            Employee employee = new Employee(integer(1,1000000),text(),number(0,1000000),text());
            System.out.println("Default employee:"); new Employee().generateSlip();
            System.out.println("Salary slip:"); employee.generateSlip(); money("calculateSalary()",employee.calculateSalary());

main reads the real employee fields, prints a default employee’s slip, then the supplied employee’s slip and calculateSalary result. Separate breakup objects use the same outer base salary and therefore give consistent calculations.

        } catch (IllegalArgumentException e) { System.out.println("Invalid input: " + e.getMessage()); }
    }
}

The catch handles IllegalArgumentException, including invalid numeric strings from the helpers, and prints its message. The final braces close main and Main. Java objects become eligible for garbage collection when no live reference needs them; this program does not manually free them.