Interface trong Java: định nghĩa hợp đồng và implements

Interface là một bản hợp đồng

Interface khai báo một lớp làm được gì mà không nói làm thế nào. Đó là danh sách các chữ ký phương thức (method signature) mà mọi lớp triển khai cam kết thực hiện. Mục đích là tách rời (decoupling): code có thể làm việc với kiểu interface mà không cần quan tâm lớp cụ thể nào đứng phía sau.

interface Shape {
    double area();          // every Shape must provide an area
    double perimeter();
}

class Circle implements Shape {
    private final double radius;

    Circle(double radius) { this.radius = radius; }

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

public class Main {
    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.printf("area %.2f, perimeter %.2f%n", s.area(), s.perimeter());
    }
}

Circle implements Shape nghĩa là Circle phải định nghĩa area và perimeter. Khi đã làm vậy, một Circle là một Shape và có thể lưu trong biến kiểu Shape.

Nhiều lớp, một kiểu

Sức mạnh của interface lộ rõ khi nhiều lớp không liên quan cùng triển khai một interface. Code viết cho Shape xử lý được tất cả:

import java.util.List;

interface Shape {
    double area();
}

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

class Rectangle implements Shape {
    private final double w, h;
    Rectangle(double w, double h) { this.w = w; this.h = h; }
    public double area() { return w * h; }
}

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

        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();   // works for every Shape, whatever its class
        }
        System.out.printf("total area: %.2f%n", total);
    }
}

Vòng lặp không bao giờ hỏi "đây là Circle hay Rectangle?". Nó chỉ gọi area() và tin vào hợp đồng. Sau này thêm một lớp Triangle cũng không cần sửa gì ở đây.

Triển khai nhiều interface

Một lớp chỉ kế thừa (extends) được một lớp, nhưng có thể triển khai bao nhiêu interface cũng được. Đây là cách Java hỗ trợ "đa kế thừa" hành vi một cách an toàn:

interface Drawable { void draw(); }
interface Resizable { void resize(double factor); }

class Sprite implements Drawable, Resizable {
    private double scale = 1.0;

    public void draw() { System.out.println("drawing at scale " + scale); }
    public void resize(double factor) { scale *= factor; }
}

public class Main {
    public static void main(String[] args) {
        Sprite s = new Sprite();
        s.resize(2.0);
        s.draw();
    }
}

Liệt kê các interface sau implements, cách nhau bằng dấu phẩy. Lớp phải đáp ứng tất cả các interface đó.

Phương thức default và static

Từ Java 8, interface có thể chứa thân phương thức. Phương thức default cho các lớp triển khai một phần cài đặt có sẵn, được thừa hưởng miễn phí (và có thể ghi đè):

interface Greeter {
    String name();

    default String greet() {        // shared implementation
        return "Hello, " + name();
    }
}

class English implements Greeter {
    public String name() { return "world"; }
    // greet() is inherited from the interface
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new English().greet());
    }
}

Phương thức default giúp interface phát triển thêm: bạn thêm phương thức mới mà không làm hỏng mọi lớp đã triển khai. Ngược lại, phương thức interface static hoạt động như các thành viên static khác: đó là tiện ích bạn gọi trực tiếp trên interface, ví dụ Comparator.naturalOrder().

Hằng số

Các trường khai báo trong interface ngầm định là public static final: chúng là hằng số, không phải trạng thái của instance:

interface Physics {
    double GRAVITY = 9.81;   // automatically public static final
}

Theo truyền thống, interface không giữ trạng thái riêng cho từng đối tượng; việc không có trường instance là một phần khiến interface khác với lớp.

Functional interface

Interface có đúng một phương thức trừu tượng được gọi là functional interface, và bạn có thể triển khai nó bằng một biểu thức lambda thay vì viết cả một lớp:

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;     // lambda implements the single method
        System.out.println(doubler.apply(21));
    }
}

Đây là nền tảng của lambda trong Java và các kiểu trong java.util.function (Function, Predicate, Supplier và nhiều kiểu khác). Annotation @FunctionalInterface thể hiện rõ ý định và để trình biên dịch kiểm tra quy tắc chỉ có một phương thức.

Interface và abstract class

Cả hai đều cho phép bạn lập trình dựa trên một lớp trừu tượng hóa, vậy khi nào chọn cái nào?

• Interface: một khả năng mà các lớp không liên quan có thể cùng có. Bird và Airplane đều có thể là Flyable. Một lớp có thể triển khai nhiều interface. Không có trạng thái instance.
• Abstract class (lớp trừu tượng): trạng thái và code dùng chung giữa các lớp có quan hệ gần gũi. Cat và Dog đều kế thừa Animal, thừa hưởng các trường chung và các phương thức đã viết sẵn một phần. Một lớp chỉ kế thừa được một lớp.

Một cách làm phổ biến là kết hợp cả hai: interface định nghĩa hợp đồng, lớp trừu tượng cài đặt phần code lặp lại (boilerplate), để các lớp con cụ thể chỉ cần viết phần riêng của mình.

Tiếp theo: lớp trừu tượng

Interface định nghĩa hành vi mà không có trạng thái. Lớp trừu tượng nằm giữa interface và lớp đầy đủ: nó có thể khai báo các phương thức chưa cài đặt và đồng thời có trường và hàm khởi tạo. Đó là nội dung của trang tiếp theo.