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

// ShapeHierarchy.java — a self-contained, runnable example
// Demonstrates abstract class with both abstract and concrete methods

abstract class Shape {
    // A concrete field — every shape has a colour
    private final String colour;

    // Abstract classes CAN have constructors.
    // Subclasses call this via super() to ensure colour is always set.
    public Shape(String colour) {
        this.colour = colour;
    }

    // ABSTRACT METHOD — no body here.
    // Every concrete subclass MUST provide its own implementation.
    public abstract double calculateArea();

    // CONCRETE METHOD — shared logic that every shape can use as-is.
    // No need to re-implement this in Circle or Rectangle.
    public void printDetails() {
        System.out.printf(
            "Shape: %-12s | Colour: %-8s | Area: %.2f%n",
            getClass().getSimpleName(),
            colour,
            calculateArea()  // polymorphic call — resolved at runtime
        );
    }

    public String getColour() {
        return colour;
    }
}

// Circle MUST implement calculateArea() or itself be declared abstract
class Circle extends Shape {
    private final double radius;

    public Circle(String colour, double radius) {
        super(colour);  // delegate colour handling to the abstract parent
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;  // Circle-specific formula
    }
}

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

    public Rectangle(String colour, double width, double height) {
        super(colour);
        this.width = width;
        this.height = height;
    }

    @Override
    public double calculateArea() {
        return width * height;  // Rectangle-specific formula
    }
}

public class ShapeHierarchy {
    public static void main(String[] args) {
        // Shape redShape = new Shape("red"); // COMPILE ERROR — can't instantiate abstract class

        // We use the abstract type as the reference — polymorphism in action
        Shape circle    = new Circle("Red", 5.0);
        Shape rectangle = new Rectangle("Blue", 4.0, 6.0);

        // printDetails() is called on each, but calculateArea() resolves
        // to the correct subclass implementation at runtime
        circle.printDetails();
        rectangle.printDetails();
    }
}

// DataExportPipeline.java — Template Method pattern with abstract classes
// Models a real-world export pipeline: validate → transform → write

abstract class DataExporter {
    // TEMPLATE METHOD — concrete, final so subclasses can't reorder the steps.
    // This is the locked-in algorithm skeleton.
    public final void export(String rawData) {
        System.out.println("--- Starting export via " + getClass().getSimpleName() + " ---");
        
        if (!validate(rawData)) {
            System.out.println("Validation failed. Export aborted.");
            return;
        }
        
        String transformedData = transform(rawData);
        write(transformedData);
        
        System.out.println("--- Export complete ---\n");
    }

    // These three steps are abstract — each subclass owns its implementation
    protected abstract boolean validate(String rawData);
    protected abstract String  transform(String rawData);
    protected abstract void    write(String processedData);
}

// CSV-specific exporter — only fills in the variable steps
class CsvExporter extends DataExporter {
    @Override
    protected boolean validate(String rawData) {
        // Simple check: CSV must contain a comma
        boolean isValid = rawData.contains(",");
        System.out.println("[CSV] Validation " + (isValid ? "passed" : "failed"));
        return isValid;
    }

    @Override
    protected String transform(String rawData) {
        // Wrap values in quotes for safe CSV output
        String transformed = rawData.replace(",", "\",\"");
        System.out.println("[CSV] Transformed: \"" + transformed + "\"");
        return transformed;
    }

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

// JSON-specific exporter — completely different logic, same skeleton
class JsonExporter extends DataExporter {
    @Override
    protected boolean validate(String rawData) {
        // Minimal check: JSON-ish data starts with a letter
        boolean isValid = rawData != null && !rawData.isBlank();
        System.out.println("[JSON] Validation " + (isValid ? "passed" : "failed"));
        return isValid;
    }

    @Override
    protected String transform(String rawData) {
        // Wrap as a simple JSON object
        String transformed = "{\"data\": \"" + rawData + "\"}"; 
        System.out.println("[JSON] Transformed: " + transformed);
        return transformed;
    }

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

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");          // valid JSON input
        csvExporter.export("no commas here");      // validation will fail
    }
}

// BirdHierarchy.java — combining abstract class + interface
// Shows why the two tools complement rather than compete with each other

// Interface: defines a CAPABILITY — not all birds have this
interface Flyable {
    void fly();  // What a flyable thing must be able to do

    // Default method available since Java 8 — a reasonable fallback
    default String getFlightType() {
        return "powered flight";
    }
}

// Abstract class: defines what every Bird IS — shared identity and state
abstract class Bird {
    private final String species;
    private final String sound;

    public Bird(String species, String sound) {
        this.species = species;
        this.sound   = sound;
    }

    // Concrete shared behaviour — every bird calls its sound
    public void makeSound() {
        System.out.println(species + " says: " + sound);
    }

    // Abstract — each bird has its own way of moving on the ground
    public abstract void move();

    public String getSpecies() { return species; }
}

// Eagle IS a Bird AND CAN FLY
class Eagle extends Bird implements Flyable {
    public Eagle() {
        super("Eagle", "Screech!");
    }

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

    @Override
    public void fly() {
        System.out.println("Eagle soars on thermal currents at 160 km/h");
    }
}

// Penguin IS a Bird but CANNOT FLY — no Flyable here
class Penguin extends Bird {
    public Penguin() {
        super("Penguin", "Squawk!");
    }

    @Override
    public void move() {
        System.out.println("Penguin waddles across the ice");
    }
}

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

        // Both share Bird behaviour
        eagle.makeSound();
        eagle.move();
        eagle.fly();  // Eagle-only capability
        System.out.println("Flight type: " + eagle.getFlightType()); // interface default

        System.out.println();

        penguin.makeSound();
        penguin.move();
        // penguin.fly() — this would be a compile error: Penguin doesn't implement Flyable
    }
}