Đa hình trong Java: một giao diện, nhiều hình thái

Một tham chiếu, nhiều kiểu

Đa hình (polymorphism) là thành quả của kế thừa và interface. Nó có nghĩa là một biến duy nhất có kiểu là lớp cha (hoặc một interface) có thể giữ đối tượng thuộc bất kỳ kiểu con nào, và khi bạn gọi một phương thức trên nó, Java chạy phiên bản thuộc về lớp thật của đối tượng, không phải phiên bản suy ra từ kiểu đã khai báo của biến.

Bạn đã thấy phần chuẩn bị ở trang kế thừa: một lớp con ghi đè một phương thức của lớp cha. Đa hình là thứ khiến việc ghi đè đó đáng làm: nó cho phép bạn viết code theo kiểu tổng quát và để mỗi đối tượng cụ thể hành xử theo cách riêng.

class Animal {
    String speak() { return "..."; }
}

class Dog extends Animal {
    String speak() { return "Woof"; }
}

class Cat extends Animal {
    String speak() { return "Meow"; }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();   // a parent reference holding a child object
        Animal b = new Cat();

        System.out.println(a.speak());   // Woof
        System.out.println(b.speak());   // Meow
    }
}

Cả a và b đều được khai báo là Animal, vậy mà mỗi biến in ra tiếng kêu riêng. Lựa chọn đó diễn ra lúc chạy, dựa trên đối tượng thật.

Dynamic method dispatch

Cơ chế đằng sau điều này là dynamic method dispatch (điều phối phương thức động): với một phương thức instance đã bị ghi đè, JVM nhìn vào lớp lúc chạy của đối tượng để quyết định gọi bản cài đặt nào. Trình biên dịch chỉ kiểm tra phương thức có tồn tại trên kiểu đã khai báo hay không; việc chọn thật sự được hoãn đến khi chương trình chạy.

Đây là thứ cho phép một vòng lặp xử lý cả một tập hỗn hợp các kiểu mà không bao giờ phải hỏi từng phần tử là gì:

import java.util.List;

class Shape {
    double area() { return 0; }
}

class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    double area() { return Math.PI * r * r; }
}

class Square extends Shape {
    private final double side;
    Square(double side) { this.side = side; }
    double area() { return side * side; }
}

public class Main {
    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Square(2), new Circle(3));

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // each call dispatches to the real subclass
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

Vòng lặp chỉ biết đến Shape. Sau này thêm một Triangle extends Shape thì đoạn code này vẫn chạy mà không cần sửa: đó chính là mục đích. Code phụ thuộc vào trừu tượng, không phụ thuộc vào danh sách cụ thể các kiểu.

Upcasting và downcasting

Lưu một Dog vào một biến Animal là upcasting: đi lên trong cây phân cấp tới một kiểu tổng quát hơn. Việc này luôn an toàn và Java tự làm ngầm định, vì mọi Dog đều là Animal.

Đi theo chiều ngược lại là downcasting: lấy một tham chiếu kiểu cha và coi nó như một kiểu con cụ thể. Đây là một dạng ép kiểu giữa các kiểu tham chiếu, và nó chỉ hợp lệ nếu đối tượng thật sự là kiểu con đó, nên bạn phải viết phép ép kiểu tường minh, và có nguy cơ gặp ClassCastException nếu bạn sai:

class Animal { }
class Dog extends Animal {
    void fetch() { System.out.println("fetching"); }
}
class Cat extends Animal { }

public class Main {
    public static void main(String[] args) {
        Animal a = new Dog();   // upcast - implicit, safe

        Dog d = (Dog) a;        // downcast - explicit, valid because a is really a Dog
        d.fetch();

        Animal c = new Cat();
        Dog wrong = (Dog) c;    // compiles, but throws ClassCastException at runtime
        wrong.fetch();
    }
}

