Employee Payroll System

Calculate salaries for different employee types using interfaces and abstract classes.

InterfacesAbstractionArrays

Overview

Every company pays different kinds of employees in fundamentally different ways — a salaried employee earns the same amount every period, an hourly employee earns based on hours worked, and a commission-based employee earns a percentage of what they sell. What all three genuinely share is not a formula, only a promise: every one of them is "payable," meaning you can always ask it for a salary. Java's `interface` is built to express exactly that kind of promise, separately from any shared implementation.

By the end of this tutorial you will have a console payroll application built around a `Payable` interface, an `abstract` `Employee` class that implements it without fully satisfying it, and three concrete subclasses that each override `calculateSalary()` with their own formula. Every employee, regardless of type, is stored in a single fixed-size `Employee[]` array, and running payroll is one loop that calls `calculateSalary()` on each element — the array never needs to know or care which concrete class any given element actually is.

What You'll Build

A `Payable` interface declaring a single `calculateSalary()` method.
An abstract `Employee` class implementing `Payable` without providing a body for `calculateSalary()`.
A `SalariedEmployee` subclass paying a fixed monthly amount.
An `HourlyEmployee` subclass paying `hoursWorked * hourlyRate`, with overtime past 160 hours.
A `CommissionEmployee` subclass paying a base plus a percentage of sales.
A `Payroll` class managing a fixed-size `Employee[]` array and printing a full payroll report polymorphically.

Prerequisites

Interfaces — declaring a `interface` with an abstract method and `implements`-ing it in a class.
Abstraction — the difference between an `interface` (a pure contract) and an `abstract class` (a partial implementation).
Inheritance and polymorphism — `extends`, `@Override`, and calling an overridden method through a base reference.
Arrays — declaring a fixed-size `Employee[]`, storing elements by index, and iterating with a `for` loop.
Method basics — return types, parameters, and calling one method from another.

Project Structure

The program lives in a single file, `EmployeePayrollSystem.java`. `Payable` is a pure interface: it has no fields and no method bodies, only the signature `double calculateSalary();`, which is implicitly `public abstract`. `Employee` is declared `abstract class Employee implements Payable` — it satisfies the "is a class that can be paid" promise structurally by implementing `Payable`, but it deliberately does not provide a body for `calculateSalary()` itself, re-declaring it as `abstract`. Java allows this specific combination: an abstract class is allowed to leave an interface method unimplemented, as long as the class itself is marked `abstract`, pushing the actual obligation down to whichever concrete subclass extends it.

`Payroll` owns a fixed-size `Employee[]` array rather than a growable `ArrayList<Employee>` — the array size is decided once in the constructor, and `addEmployee()` fills the next open slot, which is a deliberate, simpler alternative chosen here specifically to practice array mechanics (tracking a `count` of filled slots, checking for a full array) that a `List` would otherwise hide from you.

Step 1: Define the Payable Interface

An interface method has no body and, as of any modern Java version, no visibility modifier is needed on it — every method declared in an interface is `public abstract` by default unless marked `default` or `static`. `Payable` says nothing about how a salary is computed, only that any class implementing it must be able to answer the question.

// A pure contract: any class that "implements Payable" is promising it can
// compute a salary, without saying anything about how. No fields, no bodies.
interface Payable {
    double calculateSalary();   // Implicitly public and abstract; every implementer must define this
}

Step 2: Define an Abstract Employee Base Class

Every employee — regardless of pay structure — has an id and a name, so those live in `Employee` as `protected` fields that subclasses can read directly. `Employee implements Payable` but re-declares `calculateSalary()` as `abstract` rather than providing a formula, which is legal specifically because `Employee` itself is marked `abstract class` — the compiler defers the "you must implement this" obligation to whichever concrete subclass extends `Employee`.

abstract class Employee implements Payable {
    protected int id;       // protected, not private, so subclasses can read it directly
    protected String name;  // Employee's display name

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    // No calculateSalary() body here: Employee satisfies "implements Payable" structurally,
    // but leaves the real obligation to SalariedEmployee, HourlyEmployee, and CommissionEmployee.

    public void printPayslip() {
        System.out.printf("ID: %-4d | Name: %-18s | Type: %-12s | Salary: %.2f%n",
            id, name, getEmployeeType(), calculateSalary());   // Both calls dispatch to the real subclass at runtime
    }

    public abstract String getEmployeeType();   // A second abstract method, so payslips can label each employee's type
}

`printPayslip()` is itself never overridden by any subclass — it does not need to be. It already produces correct, type-specific output for any employee by calling the abstract `calculateSalary()` and `getEmployeeType()` internally, the same "small abstract methods power one larger shared method" pattern used by `Member.displayInfo()` in the Library Management System project.

Step 3: Derive SalariedEmployee and HourlyEmployee

