Abstract Classes in Java Explained — When, Why and How to Use Them

package io.thecodeforge.shape;

/**
 * ShapeHierarchy.java — a self-contained, runnable demonstration.
 * Shows abstract class with both abstract and concrete members.
 *
 * Key design decisions:
 *   - colour is shared state that every shape needs — lives in the abstract class
 *   - calculateArea() is abstract — each shape has a unique formula
 *   - printDetails() is concrete — the formatting logic is identical for all shapes
 *   - The constructor initialises shared state; subclasses call super()
 */
abstract class Shape {

    // Concrete field — every shape has a colour.
    // Lives here so it is initialised once, consistently, for all subclasses.
    private final String colour;

    // Abstract classes CAN and SHOULD have constructors.
    // Subclasses call this via super() to ensure colour is always set.
    // The abstract class itself is never instantiated — but this constructor
    // runs every time a concrete subclass is instantiated.
    protected Shape(String colour) {
        if (colour == null || colour.isBlank()) {
            throw new IllegalArgumentException("Shape colour cannot be null or blank");
        }
        this.colour = colour;
    }

    /**
     * ABSTRACT METHOD — no body here.
     * Every concrete subclass MUST provide its own implementation.
     * The compiler enforces this — forget to implement it and the build breaks.
     * There is no sensible default: area depends entirely on the geometry.
     */
    public abstract double calculateArea();

    /**
     * ABSTRACT METHOD — perimeter varies by geometry just as area does.
     * Declaring both as abstract ensures no half-implemented subclass reaches production.
     */
    public abstract double calculatePerimeter();

    /**
     * CONCRETE METHOD — shared formatting logic that every shape reuses.
     * This is why abstract classes beat interfaces when shared logic matters:
     * subclasses inherit this for free without writing a single line.
     */
    public void printDetails() {
        System.out.printf(
            "Shape: %-12s | Colour: %-8s | Area: %8.2f | Perimeter: %8.2f%n",
            getClass().getSimpleName(),
            colour,
            calculateArea(),       // resolved to the concrete subclass at runtime
            calculatePerimeter()   // same — polymorphism at work
        );
    }

    public String getColour() { return colour; }
}

class Circle extends Shape {
    private final double radius;

    public Circle(String colour, double radius) {
        super(colour);  // delegates shared state initialisation to the abstract parent
        if (radius <= 0) throw new IllegalArgumentException("Radius must be positive");
        this.radius = radius;
    }

    @Override  // @Override catches typos and signature mismatches at compile time
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}

class Rectangle extends Shape {
    private final double width;
    private final double height;

    public Rectangle(String colour, double width, double height) {
        super(colour);
        if (width <= 0 || height <= 0) throw new IllegalArgumentException("Dimensions must be positive");
        this.width = width;
        this.height = height;
    }

    @Override
    public double calculateArea() {
        return width * height;
    }

    @Override
    public double calculatePerimeter() {
        return 2 * (width + height);
    }
}

public class ShapeHierarchy {
    public static void main(String[] args) {
        // Shape redShape = new Shape("Red"); // COMPILE ERROR: Shape is abstract; cannot be instantiated

        // We store references as the abstract type — polymorphism in action.
        // The concrete type determines which calculateArea() runs at runtime.
        Shape[] shapes = {
            new Circle("Red", 5.0),
            new Rectangle("Blue", 4.0, 6.0),
            new Circle("Green", 3.5)
        };

        for (Shape shape : shapes) {
            shape.printDetails();
        }
    }
}

package io.thecodeforge.export;

/**
 * DataExportPipeline.java — Template Method pattern with abstract classes.
 *
 * Every export pipeline follows the same sequence:
 *   validate -> preProcess (optional hook) -> transform -> write -> postProcess (optional hook)
 *
 * The sequence is locked in the final export() method.
 * Subclasses fill in the required steps; optional hooks have no-op defaults.
 *
 * This is the pattern that prevents the 14K record corruption incident:
 * you cannot call transform() before validate() — the template method enforces it.
 */
