Abstract class — template buộc subclass hoàn thiện

Bạn muốn viết class Shape chung cho Circle, Square, Triangle — cả 3 đều có method area(), perimeter(), nhưng công thức tính khác nhau. Class Shape không có công thức riêng, cũng không nên tồn tại như object cụ thể (ai tạo ra "shape" mà không phải hình gì?). Đây là lúc cần abstract class.

Abstract class là class không instantiate được và có thể chứa abstract method (method không body). Subclass bắt buộc implement các abstract method — compiler đảm bảo. Bài này giải thích khi nào chọn abstract class, pattern template method, và phân biệt với interface.

1. Analogy — bản thiết kế kiến trúc nhà

Bạn có bản thiết kế nhà mẫu — gồm cấu trúc tường, mái, điện, nước. Nhưng "vị trí cửa sổ" bản vẽ ghi "tuỳ chủ nhà". Bản thiết kế này không xây được thành ngôi nhà thật — phải có chủ nhà điền phần còn lại. Mỗi chủ xây cùng bản thiết kế ra nhà khác nhau ở phần "cửa sổ".

2. Cú pháp

public abstract class Shape {
    private final String name;

    protected Shape(String name) {
        this.name = name;
    }

    public String getName() { return name; }

    public abstract double area();          // abstract — khong body
    public abstract double perimeter();

    public String describe() {               // concrete — co body, dung abstract method
        return name + ": area=" + area() + ", perimeter=" + perimeter();
    }
}

Subclass phải implement abstract method:

public class Circle extends Shape {
    private final double radius;

    public Circle(double radius) {
        super("Circle");
        this.radius = radius;
    }

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

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

public class Square extends Shape {
    private final double side;

    public Square(double side) {
        super("Square");
        this.side = side;
    }

    @Override
    public double area() { return side * side; }

    @Override
    public double perimeter() { return side * 4; }
}

Dùng:

Shape s1 = new Circle(5);
Shape s2 = new Square(4);
System.out.println(s1.describe());   // Circle: area=78.53..., perimeter=31.41...
System.out.println(s2.describe());   // Square: area=16.0, perimeter=16.0

Shape s3 = new Shape("x");   // COMPILE ERROR — cannot instantiate abstract class

3. Quy tắc abstract class

3.1 Class đánh dấu abstract — không new được

Compiler bắt new Shape(...). Class vẫn có constructor — nhưng chỉ gọi được bằng super(...) từ subclass.

3.2 Chứa abstract method → class phải abstract

public class Shape {
    public abstract double area();   // COMPILE ERROR — class khong abstract
}

Fix: thêm abstract trước class.

3.3 Abstract class có thể không có abstract method nào

public abstract class BaseEntity {
    protected Long id;
    protected LocalDateTime createdAt;
    // khong co abstract method — nhung van abstract
}

Dùng khi: bạn muốn cấm instantiate (class "base" thuần tuý), nhưng không muốn buộc subclass override gì cụ thể. Pattern hiếm hơn nhưng hợp lệ.

3.4 Subclass không implement đủ → subclass phải abstract

abstract class Shape {
    public abstract double area();
    public abstract double perimeter();
}

abstract class Ellipse extends Shape {
    private double a, b;

    @Override
    public double area() { return Math.PI * a * b; }
    // khong implement perimeter -> Ellipse van abstract
}

class Circle extends Ellipse {
    private double r;
    @Override
    public double perimeter() { return 2 * Math.PI * r; }
    // lop nay da implement ca 2 -> concrete (co the new)
}

Subclass "truyền gánh nặng" cho cháu — hợp lệ nhưng thường là dấu hiệu nên nhóm lại.

4. Template Method Pattern

Abstract class với mix concrete method + abstract method là nền của template method pattern: cha định nghĩa thuật toán khung, gọi các bước trừu tượng; con cung cấp các bước cụ thể.

public abstract class DataExporter {
    public final void export(List<Record> records) {   // method final — khong override khung
        String header = buildHeader();
        String body = records.stream()
            .map(this::formatRecord)                    // goi abstract method
            .collect(Collectors.joining("\n"));
        String footer = buildFooter();
        writeFile(header + "\n" + body + "\n" + footer);
    }

    // Moi subclass customize 2 buoc
    protected abstract String formatRecord(Record r);
    protected abstract String buildHeader();
    protected String buildFooter() { return ""; }   // mac dinh empty, optional override

    private void writeFile(String content) { ... }   // private — khung quan ly
}

public class CsvExporter extends DataExporter {
    @Override
    protected String buildHeader() { return "id,name,email"; }

    @Override
    protected String formatRecord(Record r) {
        return r.id + "," + r.name + "," + r.email;
    }
}

public class JsonExporter extends DataExporter {
    @Override
    protected String buildHeader() { return "["; }

    @Override
    protected String formatRecord(Record r) {
        return "{\"id\":" + r.id + ", \"name\":\"" + r.name + "\"}";
    }