`SalariedEmployee` is the simplest possible implementation: `calculateSalary()` just returns a fixed field. `HourlyEmployee` is more interesting — it multiplies `hoursWorked` by `hourlyRate` for the first 160 hours, then applies a 1.5x overtime multiplier to anything beyond that, all inside its own `calculateSalary()` override, completely invisible to any code that only knows it is holding an `Employee`.

class SalariedEmployee extends Employee {
    private double monthlySalary;   // Fixed amount paid every period, regardless of hours

    public SalariedEmployee(int id, String name, double monthlySalary) {
        super(id, name);              // Forwards id and name to Employee's constructor
        this.monthlySalary = monthlySalary;
    }

    @Override
    public double calculateSalary() {
        return monthlySalary;         // No formula needed: salaried pay doesn't depend on hours or sales
    }

    @Override
    public String getEmployeeType() {
        return "Salaried";
    }
}

class HourlyEmployee extends Employee {
    private double hoursWorked;   // Hours worked this pay period
    private double hourlyRate;    // Base pay per hour

    public HourlyEmployee(int id, String name, double hoursWorked, double hourlyRate) {
        super(id, name);
        this.hoursWorked = hoursWorked;
        this.hourlyRate = hourlyRate;
    }

    @Override
    public double calculateSalary() {
        double regularHours = Math.min(hoursWorked, 160);       // Cap regular-rate hours at 160 per period
        double overtimeHours = Math.max(0, hoursWorked - 160);  // Anything past 160 counts as overtime
        return (regularHours * hourlyRate) + (overtimeHours * hourlyRate * 1.5);   // Overtime pays 1.5x
    }

    @Override
    public String getEmployeeType() {
        return "Hourly";
    }
}

Example Usage

Click Run to see what this code prints.

Step 4: Derive a CommissionEmployee

A third subclass drives home that `calculateSalary()` can be computed however each type needs — `CommissionEmployee` combines a flat base pay with a percentage of sales, a formula that shares nothing structurally with either `SalariedEmployee` or `HourlyEmployee`, yet all three are equally valid `Employee` objects to any code that only calls the methods `Employee` and `Payable` promise.

class CommissionEmployee extends Employee {
    private double baseSalary;       // Guaranteed pay regardless of sales performance
    private double salesAmount;      // Total sales generated this period
    private double commissionRate;   // Fraction of sales paid as commission, e.g. 0.05 for 5%

    public CommissionEmployee(int id, String name, double baseSalary, double salesAmount, double commissionRate) {
        super(id, name);
        this.baseSalary = baseSalary;
        this.salesAmount = salesAmount;
        this.commissionRate = commissionRate;
    }

    @Override
    public double calculateSalary() {
        return baseSalary + (salesAmount * commissionRate);   // Base pay plus a cut of whatever they sold
    }

    @Override
    public String getEmployeeType() {
        return "Commission";
    }
}

Step 5: Build the Payroll Class Around an Employee Array

`Payroll` allocates a fixed-size `Employee[]` in its constructor and tracks how many slots are actually filled with a `count` field, since a Java array (unlike an `ArrayList`) has no built-in notion of "how many elements are really in use" versus "how large the array is." `addEmployee()` checks `count` against the array's `.length` before writing, since writing past a full array would throw an `ArrayIndexOutOfBoundsException`.

class Payroll {
    private Employee[] employees;   // Fixed-size array; every element is an Employee reference, concrete type varies
    private int count = 0;            // How many slots are actually filled, since employees.length never shrinks or grows

    public Payroll(int capacity) {
        employees = new Employee[capacity];   // Allocates capacity slots, all initially null
    }

    public boolean addEmployee(Employee e) {
        if (count >= employees.length) {   // Guard against writing past the array's fixed size
            System.out.println("Payroll is full; cannot add more employees.");
            return false;
        }
        employees[count] = e;   // Store at the next open slot
        count++;
        return true;
    }

    public void runPayroll() {
        System.out.println("\n--- Payroll Report ---");
        double total = 0;
        for (int i = 0; i < count; i++) {          // Only iterate over filled slots, not the whole array
            employees[i].printPayslip();             // Polymorphic: dispatches to each employee's real calculateSalary()
            total += employees[i].calculateSalary();
        }
        System.out.printf("Total payroll this period: %.2f%n", total);
    }

    public Employee findById(int id) {
        for (int i = 0; i < count; i++) {
            if (employees[i].getId() == id) {
                return employees[i];
            }
        }
        return null;
    }
}

Step 6: Build the Menu Loop

`main()` creates a `Payroll` with a fixed capacity and loops over a menu that lets the user add any of the three employee types or run the full payroll report. Adding an employee is the one place the user's choice directly decides which concrete class gets constructed, while `runPayroll()` afterward treats every element of the array uniformly through its `Employee` type.

import java.util.Scanner;

