Java OOP Interview Questions: Polymorphism, Abstraction & More

public class BankAccountEncapsulation {

    // --- Encapsulation Demo ---
    // The balance field is private — no outside code can set it directly.
    // This means we can enforce rules (e.g. no negative balances) in ONE place.
    static class BankAccount {
        private double balance;        // hidden internal state
        private String accountHolder;  // also hidden

        public BankAccount(String accountHolder, double openingBalance) {
            this.accountHolder = accountHolder;
            // Using our own setter so the validation rule applies at construction too
            setBalance(openingBalance);
        }

        // Public getter — read-only access from outside
        public double getBalance() {
            return balance;
        }

        // Public method to deposit — enforces business logic
        public void deposit(double amount) {
            if (amount <= 0) {
                throw new IllegalArgumentException("Deposit amount must be positive.");
            }
            balance += amount; // safe: we control every modification
        }

        // Public method to withdraw — enforces business logic
        public void withdraw(double amount) {
            if (amount > balance) {
                throw new IllegalStateException("Insufficient funds.");
            }
            balance -= amount;
        }

        // Private setter — only used internally so we keep validation centralised
        private void setBalance(double balance) {
            if (balance < 0) {
                throw new IllegalArgumentException("Opening balance cannot be negative.");
            }
            this.balance = balance;
        }

        @Override
        public String toString() {
            return accountHolder + "'s balance: $" + balance;
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount("Alice", 500.00);
        System.out.println(account);            // initial state

        account.deposit(200.00);
        System.out.println(account);            // after deposit

        account.withdraw(100.00);
        System.out.println(account);            // after withdrawal

        // This next line would throw IllegalStateException — try it!
        // account.withdraw(1000.00);

        // Without encapsulation, any code could do: account.balance = -999;
        // With encapsulation, that line won't even compile.
    }
}

import java.util.List;
import java.util.ArrayList;

public class NotificationPolymorphism {

    // ABSTRACTION: This interface declares WHAT a notifier must do.
    // It says nothing about HOW — that's left to implementations.
    interface Notifier {
        void sendAlert(String message);
        
        // Default method: shared behaviour without forcing subclasses to override
        default String formatMessage(String raw) {
            return "[ALERT] " + raw.toUpperCase();
        }
    }

    // POLYMORPHISM: Each class defines its own version of sendAlert.
    // The caller never needs to know which one it's talking to.
    static class EmailNotifier implements Notifier {
        private String recipientEmail;

        EmailNotifier(String recipientEmail) {
            this.recipientEmail = recipientEmail;
        }

        @Override
        public void sendAlert(String message) {
            // In production this would call an email API
            System.out.println("EMAIL to " + recipientEmail + ": " + formatMessage(message));
        }
    }

    static class SmsNotifier implements Notifier {
        private String phoneNumber;

        SmsNotifier(String phoneNumber) {
            this.phoneNumber = phoneNumber;
        }

        @Override
        public void sendAlert(String message) {
            // In production this would call an SMS gateway
            System.out.println("SMS to " + phoneNumber + ": " + formatMessage(message));
        }
    }

    static class SlackNotifier implements Notifier {
        private String channel;

        SlackNotifier(String channel) {
            this.channel = channel;
        }

        @Override
        public void sendAlert(String message) {
            System.out.println("SLACK #" + channel + ": " + formatMessage(message));
        }
    }

    // KEY POINT: This method takes a List<Notifier> — it doesn't care about
    // the concrete type. Add a new PushNotifier tomorrow and this code needs
    // zero changes. That's polymorphism making your code Open/Closed.
    static void broadcastAlert(List<Notifier> notifiers, String message) {
        for (Notifier notifier : notifiers) {
            notifier.sendAlert(message); // JVM picks the right implementation at runtime
        }
    }

    public static void main(String[] args) {
        List<Notifier> alertChannels = new ArrayList<>();
        alertChannels.add(new EmailNotifier("ops@company.com"));
        alertChannels.add(new SmsNotifier("+1-555-0199"));
        alertChannels.add(new SlackNotifier("incidents"));

        broadcastAlert(alertChannels, "server CPU at 98%");
    }
}

public class VehicleHierarchy {

    // ABSTRACT CLASS: appropriate here because:
    // 1. All vehicles genuinely 'are' vehicles (is-a relationship)
    // 2. They share real instance state (fuelLevel, make)
    // 3. They share some concrete behaviour (refuel)
    static abstract class Vehicle {
        protected String make;         // shared state — inherited by all subclasses
        protected double fuelLevel;    // shared state

        Vehicle(String make, double initialFuel) {
            this.make = make;
            this.fuelLevel = initialFuel;
        }

        // Concrete method — defined once, works for every vehicle
        public void refuel(double litres) {
            fuelLevel += litres;
            System.out.println(make + " refuelled. Fuel level: " + fuelLevel + "L");
        }

        // Abstract method — subclasses MUST provide their own implementation
        public abstract void accelerate();

        // Abstract method — different vehicles report differently
        public abstract String getType();
    }

    // INTERFACE: appropriate for capabilities that cross class hierarchies
    // A Car and a Drone can both be GPS-tracked — they don't share a parent
    interface GpsTrackable {
        String getCurrentLocation();  // every implementor must define this

