Polymorphism in Java Explained — Runtime vs Compile-Time with Real Examples

public class InvoiceFormatter {

    // Overload 1: caller has a whole-number amount (e.g. loyalty points)
    public String formatPrice(int amountInCents) {
        double dollars = amountInCents / 100.0;
        // Format the integer input as a dollar string
        return String.format("$%.2f", dollars);
    }

    // Overload 2: caller already has a decimal amount
    public String formatPrice(double amount) {
        // Directly format the double — no conversion needed
        return String.format("$%.2f", amount);
    }

    // Overload 3: caller also wants a currency code (e.g. for international invoices)
    public String formatPrice(double amount, String currencyCode) {
        // The compiler picks THIS version when two arguments are passed
        return String.format("%s %.2f", currencyCode, amount);
    }

    public static void main(String[] args) {
        InvoiceFormatter formatter = new InvoiceFormatter();

        // Compiler resolves each call at compile time based on argument types
        System.out.println(formatter.formatPrice(1999));           // int version
        System.out.println(formatter.formatPrice(19.99));          // double version
        System.out.println(formatter.formatPrice(19.99, "EUR"));   // double + String version
    }
}

// Abstract base class — defines the contract every payment method must fulfil
abstract class PaymentMethod {
    protected String accountId;

    public PaymentMethod(String accountId) {
        this.accountId = accountId;
    }

    // Every subclass MUST provide its own version of this method
    public abstract String processPayment(double amount);

    // This method is shared — subclasses inherit it unchanged
    public String getAccountSummary() {
        return "Account: " + accountId;
    }
}

// Concrete subclass 1
class CreditCard extends PaymentMethod {
    private String lastFourDigits;

    public CreditCard(String accountId, String lastFourDigits) {
        super(accountId);
        this.lastFourDigits = lastFourDigits;
    }

    @Override
    public String processPayment(double amount) {
        // This version charges a card and adds a processing fee
        double fee = amount * 0.015;
        return String.format("Credit card ****%s charged $%.2f (fee: $%.2f)",
                lastFourDigits, amount, fee);
    }
}

// Concrete subclass 2
class PayPalAccount extends PaymentMethod {

    public PayPalAccount(String email) {
        super(email);
    }

    @Override
    public String processPayment(double amount) {
        // PayPal has a flat fee model — completely different logic, same method name
        return String.format("PayPal account %s debited $%.2f (flat fee: $0.30)",
                accountId, amount);
    }
}

// Concrete subclass 3 — added later, zero changes to PaymentProcessor needed
class CryptoPay extends PaymentMethod {

    public CryptoPay(String walletAddress) {
        super(walletAddress);
    }

    @Override
    public String processPayment(double amount) {
        // Crypto converts to BTC at a fake rate for illustration
        double btcAmount = amount / 45000.0;
        return String.format("Wallet %s sent %.6f BTC ($%.2f)",
                accountId, btcAmount, amount);
    }
}

public class PaymentProcessor {

    // This method was written ONCE. It works for every PaymentMethod — past and future.
    // The JVM uses dynamic dispatch to call the right processPayment() at runtime.
    public static void checkout(PaymentMethod method, double orderTotal) {
        System.out.println(method.processPayment(orderTotal)); // runtime decision
        System.out.println(method.getAccountSummary());        // shared inherited method
        System.out.println("---");
    }

    public static void main(String[] args) {
        // Reference type is PaymentMethod; actual object type varies — that's the point
        PaymentMethod card   = new CreditCard("ACC-001", "4242");
        PaymentMethod paypal = new PayPalAccount("user@example.com");
        PaymentMethod crypto = new CryptoPay("0xABCD1234");

        // Same method call, three completely different behaviours — runtime polymorphism
        checkout(card,   99.99);
        checkout(paypal, 99.99);
        checkout(crypto, 99.99);
    }
}

// Interface defines a CAPABILITY — any class can implement this regardless of its lineage
interface Exportable {
    // Every implementor must know how to export itself
    byte[] exportData();

    // Default method: shared behaviour that implementors can optionally override
    default String getExportStatus() {
        return "Export ready: " + this.getClass().getSimpleName();
    }
}

