Abstract Classes & Interfaces

1// Abstract class: cannot be instantiated, may have abstract methods
2public abstract class Vehicle {
3    // Instance state — available to all subclasses
4    protected String make;
5    protected String model;
6    protected int year;
7    private double fuelLevel;
8
9    // Constructor — called by subclass constructors via super()
10    protected Vehicle(String make, String model, int year) {
11        this.make = make;
12        this.model = model;
13        this.year = year;
14        this.fuelLevel = 1.0;  // 100%
15    }
16
17    // Abstract methods: subclasses MUST implement these
18    public abstract double fuelEfficiency(); // km per liter
19    public abstract String fuelType();
20    public abstract void start();
21
22    // Concrete method: shared by all subclasses
23    public double range() {
24        return fuelLevel * 60 * fuelEfficiency(); // 60L tank
25    }
26
27    public void refuel(double amount) {
28        fuelLevel = Math.min(1.0, fuelLevel + amount / 60.0);
29    }
30
31    // Template method pattern: concrete flow, abstract steps
32    public final String describe() {
33        return String.format("%d %s %s — %s, range: %.0f km",
34            year, make, model, fuelType(), range());
35    }
36
37    @Override
38    public String toString() { return describe(); }
39}
40
41// Concrete subclasses implement the abstract methods
42public class GasolineCar extends Vehicle {
43    private int engineCc;
44
45    public GasolineCar(String make, String model, int year, int cc) {
46        super(make, model, year);
47        this.engineCc = cc;
48    }
49
50    @Override public double fuelEfficiency() { return 12.5; } // km/L
51    @Override public String fuelType()       { return "Gasoline"; }
52    @Override public void start() { System.out.println("Vroom! Engine starts."); }
53}
54
55public class ElectricCar extends Vehicle {
56    private int batteryKwh;
57
58    public ElectricCar(String make, String model, int year, int kwh) {
59        super(make, model, year);
60        this.batteryKwh = kwh;
61    }
62
63    @Override public double fuelEfficiency() { return 6.0; }  // km/kWh
64    @Override public String fuelType()       { return "Electric"; }
65    @Override public void start() { System.out.println("Silent motor engages."); }
66}
67
68// Vehicle car = new Vehicle(...); // COMPILE ERROR: abstract class
69Vehicle gas = new GasolineCar("Toyota", "Camry", 2023, 2000);
70Vehicle ev  = new ElectricCar("Tesla", "Model 3", 2023, 75);
71gas.start();
72System.out.println(ev.describe());

1// Interface: defines capabilities (what), not state (how)
2public interface Printable {
3    void print();  // implicitly public abstract
4}
5
6public interface Serializable {
7    String serialize();
8    static Serializable of(String data) { return () -> data; } // static method
9}
10
11public interface Auditable {
12    String getCreatedBy();
13    java.time.LocalDateTime getCreatedAt();
14
15    // Default method: provides implementation (Java 8+)
16    default String auditInfo() {
17        return String.format("Created by %s at %s",
18            getCreatedBy(), getCreatedAt());
19    }
20}
21
22// A class can implement multiple interfaces
23public class Document implements Printable, Serializable, Auditable {
24    private String title;
25    private String content;
26    private String createdBy;
27    private java.time.LocalDateTime createdAt;
28
29    public Document(String title, String content, String createdBy) {
30        this.title = title;
31        this.content = content;
32        this.createdBy = createdBy;
33        this.createdAt = java.time.LocalDateTime.now();
34    }
35
36    // From Printable
37    @Override
38    public void print() {
39        System.out.println("=== " + title + " ===");
40        System.out.println(content);
41    }
42
43    // From Serializable
44    @Override
45    public String serialize() {
46        return title + "|" + content + "|" + createdBy;
47    }
48
49    // From Auditable
50    @Override public String getCreatedBy() { return createdBy; }
51    @Override public java.time.LocalDateTime getCreatedAt() { return createdAt; }
52    // auditInfo() is inherited from Auditable — no override needed
53}
54
55// Interface as type — polymorphism across unrelated class hierarchies
56void printAll(List<Printable> items) {
57    items.forEach(Printable::print);  // method reference
58}
59
60void archiveAll(List<Serializable> items) {
61    items.stream()
62        .map(Serializable::serialize)
63        .forEach(System.out::println);
64}