        // Default method — shared utility behaviour added in Java 8
        default void printLocation() {
            System.out.println("Current position: " + getCurrentLocation());
        }
    }

    // Car extends Vehicle (is-a) AND implements GpsTrackable (has-a capability)
    // Java allows one parent class + multiple interfaces — best of both worlds
    static class Car extends Vehicle implements GpsTrackable {
        private int horsepower;
        private double latitude;
        private double longitude;

        Car(String make, double fuel, int horsepower) {
            super(make, fuel);         // call parent constructor to set shared state
            this.horsepower = horsepower;
            this.latitude = 51.5074;   // London by default for demo
            this.longitude = -0.1278;
        }

        @Override
        public void accelerate() {
            // Car-specific implementation — burns fuel faster with more HP
            fuelLevel -= (horsepower * 0.01);
            System.out.println(make + " car accelerates. Fuel remaining: " + fuelLevel + "L");
        }

        @Override
        public String getType() {
            return "Petrol Car";
        }

        @Override
        public String getCurrentLocation() {
            return latitude + ", " + longitude;  // would call GPS API in production
        }
    }

    static class ElectricBike extends Vehicle {
        private int batteryPercent;

        ElectricBike(String make, double fuel, int battery) {
            super(make, fuel);
            this.batteryPercent = battery;
        }

        @Override
        public void accelerate() {
            batteryPercent -= 2;  // electric: drains battery, not fuel
            System.out.println(make + " e-bike accelerates. Battery: " + batteryPercent + "%");
        }

        @Override
        public String getType() {
            return "Electric Bike";
        }
    }

    public static void main(String[] args) {
        Car tesla = new Car("Tesla", 100.0, 300);
        ElectricBike specialised = new ElectricBike("Specialised", 0, 100);

        // Polymorphism: same method call, different behaviour
        Vehicle[] garage = { tesla, specialised };
        for (Vehicle v : garage) {
            System.out.println("--- " + v.getType() + " ---");
            v.accelerate();
        }

        System.out.println();

        // GpsTrackable: only Tesla implements it — checked at compile time
        tesla.printLocation();   // uses default interface method

        // Refuel is concrete in parent — works without override
        tesla.refuel(20.0);
    }
}

public class LiskovSubstitution {

    // GOOD INHERITANCE: Penguin violating LSP — let's see what goes wrong first,
    // then we'll fix it with the correct design.

    // Scenario: A payroll system processes different employee types.
    // Base class represents any person on payroll.
    static abstract class PayrollEmployee {
        protected String name;
        protected double baseSalary;

        PayrollEmployee(String name, double baseSalary) {
            this.name = name;
            this.baseSalary = baseSalary;
        }

        // Every employee gets paid — the amount may vary by type
        public abstract double calculateMonthlyPay();

        public String getName() { return name; }
    }

    // FullTimeEmployee: gets exactly their monthly salary
    static class FullTimeEmployee extends PayrollEmployee {
        FullTimeEmployee(String name, double annualSalary) {
            super(name, annualSalary / 12); // store as monthly
        }

        @Override
        public double calculateMonthlyPay() {
            return baseSalary;  // straightforward
        }
    }

    // Contractor: paid by hours worked each month
    static class Contractor extends PayrollEmployee {
        private double hourlyRate;
        private int hoursWorkedThisMonth;

        Contractor(String name, double hourlyRate, int hoursWorked) {
            super(name, 0); // contractors don't have a base salary
            this.hourlyRate = hourlyRate;
            this.hoursWorkedThisMonth = hoursWorked;
        }

        @Override
        public double calculateMonthlyPay() {
            return hourlyRate * hoursWorkedThisMonth;
        }
    }

    // BonusEligibleEmployee: full-timer who also gets a performance bonus
    static class BonusEligibleEmployee extends FullTimeEmployee {
        private double bonusMultiplier;  // e.g. 1.2 = 20% bonus on top of salary

        BonusEligibleEmployee(String name, double annualSalary, double bonusMultiplier) {
            super(name, annualSalary);
            this.bonusMultiplier = bonusMultiplier;
        }

        @Override
        public double calculateMonthlyPay() {
            // LSP is respected: substituting this for FullTimeEmployee still makes sense.
            // We return MORE than base pay, never LESS or something nonsensical.
            return super.calculateMonthlyPay() * bonusMultiplier;
        }
    }

    // This method works on ANY PayrollEmployee — it doesn't care about the subtype.
    // LSP guarantees this is safe: every subtype correctly fulfils the contract.
    static void processPayroll(PayrollEmployee[] employees) {
        double totalPayroll = 0;
        for (PayrollEmployee employee : employees) {
            double pay = employee.calculateMonthlyPay(); // runtime polymorphism
            totalPayroll += pay;
            System.out.printf("%-25s $%.2f%n", employee.getName(), pay);
        }
        System.out.printf("%-25s $%.2f%n", "TOTAL PAYROLL:", totalPayroll);
    }

    public static void main(String[] args) {
        PayrollEmployee[] team = {
            new FullTimeEmployee("Sarah Chen", 84000),           // $7,000/month
            new Contractor("Marcus Webb", 95.00, 160),           // $15,200/month
            new BonusEligibleEmployee("Priya Patel", 96000, 1.25) // $10,000/month
        };

        System.out.println("=== Monthly Payroll Run ===");
        processPayroll(team);
    }
}