abstract class DataExporter {

    /**
     * TEMPLATE METHOD — concrete and final.
     * Owns the algorithm sequence. Cannot be overridden.
     * Every export goes through exactly these steps in exactly this order.
     */
    public final void export(String rawData) {
        System.out.println("--- Starting export via " + getClass().getSimpleName() + " ---");

        if (!validate(rawData)) {
            System.out.println("[" + getClass().getSimpleName() + "] Validation failed — export aborted. No records written.");
            System.out.println();
            return;
        }

        preProcess(rawData);  // hook — optional step, no-op by default

        String transformedData = transform(rawData);
        write(transformedData);

        postProcess(transformedData);  // hook — optional step, no-op by default

        System.out.println("--- Export complete ---\n");
    }

    // REQUIRED STEPS — abstract, every subclass must provide its own implementation.
    // Missing any of these causes a compile error. The build catches it, not production.
    protected abstract boolean validate(String rawData);
    protected abstract String  transform(String rawData);
    protected abstract void    write(String processedData);

    // HOOK METHODS — concrete with no-op defaults.
    // Subclasses that need these steps override them; others inherit the no-op silently.
    protected void preProcess(String rawData) {
        // Default: do nothing. Override when pre-processing is needed.
    }

    protected void postProcess(String processedData) {
        // Default: do nothing. Override for post-write auditing, metrics emission, etc.
    }
}

/** CSV-specific exporter — fills in the three required steps. */
class CsvExporter extends DataExporter {

    @Override
    protected boolean validate(String rawData) {
        boolean isValid = rawData != null && rawData.contains(",");
        System.out.println("[CSV] Validation: " + (isValid ? "PASSED" : "FAILED — no commas found"));
        return isValid;
    }

    @Override
    protected String transform(String rawData) {
        // Wrap each comma-separated value in quotes for RFC 4180 compliance
        String transformed = '"' + rawData.replace(",", "\",\"") + '"';
        System.out.println("[CSV] Transformed: " + transformed);
        return transformed;
    }

    @Override
    protected void write(String processedData) {
        System.out.println("[CSV] Writing " + processedData.length() + " chars to output.csv");
    }
}

/** JSON-specific exporter — different logic, same fixed sequence. */
class JsonExporter extends DataExporter {

    @Override
    protected boolean validate(String rawData) {
        boolean isValid = rawData != null && !rawData.isBlank();
        System.out.println("[JSON] Validation: " + (isValid ? "PASSED" : "FAILED — empty input"));
        return isValid;
    }

    @Override
    protected String transform(String rawData) {
        // Produce a minimal valid JSON object
        String escaped = rawData.replace("\"", "\\\"");
        String transformed = "{\"data\": \"" + escaped + "\"}";
        System.out.println("[JSON] Transformed: " + transformed);
        return transformed;
    }

    @Override
    protected void write(String processedData) {
        System.out.println("[JSON] Writing " + processedData.length() + " chars to output.json");
    }

    // Overrides the optional postProcess hook — JSON exports emit metrics
    @Override
    protected void postProcess(String processedData) {
        System.out.println("[JSON] Emitting export metrics to monitoring system");
    }
}

public class DataExportPipeline {
    public static void main(String[] args) {
        DataExporter csvExporter  = new CsvExporter();
        DataExporter jsonExporter = new JsonExporter();

        csvExporter.export("Alice,30,Engineer");    // valid CSV
        jsonExporter.export("name: Bob, age: 25");   // valid JSON input
        csvExporter.export("no commas anywhere");    // validation fails — nothing written
        jsonExporter.export("");                     // validation fails — nothing written
    }
}

package io.thecodeforge.behavior;