1// Default methods enable evolving interfaces without breaking existing implementors
2public interface Collection<E> {  // simplified java.util.Collection
3    boolean add(E element);
4    boolean remove(E element);
5    int size();
6    boolean isEmpty();
7
8    // Default method (Java 8+): added after initial release
9    // Existing implementors inherit this — no code changes needed
10    default boolean addAll(Iterable<? extends E> elements) {
11        boolean changed = false;
12        for (E element : elements) {
13            changed |= add(element);
14        }
15        return changed;
16    }
17}
18
19// Functional interfaces: exactly ONE abstract method
20@FunctionalInterface
21public interface Transformer<T, R> {
22    R transform(T input);   // single abstract method
23
24    // Default methods don't break the functional interface contract
25    default Transformer<T, R> logBefore() {
26        return input -> {
27            System.out.println("Input: " + input);
28            return this.transform(input);
29        };
30    }
31}
32
33// Lambdas implement functional interfaces concisely
34Transformer<String, Integer> lengthOf = s -> s.length();
35Transformer<String, Integer> loggedLength = lengthOf.logBefore();
36
37System.out.println(lengthOf.transform("hello"));  // 5
38System.out.println(loggedLength.transform("hi")); // Input: hi\n2
39
40// Common built-in functional interfaces
41import java.util.function.*;
42
43Function<String, Integer> length    = String::length;        // T → R
44Predicate<String>          nonEmpty  = s -> !s.isEmpty();     // T → boolean
45Consumer<String>           printer   = System.out::println;   // T → void
46Supplier<String>           greeting  = () -> "Hello World";   // () → T
47BiFunction<Integer,Integer,Integer> add = (a, b) -> a + b;  // T,U → R
48
49System.out.println(length.apply("Java"));  // 4
50System.out.println(nonEmpty.test(""));     // false
51printer.accept("Printed!");
52System.out.println(greeting.get());
53System.out.println(add.apply(3, 4));       // 7

1// USE ABSTRACT CLASS when:
2// 1. Subclasses share state (instance variables)
3// 2. You want to provide partial implementations
4// 3. You need constructors to initialize shared state
5// 4. The hierarchy is tightly coupled (IS-A, same team)
6
7abstract class Report {  // has state → abstract class
8    protected String title;
9    protected LocalDate date;
10    protected List<String> lines = new ArrayList<>();
11
12    protected Report(String title) {
13        this.title = title;
14        this.date = LocalDate.now();
15    }
16
17    public abstract void generate();  // must implement
18
19    protected void addLine(String line) { lines.add(line); }  // shared
20
21    public void print() {  // shared template
22        System.out.println("Report: " + title + " (" + date + ")");
23        lines.forEach(System.out::println);
24    }
25}
26
27// USE INTERFACE when:
28// 1. Defining capabilities across unrelated class hierarchies
29// 2. Classes need to implement multiple contracts
30// 3. No shared state — just behavior contracts
31// 4. Design for extensibility across teams/libraries
32
33interface Exportable {  // no state → interface
34    byte[] toBytes();
35    default String toBase64() {
36        return java.util.Base64.getEncoder()
37            .encodeToString(toBytes());
38    }
39}
40
41interface Validatable {
42    List<String> validate();
43    default boolean isValid() { return validate().isEmpty(); }
44}
45
46// A class can only extend ONE abstract class
47// but can implement MULTIPLE interfaces
48class SalesReport extends Report
49    implements Exportable, Validatable, Comparable<SalesReport> {
50
51    private double totalSales;
52
53    public SalesReport(String title, double totalSales) {
54        super(title);
55        this.totalSales = totalSales;
56    }
57
58    @Override public void generate() {
59        addLine("Total Sales: $" + totalSales);
60    }
61
62    @Override public byte[] toBytes() {
63        return title.getBytes();
64    }
65
66    @Override public List<String> validate() {
67        List<String> errors = new ArrayList<>();
68        if (totalSales < 0) errors.add("Sales cannot be negative");
69        return errors;
70    }
71
72    @Override public int compareTo(SalesReport other) {
73        return Double.compare(this.totalSales, other.totalSales);
74    }
75}

1// Sealed interface (Java 17+): restricts permitted subtypes
2// All permitted types must be in the same package or module
3public sealed interface Shape permits Circle, Rectangle, Triangle {}
4
5public record Circle(double radius) implements Shape {}
6public record Rectangle(double width, double height) implements Shape {}
7public record Triangle(double base, double height) implements Shape {}
8
9// Exhaustive switch: compiler verifies all permitted types are handled
10// No 'default' needed if all cases are covered
11double area(Shape shape) {
12    return switch (shape) {
13        case Circle c     -> Math.PI * c.radius() * c.radius();
14        case Rectangle r  -> r.width() * r.height();
15        case Triangle t   -> 0.5 * t.base() * t.height();
16        // If you omit Triangle, the compiler gives an ERROR — not just a warning
17        // This is a compile-time guarantee that all shapes are handled
18    };
19}
20
21// Sealed interfaces for domain modeling
22public sealed interface PaymentResult permits Success, Failure, Pending {}
23
24record Success(String transactionId, double amount) implements PaymentResult {}
25record Failure(String reason, int errorCode) implements PaymentResult {}
26record Pending(String referenceId) implements PaymentResult {}
27
28// Process all payment outcomes exhaustively
29String handlePayment(PaymentResult result) {
30    return switch (result) {
31        case Success s  -> "Paid: " + s.transactionId();
32        case Failure f  -> "Failed: " + f.reason();
33        case Pending p  -> "Pending: " + p.referenceId();
34    };
35}