public class EmployeePayrollSystem {
    public static void main(String[] args) {
        Payroll payroll = new Payroll(50);   // Fixed capacity of 50 employees for this run
        Scanner scanner = new Scanner(System.in);
        int nextId = 1;
        int choice;

        do {
            System.out.println("\n===== EMPLOYEE PAYROLL SYSTEM =====");
            System.out.println("1. Add Salaried Employee");
            System.out.println("2. Add Hourly Employee");
            System.out.println("3. Add Commission Employee");
            System.out.println("4. Run Payroll Report");
            System.out.println("5. Find Employee by ID");
            System.out.println("6. Exit");
            System.out.print("Enter your choice: ");
            choice = scanner.nextInt();
            scanner.nextLine();   // Discard the leftover newline left behind by nextInt()

            if (choice == 1) {
                System.out.print("Enter name: ");
                String name = scanner.nextLine();
                System.out.print("Enter monthly salary: ");
                double monthlySalary = scanner.nextDouble();
                scanner.nextLine();
                payroll.addEmployee(new SalariedEmployee(nextId, name, monthlySalary));
                nextId++;
                System.out.println("Salaried employee added.");
            } else if (choice == 2) {
                System.out.print("Enter name: ");
                String name = scanner.nextLine();
                System.out.print("Enter hours worked: ");
                double hours = scanner.nextDouble();
                System.out.print("Enter hourly rate: ");
                double rate = scanner.nextDouble();
                scanner.nextLine();
                payroll.addEmployee(new HourlyEmployee(nextId, name, hours, rate));
                nextId++;
                System.out.println("Hourly employee added.");
            } else if (choice == 3) {
                System.out.print("Enter name: ");
                String name = scanner.nextLine();
                System.out.print("Enter base salary: ");
                double base = scanner.nextDouble();
                System.out.print("Enter sales amount: ");
                double sales = scanner.nextDouble();
                System.out.print("Enter commission rate (e.g. 0.05 for 5%): ");
                double rate = scanner.nextDouble();
                scanner.nextLine();
                payroll.addEmployee(new CommissionEmployee(nextId, name, base, sales, rate));
                nextId++;
                System.out.println("Commission employee added.");
            } else if (choice == 4) {
                payroll.runPayroll();
            } else if (choice == 5) {
                System.out.print("Enter ID to find: ");
                int id = scanner.nextInt();
                scanner.nextLine();
                Employee found = payroll.findById(id);
                if (found == null) {
                    System.out.println("No employee with that ID.");
                } else {
                    found.printPayslip();
                }
            } else if (choice == 6) {
                System.out.println("Goodbye!");
            } else {
                System.out.println("Invalid choice, try again.");   // Catches anything outside 1-6
            }
        } while (choice != 6);   // Keep looping until the user explicitly picks Exit

        scanner.close();
    }
}

Complete Code

Here is the full program with every type assembled in the correct order, ready to save as `EmployeePayrollSystem.java` and run with `javac EmployeePayrollSystem.java && java EmployeePayrollSystem`.

import java.util.Scanner;

interface Payable {
    double calculateSalary();
}

abstract class Employee implements Payable {
    protected int id;
    protected String name;

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void printPayslip() {
        System.out.printf("ID: %-4d | Name: %-18s | Type: %-12s | Salary: %.2f%n",
            id, name, getEmployeeType(), calculateSalary());
    }

    public abstract String getEmployeeType();
}

class SalariedEmployee extends Employee {
    private double monthlySalary;

    public SalariedEmployee(int id, String name, double monthlySalary) {
        super(id, name);
        this.monthlySalary = monthlySalary;
    }

    @Override
    public double calculateSalary() {
        return monthlySalary;
    }

    @Override
    public String getEmployeeType() {
        return "Salaried";
    }
}

class HourlyEmployee extends Employee {
    private double hoursWorked;
    private double hourlyRate;

    public HourlyEmployee(int id, String name, double hoursWorked, double hourlyRate) {
        super(id, name);
        this.hoursWorked = hoursWorked;
        this.hourlyRate = hourlyRate;
    }

    @Override
    public double calculateSalary() {
        double regularHours = Math.min(hoursWorked, 160);
        double overtimeHours = Math.max(0, hoursWorked - 160);
        return (regularHours * hourlyRate) + (overtimeHours * hourlyRate * 1.5);
    }

    @Override
    public String getEmployeeType() {
        return "Hourly";
    }
}

class CommissionEmployee extends Employee {
    private double baseSalary;
    private double salesAmount;
    private double commissionRate;

    public CommissionEmployee(int id, String name, double baseSalary, double salesAmount, double commissionRate) {
        super(id, name);
        this.baseSalary = baseSalary;
        this.salesAmount = salesAmount;
        this.commissionRate = commissionRate;
    }