/**
 * BirdHierarchy.java — combining abstract class and interface.
 *
 * Shows why the two tools complement rather than compete:
 *   - Bird (abstract class): what every bird IS — shared identity, shared state, shared behaviour
 *   - Flyable (interface): a capability that SOME birds have and others do not
 *
 * This models reality accurately. Forcing a Penguin to implement fly()
 * just because it IS a Bird would be a design error. The interface lets
 * the compiler enforce the capability only where it genuinely applies.
 */

// Interface: defines a CAPABILITY, not a family.
// An Eagle, a Bat, and a commercial aircraft could all implement Flyable.
// They share nothing else — the interface is purely about the capability.
interface Flyable {
    void fly();
    double getMaxAltitudeMetres();

    // Default method — available since Java 8.
    // Provides a sensible fallback without requiring all implementors to override.
    default String getFlightType() {
        return "powered flight";
    }
}

// Abstract class: defines what every Bird IS — shared identity, shared state.
// ALL birds share these fields and behaviours regardless of flight capability.
abstract class Bird {
    private final String species;   // shared state — every bird has a species
    private final String sound;     // shared state — every bird makes a sound

    // Constructor initialises shared state.
    // Any subclass that forgets to call super() gets a compile error.
    protected Bird(String species, String sound) {
        this.species = species;
        this.sound   = sound;
    }

    // Concrete shared behaviour — identical for every bird, no duplication.
    public void makeSound() {
        System.out.printf("%s says: %s%n", species, sound);
    }

    // Abstract — each bird species moves differently on the ground.
    // This MUST be implemented in every concrete Bird subclass.
    public abstract void move();

    public String getSpecies() { return species; }
}

// Eagle IS a Bird AND CAN FLY — inherits Bird state, implements Flyable capability.
class Eagle extends Bird implements Flyable {

    public Eagle() {
        super("Bald Eagle", "Screech!");
    }

    @Override
    public void move() {
        System.out.println("Eagle walks deliberately with powerful talons gripping the ground");
    }

    @Override
    public void fly() {
        System.out.println("Eagle soars on thermal currents, banking effortlessly at altitude");
    }

    @Override
    public double getMaxAltitudeMetres() {
        return 3000.0;  // Bald Eagles have been recorded above 3,000m
    }

    // Overrides the default — eagles glide as much as they power-flap
    @Override
    public String getFlightType() {
        return "thermal soaring and gliding";
    }
}

// Penguin IS a Bird but CANNOT FLY — no Flyable implementation.
// The compiler prevents anyone from calling penguin.fly() because Penguin
// never committed to that capability. Correct by design, not by convention.
class Penguin extends Bird {

    public Penguin() {
        super("Emperor Penguin", "Squawk!");
    }

    @Override
    public void move() {
        System.out.println("Penguin waddles across the ice at 2.5 km/h on stubby legs");
    }

    // No fly() — Penguin does not implement Flyable, so fly() is simply unavailable.
    // This is not a workaround; it is the correct model of reality.
}

public class BirdHierarchy {
    public static void main(String[] args) {
        Eagle   eagle   = new Eagle();
        Penguin penguin = new Penguin();

        System.out.println("=== Eagle ===");
        eagle.makeSound();   // inherited from Bird — shared concrete method
        eagle.move();        // Eagle's own implementation of the abstract method
        eagle.fly();         // Eagle's Flyable implementation
        System.out.printf("Max altitude: %.0fm | Flight type: %s%n",
            eagle.getMaxAltitudeMetres(), eagle.getFlightType());

        System.out.println("\n=== Penguin ===");
        penguin.makeSound();  // same shared concrete method
        penguin.move();       // Penguin's own implementation
        // penguin.fly();     // COMPILE ERROR — Penguin does not implement Flyable

        // Polymorphism via the interface — any Flyable, not just Eagle
        System.out.println("\n=== Flyable polymorphism ===");
        Flyable flier = eagle;  // Eagle satisfies the Flyable contract
        flier.fly();
        System.out.println("Is also a Bird? " + (flier instanceof Bird));
    }
}