Phép ép cuối cùng biên dịch bình thường, vì trình biên dịch không chứng minh được nó sai, nhưng sập khi chạy vì một Cat không phải là Dog. Đừng bao giờ downcast dựa trên niềm tin.

Bảo vệ downcast bằng instanceof

Trước khi downcast, hãy kiểm tra kiểu thật bằng instanceof. Java hiện đại cho phép bạn gán kết quả ngay trong cùng biểu thức (pattern matching cho instanceof), nên bạn bỏ được phép ép kiểu riêng:

class Animal { }
class Dog extends Animal {
    void fetch() { System.out.println("fetching"); }
}
class Cat extends Animal {
    void scratch() { System.out.println("scratching"); }
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = { new Dog(), new Cat(), new Dog() };

        for (Animal animal : animals) {
            if (animal instanceof Dog dog) {     // checks type AND binds dog
                dog.fetch();
            } else if (animal instanceof Cat cat) {
                cat.scratch();
            }
        }
    }
}

instanceof trả về false với null, nên phép kiểm tra này cũng bảo vệ bạn khỏi NullPointerException. Dù vậy, nếu bạn thấy mình viết những chuỗi instanceof dài, đó thường là dấu hiệu hành vi đó nên nằm bên trong các lớp dưới dạng một phương thức ghi đè: hãy để đa hình rẽ nhánh giúp bạn.

Ghi đè và nạp chồng

Hai khái niệm này nghe giống nhau nhưng không liên quan, và nhầm lẫn chúng là nguồn bối rối kinh điển.

Ghi đè (overriding) là lớp con thay thế một phương thức của lớp cha bằng phương thức có chữ ký giống hệt. Nó được quyết định lúc chạy theo kiểu của đối tượng: đây là đa hình mà chúng ta đang dùng.

Nạp chồng (overloading) là một lớp có nhiều phương thức cùng tên nhưng khác danh sách tham số. Nó được quyết định lúc biên dịch theo kiểu của đối số, không có điều phối nào lúc chạy:

public class Main {
    static String describe(int x)    { return "int: " + x; }
    static String describe(double x) { return "double: " + x; }
    static String describe(String x) { return "String: " + x; }

    public static void main(String[] args) {
        System.out.println(describe(5));      // int: 5
        System.out.println(describe(5.0));    // double: 5.0
        System.out.println(describe("five")); // String: five
    }
}

Trình biên dịch chọn describe phù hợp hoàn toàn dựa trên kiểu tĩnh của đối số. Không có đối tượng cha/con nào tham gia, nên đây không phải đa hình lúc chạy: nó chỉ dùng lại một tên phương thức.

Một bẫy thường gặp: thuộc tính không đa hình

Chỉ phương thức instance mới được điều phối lúc chạy. Thuộc tính và phương thức static được quyết định theo kiểu đã khai báo, điều này khiến rất nhiều người vấp:

class Parent {
    String label = "parent";
    String name() { return "Parent"; }
}

class Child extends Parent {
    String label = "child";          // hides, does not override
    String name() { return "Child"; }
}

public class Main {
    public static void main(String[] args) {
        Parent p = new Child();
        System.out.println(p.label);    // parent  - field uses declared type
        System.out.println(p.name());   // Child   - method uses runtime type
    }
}

p.name() chạy phiên bản của Child (đa hình), nhưng p.label đọc thuộc tính của Parent, vì thuộc tính bị che (hidden) chứ không bị ghi đè. Cách sửa rất đơn giản: giữ thuộc tính là private và chỉ truy cập chúng qua phương thức, để lời gọi đa hình luôn thắng.

Tiếp theo: access modifier

Đa hình chỉ hoạt động gọn gàng khi lớp con nhìn thấy và ghi đè được đúng các thành viên, trong khi phần còn lại của code không thể chọc vào và phá vỡ các bất biến. Sự cân bằng đó được điều khiển bởi các mức truy cập public, protected, private và package-private, tức các access modifier, nội dung tiếp theo.