    @Override
    protected String buildFooter() { return "]"; }
}

Ưu điểm: luồng chung ở cha, biến thể ở con. Framework Java đầy ví dụ: javax.servlet.HttpServlet, AbstractList, InputStream.

5. Abstract class vs Interface — so sánh

Khi nào chọn abstract class?

✅ Abstract class khi:

• Có state chung subclass dùng (name, createdAt).
• Có implementation chung không muốn lặp (template method).
• Quan hệ "is-a" rõ: Circle extends Shape (hình tròn là một loại hình).

✅ Interface khi:

• Muốn nhóm class không cùng cây kế thừa có chung capability: Comparable, Serializable, Closeable.
• Không cần state — chỉ hợp đồng method.
• Muốn class implement nhiều "vai trò".

Modern Java (8+): interface cũng có default method, nên đôi khi ranh giới mờ. Rule đơn giản: cần state → abstract class; chỉ method → interface. Nhiều team hiện ưu tiên interface trừ khi thực sự cần abstract class.

6. protected constructor — pattern thường gặp

Abstract class thường dùng protected cho constructor:

public abstract class Shape {
    protected Shape(String name) { ... }
}

Lý do:

• Không cần public — không ai bên ngoài new được class abstract.
• protected vừa đủ để subclass gọi super(...).
• Tín hiệu rõ ý đồ cho reader: "class này chỉ extends".

7. Abstract class kèm sealed (Java 17+)

Hạn chế subclass chỉ trong tập xác định:

public sealed abstract class Shape permits Circle, Square, Triangle {
    public abstract double area();
}

public final class Circle extends Shape { ... }
public final class Square extends Shape { ... }
public final class Triangle extends Shape { ... }

// class Hexagon extends Shape { ... }   // COMPILE ERROR — khong trong permits

Kết hợp với switch pattern matching: compiler biết exhaustive, không cần default:

double area = switch (s) {
    case Circle c -> Math.PI * c.radius() * c.radius();
    case Square sq -> sq.side() * sq.side();
    case Triangle t -> 0.5 * t.base() * t.height();
    // khong can default — compiler biet 3 case la day du
};

Sẽ đào sâu ở bài 5.

8. Pitfall tổng hợp

❌ Nhầm 1: new abstract class.

Shape s = new Shape("abc");   // COMPILE ERROR

✅ Chỉ new subclass concrete.

❌ Nhầm 2: Có abstract method mà quên khai class abstract.

public class Shape {          // COMPILE ERROR
    public abstract double area();
}

✅ Thêm abstract trước class.

❌ Nhầm 3: Abstract method có body.

public abstract double area() { return 0; }   // COMPILE ERROR

✅ Abstract method không có { }.

❌ Nhầm 4: Subclass concrete không implement đủ abstract method.

abstract class Shape { public abstract double area(); }
class Circle extends Shape { }   // COMPILE ERROR — chua implement area()

✅ Implement hoặc khai Circle cũng abstract.

❌ Nhầm 5: Dùng abstract class cho "capability" thuần — vì bỏ qua sức mạnh của multi-interface.

abstract class Printable { public abstract void print(); }
// class Book extends Printable — OK, nhung class Book da extends PaperItem -> COMPILE ERROR

✅ interface Printable { void print(); } — class implement được nhiều interface.

9. 📚 Deep Dive Oracle

10. Tóm tắt

• abstract class không instantiate được trực tiếp. new Shape() → compile error.
• abstract method không có body, buộc subclass concrete implement.
• Class có abstract method → class phải abstract. Class abstract có thể không có abstract method nào.
• Abstract class có state (field), constructor, concrete method — khác với interface ở điểm này.
• Template method pattern: cha định nghĩa final khung, gọi abstract method; con cung cấp bước cụ thể.
• Constructor abstract class thường protected — tín hiệu "chỉ extends".
• So với interface: abstract class khi cần state + đơn kế thừa; interface khi nhóm capability không cùng cây.
• Modern Java ưu tiên interface; chỉ dùng abstract class khi thực sự cần state chung.
• sealed abstract class (Java 17+) cho phép kiểm soát subclass chính xác + pattern matching exhaustive.

11. Tự kiểm tra

public abstract class Vehicle {
    public abstract int maxSpeed();
}
public class Bike extends Vehicle { }

Vehicle v = new Bike();

abstract class Base {
    public Base() { step(); }
    public abstract void step();
}
class Sub extends Base {
    private int x = 10;
    @Override public void step() { System.out.println("x = " + x); }
}

new Sub();

public abstract class Shape {
    private final String name;

    protected Shape(String name) { this.name = name; }

    public abstract double area();
    public abstract double perimeter();

    public String describe() {
        return String.format("%s: area=%.2f, perimeter=%.2f",
            name, area(), perimeter());
    }
}

public class Circle extends Shape {
    private final double radius;

    public Circle(double radius) {
        super("Circle");
        if (radius <= 0) throw new IllegalArgumentException("radius must be positive");
        this.radius = radius;
    }

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

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

Bài tiếp theo: Interface — hợp đồng capability, default method, và đa kế thừa có kiểm soát