    @Override
    public double calculateSalary() {
        return baseSalary + (salesAmount * commissionRate);
    }

    @Override
    public String getEmployeeType() {
        return "Commission";
    }
}

class Payroll {
    private Employee[] employees;
    private int count = 0;

    public Payroll(int capacity) {
        employees = new Employee[capacity];
    }

    public boolean addEmployee(Employee e) {
        if (count >= employees.length) {
            System.out.println("Payroll is full; cannot add more employees.");
            return false;
        }
        employees[count] = e;
        count++;
        return true;
    }

    public void runPayroll() {
        System.out.println("\n--- Payroll Report ---");
        double total = 0;
        for (int i = 0; i < count; i++) {
            employees[i].printPayslip();
            total += employees[i].calculateSalary();
        }
        System.out.printf("Total payroll this period: %.2f%n", total);
    }

    public Employee findById(int id) {
        for (int i = 0; i < count; i++) {
            if (employees[i].getId() == id) {
                return employees[i];
            }
        }
        return null;
    }
}

public class EmployeePayrollSystem {
    public static void main(String[] args) {
        Payroll payroll = new Payroll(50);
        Scanner scanner = new Scanner(System.in);
        int nextId = 1;
        int choice;

        do {
            System.out.println("\n===== EMPLOYEE PAYROLL SYSTEM =====");
            System.out.println("1. Add Salaried Employee");
            System.out.println("2. Add Hourly Employee");
            System.out.println("3. Add Commission Employee");
            System.out.println("4. Run Payroll Report");
            System.out.println("5. Find Employee by ID");
            System.out.println("6. Exit");
            System.out.print("Enter your choice: ");
            choice = scanner.nextInt();
            scanner.nextLine();

            if (choice == 1) {
                System.out.print("Enter name: ");
                String name = scanner.nextLine();
                System.out.print("Enter monthly salary: ");
                double monthlySalary = scanner.nextDouble();
                scanner.nextLine();
                payroll.addEmployee(new SalariedEmployee(nextId, name, monthlySalary));
                nextId++;
                System.out.println("Salaried employee added.");
            } else if (choice == 2) {
                System.out.print("Enter name: ");
                String name = scanner.nextLine();
                System.out.print("Enter hours worked: ");
                double hours = scanner.nextDouble();
                System.out.print("Enter hourly rate: ");
                double rate = scanner.nextDouble();
                scanner.nextLine();
                payroll.addEmployee(new HourlyEmployee(nextId, name, hours, rate));
                nextId++;
                System.out.println("Hourly employee added.");
            } else if (choice == 3) {
                System.out.print("Enter name: ");
                String name = scanner.nextLine();
                System.out.print("Enter base salary: ");
                double base = scanner.nextDouble();
                System.out.print("Enter sales amount: ");
                double sales = scanner.nextDouble();
                System.out.print("Enter commission rate (e.g. 0.05 for 5%): ");
                double rate = scanner.nextDouble();
                scanner.nextLine();
                payroll.addEmployee(new CommissionEmployee(nextId, name, base, sales, rate));
                nextId++;
                System.out.println("Commission employee added.");
            } else if (choice == 4) {
                payroll.runPayroll();
            } else if (choice == 5) {
                System.out.print("Enter ID to find: ");
                int id = scanner.nextInt();
                scanner.nextLine();
                Employee found = payroll.findById(id);
                if (found == null) {
                    System.out.println("No employee with that ID.");
                } else {
                    found.printPayslip();
                }
            } else if (choice == 6) {
                System.out.println("Goodbye!");
            } else {
                System.out.println("Invalid choice, try again.");
            }
        } while (choice != 6);

        scanner.close();
    }
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Add a second interface, `Bonusable`, with a `double calculateBonus()` method, and implement it only on the employee types that should receive a year-end bonus.
Replace the fixed-size `Employee[]` with a `List<Employee>` and compare the two approaches directly — note how `addEmployee()` no longer needs a capacity check.
Add a `TaxCalculator` utility class with a static method that applies a progressive tax rate to `calculateSalary()`'s result before printing.
Sort the payroll report by salary using `Arrays.sort(employees, 0, count, Comparator.comparingDouble(Employee::calculateSalary))`.
Persist each payroll run to a CSV file with `java.io.FileWriter`, one line per employee, so historical payroll reports can be reviewed later.

Summary

You built a payroll system where three genuinely different salary formulas coexist behind one shared `Payable` promise and one `abstract Employee` class, stored together in a single fixed-size `Employee[]` array and processed by one polymorphic loop in `runPayroll()`. The interface-plus-abstract-class combination you used here — a contract with no implementation at all, and a partial implementation that still leaves the core method abstract — is a pattern you will see constantly in larger Java codebases, anywhere a family of types needs to share some behavior while still guaranteeing every member can answer one specific question in its own way.