// A completely unrelated second interface — Java allows implementing both
interface Auditable {
    String getAuditLog();
}

// SalesReport implements BOTH interfaces — impossible with single-inheritance abstract classes
class SalesReport implements Exportable, Auditable {
    private String reportName;
    private double totalRevenue;

    public SalesReport(String reportName, double totalRevenue) {
        this.reportName = reportName;
        this.totalRevenue = totalRevenue;
    }

    @Override
    public byte[] exportData() {
        // Simulate generating CSV bytes from the report data
        String csv = "Report,Revenue\n" + reportName + "," + totalRevenue;
        return csv.getBytes();
    }

    @Override
    public String getAuditLog() {
        return "SalesReport '" + reportName + "' exported at " + System.currentTimeMillis();
    }
}

class InventorySnapshot implements Exportable {
    private int itemCount;

    public InventorySnapshot(int itemCount) {
        this.itemCount = itemCount;
    }

    @Override
    public byte[] exportData() {
        // Simulate generating JSON bytes
        String json = "{\"itemCount\": " + itemCount + "}";
        return json.getBytes();
    }

    // Not overriding getExportStatus() — the default implementation is used instead
}

public class ReportExporter {

    // This method only cares that the object is Exportable — it doesn't know or care what type
    public static void runExport(Exportable exportable) {
        byte[] data = exportable.exportData();              // runtime polymorphism here
        System.out.println(exportable.getExportStatus());  // default or overridden version
        System.out.println("Bytes exported: " + data.length);
        System.out.println("---");
    }

    public static void main(String[] args) {
        SalesReport salesReport       = new SalesReport("Q4-2024", 128500.00);
        InventorySnapshot snapshot    = new InventorySnapshot(342);

        runExport(salesReport);   // Uses SalesReport's exportData()
        runExport(snapshot);      // Uses InventorySnapshot's exportData()

        // SalesReport also satisfies Auditable — dual polymorphic identity
        Auditable auditTarget = salesReport;
        System.out.println(auditTarget.getAuditLog());
    }
}

// Base factory class with a general return type
class VehicleFactory {

    // Returns the broad type Vehicle
    public Vehicle createVehicle(String model) {
        return new Vehicle(model, "generic");
    }
}

// Subclass uses a COVARIANT return type — returns ElectricCar instead of Vehicle
class ElectricCarFactory extends VehicleFactory {

    @Override // Compiler will error here if createVehicle doesn't exist in parent — safety net
    public ElectricCar createVehicle(String model) {
        // Covariant: ElectricCar IS-A Vehicle, so this is a valid override
        return new ElectricCar(model, "electric", 350);
    }
}

class Vehicle {
    protected String model;
    protected String fuelType;

    public Vehicle(String model, String fuelType) {
        this.model    = model;
        this.fuelType = fuelType;
    }

    public String describe() {
        return model + " (" + fuelType + ")";
    }
}

class ElectricCar extends Vehicle {
    private int rangeKm;

    public ElectricCar(String model, String fuelType, int rangeKm) {
        super(model, fuelType);
        this.rangeKm = rangeKm;
    }

    @Override
    public String describe() {
        // Overridden to include range — runtime polymorphism fires here
        return super.describe() + ", range: " + rangeKm + "km";
    }
}

public class VehicleFactoryDemo {
    public static void main(String[] args) {
        VehicleFactory genericFactory  = new VehicleFactory();
        ElectricCarFactory evFactory   = new ElectricCarFactory();

        // Covariant return: no cast needed when using the concrete factory type
        ElectricCar tesla = evFactory.createVehicle("Model S");
        System.out.println(tesla.describe());        // ElectricCar's describe() runs
        System.out.println("Range: " + tesla.rangeKm + "km");  // can access rangeKm directly

        // Polymorphism via parent reference: describe() still calls ElectricCar's version
        VehicleFactory upcastFactory = evFactory;    // reference is VehicleFactory type
        Vehicle vehicle = upcastFactory.createVehicle("Model 3"); // returns ElectricCar object
        System.out.println(vehicle.describe());      // runtime dispatch — ElectricCar.describe()
    }
}