Payroll with overridden salary calculations

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 abstract class Employee {
        final int id, daysPresent; final String name; final double baseSalary;
        Employee(int id,String name,double baseSalary,int days) { this.id=id; this.name=name; this.baseSalary=baseSalary; daysPresent=days; }
        abstract double calculateSalary();

Employee stores identity, monthly base and days present. Its constructor initialises those fields, and abstract calculateSalary requires each concrete subtype to supply a salary calculation. The abstract class itself is not directly instantiated.

        void displayPaySlip() { System.out.println(getClass().getSimpleName()+" | "+id+" | "+name+" | days "+daysPresent); money("Net salary",calculateSalary()); }
        double prorate(double monthly) { return monthly*daysPresent/30.0; }
    }

displayPaySlip calls calculateSalary on the actual receiver, enabling runtime dispatch. prorate scales a monthly amount by daysPresent/30.0; the decimal divisor avoids integer division.

    static class Manager extends Employee {
        final double bonus;
        Manager(int id,String name,double base,int days,double bonus) { super(id,name,base,days); this.bonus=bonus; }
        @Override double calculateSalary() { return prorate(baseSalary+bonus); }
    }

The constructor calls super to initialise inherited fields, then stores bonus. The override prorates base plus bonus. @Override asks the compiler to check that the method really overrides a parent declaration.

    static class Developer extends Employee {
        final double projectAllowance;
        Developer(int id,String name,double base,int days,double allowance) { super(id,name,base,days); projectAllowance=allowance; }
        @Override double calculateSalary() { return prorate(baseSalary+projectAllowance); }
    }

Store projectAllowance after the parent constructor call. This override prorates base plus that allowance rather than the manager’s bonus.

    static class Intern extends Employee {
        final double stipend;
        Intern(int id,String name,int days,double stipend) { super(id,name,0,days); this.stipend=stipend; }
        @Override double calculateSalary() { return prorate(stipend); }
    }

An intern supplies zero base to the parent and stores a stipend. Its override prorates only the stipend. All three subtypes honour the same calculateSalary method contract.

    // Days present for manager, developer, intern (0–30), one per line.
    public static void main(String[] args) {
        try {
            Employee[] team={new Manager(1,"Asha",50000,integer(0,30),10000),new Developer(2,"Ravi",40000,integer(0,30),5000),new Intern(3,"Priya",integer(0,30),10000)};
            for (Employee employee:team) employee.displayPaySlip();

Read 0–30 days for each fixed example employee. The array type is Employee[], but its elements have different concrete classes. Each displayPaySlip call dispatches to that object’s own salary implementation.

        } 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.