Giao diện hàm

Thuộc phần Lập trình hướng đối tượng trong hành trình Java của Coddy. Bài học 39 trên 87.

Giao diện hàm (functional interface) là giao diện chỉ chứa đúng một phương thức trừu tượng. Quy tắc chỉ có một phương thức này khiến giao diện hàm trở nên đặc biệt, vì bạn có thể triển khai chúng bằng biểu thức lambda, giúp viết code ngắn gọn hơn.

Java cung cấp chú thích @FunctionalInterface để đánh dấu rõ ràng một giao diện là giao diện hàm. Dù không bắt buộc, chú thích này giúp trình biên dịch phát hiện lỗi nếu bạn vô tình thêm một phương thức trừu tượng thứ hai:

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

Bạn có thể triển khai giao diện hàm (functional interface) theo cách truyền thống bằng một lớp, hoặc viết ngắn gọn hơn bằng biểu thức lambda:

// Cách triển khai truyền thống
Calculator adder = new Calculator() {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
};

// Biểu thức lambda (ngắn hơn nhiều!)
Calculator adder = (a, b) -> a + b;

System.out.println(adder.calculate(5, 3));  // 8

Giao diện hàm vẫn có thể có phương thức mặc định và phương thức tĩnh vì chúng không được tính vào quy tắc chỉ có một phương thức trừu tượng. Gói java.util.function của Java cung cấp nhiều giao diện hàm dựng sẵn như Predicate, Function và Consumer. Bạn sẽ thường gặp chúng khi làm việc với luồng và bộ sưu tập.

Thử thách

Dễ

Hãy xây dựng một hệ thống chuyển đổi chuỗi bằng giao diện hàm (functional interface) và biểu thức lambda. Bạn sẽ tạo một bộ xử lý văn bản linh hoạt có thể áp dụng nhiều cách chuyển đổi khác nhau cho chuỗi, tất cả đều dựa trên một giao diện hàm duy nhất.

Bạn sẽ sắp xếp code trong ba tệp:

StringTransformer.java: Định nghĩa một giao diện hàm đại diện cho bất kỳ thao tác chuyển đổi chuỗi nào. Đánh dấu giao diện bằng chú thích @FunctionalInterface để đảm bảo giao diện vẫn là giao diện hàm. Giao diện cần khai báo một phương thức trừu tượng duy nhất có tên transform, nhận một String và trả về một String.
TextProcessor.java: Tạo một lớp dùng giao diện hàm của bạn để xử lý văn bản. Lớp cần có một trường lưu StringTransformer và một hàm khởi tạo để khởi tạo trường đó. Thêm phương thức có tên process(String text), áp dụng bộ chuyển đổi cho văn bản đã cho và trả về kết quả. Thiết kế này cho phép bạn truyền vào bất kỳ hành vi chuyển đổi nào thông qua hàm khởi tạo.
Main.java: Kết hợp mọi thứ bằng cách tạo các cách chuyển đổi khác nhau với biểu thức lambda. Bạn sẽ nhận hai đầu vào: một chuỗi văn bản và một kiểu thao tác (upper, lower hoặc reverse).
Dựa trên kiểu thao tác, hãy tạo một TextProcessor với biểu thức lambda phù hợp:
- upper: chuyển văn bản thành chữ hoa
- lower: chuyển văn bản thành chữ thường
- reverse: đảo ngược văn bản (gợi ý: dùng StringBuilder)
Sau đó, gọi process() với văn bản đầu vào và in kết quả theo định dạng này: Result: [transformed text]

Bạn sẽ nhận hai đầu vào: văn bản cần chuyển đổi (String) và kiểu thao tác (String).

Hãy chú ý cách cùng một lớp TextProcessor có thể thực hiện những thao tác hoàn toàn khác nhau tùy theo biểu thức lambda bạn truyền vào. Đó chính là sức mạnh của giao diện hàm!

Tự làm thử

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String text = scanner.nextLine();
        String operation = scanner.nextLine();
        
        TextProcessor processor;
        
        // TODO: Dựa vào loại thao tác, tạo TextProcessor với lambda phù hợp:
        // - "upper": chuyển văn bản thành chữ hoa
        // - "lower": chuyển văn bản thành chữ thường
        // - "reverse": đảo ngược văn bản (gợi ý: dùng StringBuilder)
        
        // TODO: Gọi process() với văn bản đầu vào và in ra kết quả
        // Định dạng đầu ra: "Result: [transformed text]"
    }
}