Object-Oriented Programming in Java: The 4 Core Principles

// All four OOP pillars applied in one small, compilable program.
public class OopPillarsDemo {
    // ABSTRACTION: the contract only, with no implementation detail
    public interface NotificationChannel {
        void send(String recipient, String message);
    } // ENCAPSULATION: private state the object validates for itself
    public static class EmailChannel implements NotificationChannel {
        private final String fromAddress;
        public EmailChannel(String fromAddress) {
            if (fromAddress == null || fromAddress.isBlank()) {
                throw new IllegalArgumentException("From address is required");
            } this.fromAddress = fromAddress;
        } @Override public void send(String recipient, String message) {
            System.out.println("Email from " + fromAddress + " to " + recipient + ": " + message);
        }
    } public static class SmsChannel implements NotificationChannel {
        private final String senderId;
        public SmsChannel(String senderId) {
            if (senderId == null || senderId.isBlank()) {
                throw new IllegalArgumentException("Sender id is required");
            } this.senderId = senderId;
        } @Override public void send(String recipient, String message) {
            System.out.println("SMS from " + senderId + " to " + recipient + ": " + message);
        }
    } // INHERITANCE: a base that cannot be instantiated on its own
    public abstract static class Vehicle {
        private final String model;
        private final NotificationChannel channel;
        protected Vehicle(String model, NotificationChannel channel) {
            if (model == null || model.isBlank()) {
                throw new IllegalArgumentException("Model is required");
            } this.model = model;
            this.channel = channel;
        } public String getModel() {
            return model;
        } public abstract void drive();
        // POLYMORPHISM: one call site, several implementations
        public void notifyArrival(String destination) {
            channel.send(model, "Arrived at " + destination);
        }
    } public static class Car extends Vehicle {
        public Car(String model, NotificationChannel channel) {
            super(model, channel);
        } @Override public void drive() {
            System.out.println("Driving " + getModel() + " on the highway");
        }
    } public static class Truck extends Vehicle {
        public Truck(String model, NotificationChannel channel) {
            super(model, channel);
        } @Override public void drive() {
            System.out.println("Hauling " + getModel() + " on the motorway");
        }
    } // COMPOSITION OVER INHERITANCE: hold a collection, do not extend one
    public static class Stack<T> {
        private final java.util.Deque<T> items = new java.util.ArrayDeque<>();
        public void push(T item) {
            items.addFirst(item);
        } public T pop() {
            if (items.isEmpty()) {
                throw new java.util.NoSuchElementException("Stack is empty");
            } return items.removeFirst();
        } public int size() {
            return items.size();
        }
    } // Compile-time polymorphism: same name, different parameter types
    public static String describe(Vehicle vehicle) {
        return "vehicle: " + vehicle.getModel();
    } public static String describe(int speedInKph) {
        return "raw speed: " + speedInKph + " kph";
    } public static void main(String[] args) {
        NotificationChannel email = new EmailChannel("noreply@example.com");
        NotificationChannel sms = new SmsChannel("SHORTCODE");
        // Both declared as Vehicle, both call the right drive()
        Vehicle car = new Car("Tesla Model 3", email);
        Vehicle truck = new Truck("Volvo FH", sms);
        car.drive();
        truck.drive();
        car.notifyArrival("Bengaluru");
        truck.notifyArrival("Chennai");
        // Adding a new type later needs no change to announce()
        Vehicle bike = new Vehicle("Hero Splendor", email) {
            @Override public void drive() {
                System.out.println("Riding " + getModel() + " in traffic");
            }
        };
        bike.drive();
        bike.notifyArrival("Pune");
        // Runtime type checking is only needed when a cast is unavoidable
        for (Vehicle vehicle : new Vehicle[] {
            car, truck, bike
        }) {
            String label = vehicle instanceof Car ? "four wheeled" : "other";
            System.out.println(describe(vehicle) + " is " + label);
        } Stack<String> stack = new Stack<>();
        stack.push("first");
        stack.push("second");
        System.out.println("popped: " + stack.pop() + ", size now " + stack.size());
        System.out.println(describe(car));
        // describe(Vehicle)
        System.out.println(describe(120));
        // describe(int)
        /*
            ACTUAL OUTPUT:

                Driving Tesla Model 3 on the highway
                Hauling Volvo FH on the motorway
                Email from noreply@example.com to Tesla Model 3: Arrived at Bengaluru
                SMS from SHORTCODE to Volvo FH: Arrived at Chennai
                Riding Hero Splendor in traffic
                Email from noreply@example.com to Hero Splendor: Arrived at Pune
                vehicle: Tesla Model 3 is four wheeled
                vehicle: Volvo FH is other
                vehicle: Hero Splendor is other
                popped: second, size now 1
                vehicle: Tesla Model 3
                raw speed: 120 kph

            WHICH PILLAR IS WHICH
            1) ABSTRACTION. NotificationChannel is a contract with no
               implementation, so a caller never learns whether delivery is
               email or SMS. The implementation can be swapped freely.
            2) ENCAPSULATION. Every field is private and final, and each
               constructor and setter checks its own rule. No caller can put
               a Channel or a Vehicle into an invalid state.
            3) INHERITANCE. Car and Truck extend Vehicle, which cannot be
               instantiated because it declares an abstract method. They
               reuse the model and channel handling instead of copying it.
            4) POLYMORPHISM. announceVehicle calls drive() once and the JVM
               picks the Car, Truck, or anonymous implementation at run
               time, which is why adding a new type needed no edits.
            5) COMPOSITION BEATS INHERITANCE. Stack holds a Deque rather
               than extending ArrayList, so no future ArrayList method can
               collide with a method you wrote.
            6) OVERLOADING IS NOT POLYMORPHISM IN THE USEFUL SENSE.
               describe(Vehicle) and describe(int) are picked by the
               compiler from the static types, so they add convenience
               rather than removing type checks from calling code.
        */
    }
}