Interface: bản chất, hợp đồng trong Java và Kotlin cho Android

Interface trong Java và Kotlin là gì?

Interface là một kiểu tham chiếu chứa các phương thức trừu tượng, hằng số và phương thức mặc định. Một lớp triển khai interface phải cung cấp triển khai cho tất cả các phương thức trừu tượng của nó. Trong Java, interface không thể có trạng thái (trường instance); Kotlin cũng tuân theo hạn chế này nhưng hỗ trợ thuộc tính với bộ truy cập.

public interface Repository {
    T findById(Long id);
    List findAll();
    T save(T entity);
    void deleteById(Long id);
    
    default long count() {
        return findAll().size();
    }
}

@Entity
public class UserEntity {
    private Long id;
    private String email;
    // getter và setter
}

public class UserRepositoryImpl implements Repository {
    private final EntityManager em;
    
    public UserEntity findById(Long id) {
        return em.find(UserEntity.class, id);
    }
    
    public List findAll() {
        return em.createQuery("FROM UserEntity", UserEntity.class)
                .getResultList();
    }
    // các phương thức khác
}

Repository<T> là một interface generic với các phương thức CRUD. Phương thức default count() cung cấp triển khai mặc định có thể được ghi đè. UserRepositoryImpl triển khai interface sử dụng EntityManager để truy cập dữ liệu. Cách tiếp cận này cho phép kiểm thử tầng dữ liệu thông qua mock của interface mà không cần cơ sở dữ liệu thực.

Interface vs abstract class: khi nào chọn cái gì

Lựa chọn giữa interface và lớp trừu tượng phụ thuộc vào sự hiện diện của trạng thái chia sẻ và mối quan hệ giữa các kiểu. Interface định nghĩa một hợp đồng (lớp có thể làm gì), lớp trừu tượng định nghĩa một triển khai chung (lớp là gì).

Trong Clean Architecture, interface được đặt ở tầng bên trong (domain), và triển khai ở tầng bên ngoài (data). Điều này cho phép duy trì Dependency Rule: tầng ngoài phụ thuộc vào tầng trong, nhưng không ngược lại. Lớp trừu tượng thường được sử dụng cho các phương thức khuôn mẫu (Template Method pattern).

Interface trong Kotlin: thuộc tính và ủy quyền

Interface Kotlin linh hoạt hơn Java: chúng có thể khai báo thuộc tính trừu tượng và cung cấp triển khai phương thức. Không giống Java, Kotlin hỗ trợ ủy quyền qua từ khóa by, giúp giảm đáng kể boilerplate khi triển khai mẫu Delegate.

interface ApiService {
    val baseUrl: String  // thuộc tính trừu tượng
    
    suspend fun fetchData(): Result>
    
    fun getEndpoint(path: String): String {
        return "$baseUrl/$path"  // triển khai mặc định
    }
}

class RetrofitApiService(
    override val baseUrl: String
) : ApiService {
    private val client = Retrofit.Builder()
        .baseUrl(baseUrl)
        .build()
    
    override suspend fun fetchData(): Result> {
        // triển khai yêu cầu
    }
}

// Ủy quyền qua by
interface Logger {
    fun log(message: String)
}

class ConsoleLogger : Logger {
    override fun log(message: String) = println(message)
}

class UserService(logger: Logger) : Logger by logger

UserService triển khai interface Logger thông qua ủy quyền (by). Tất cả các cuộc gọi log() được chuyển tiếp đến đối tượng logger mà không cần viết phương thức bao. Đây là một ví dụ về hợp thành mà trong Java sẽ cần 5-10 dòng mã boilerplate.

Interface trong Clean Architecture Android

Clean Architecture cho Android phân chia ứng dụng rõ ràng thành các tầng. Interface đóng vai trò là ranh giới giữa các tầng: Domain định nghĩa interface repository và UseCase, Data cung cấp triển khai. Điều này cho phép thay thế triển khai mà không thay đổi logic nghiệp vụ — một lợi thế chính khi di chuyển từ Room sang Firebase hoặc từ REST sang GraphQL.

// Domain layer — interface (hợp đồng)
interface UserRepository {
    suspend fun getUser(id: String): User
    suspend fun updateUser(user: User)
}

// Domain layer — use case (phụ thuộc vào interface)
class GetUserUseCase(
    private val repository: UserRepository
) {
    suspend operator fun invoke(id: String): Result {
        return runCatching { repository.getUser(id) }
    }
}

// Data layer — triển khai
class UserRepositoryImpl(
    private val api: UserApi,
    private val dao: UserDao
) : UserRepository {
    override suspend fun getUser(id: String): User {
        val cached = dao.getUser(id)
        if (cached != null) return cached
        val remote = api.fetchUser(id)
        dao.insertUser(remote)
        return remote
    }
    // updateUser...
}

UserRepository là một interface trong tầng domain. GetUserUseCase phụ thuộc vào interface, không phải triển khai. UserRepositoryImpl trong tầng data triển khai interface, kết hợp API và cơ sở dữ liệu cục bộ. Kiến trúc này cho phép kiểm thử UseCases với repository mock mà không cần thiết lập cơ sở dữ liệu hoặc mạng.

Phương thức default và static trong Java 8+

Phương thức default được thêm vào Java 8 để mở rộng tiến hóa của interface mà không phá vỡ tương thích ngược. Nếu ArrayList không triển khai phương thức stream() mới được thêm vào Collection, mã cũ vẫn tiếp tục hoạt động. Phương thức static trong interface phục vụ như các tiện ích liên quan đến interface — một giải pháp thay thế cho các lớp tiện ích.

public interface Vehicle {
    void start();
    void stop();
    
    default void honk() {
        System.out.println("Beep!");
    }
    
    static Vehicle of(String type) {
        if ("car".equals(type)) return new Car();
        return new Bicycle();
    }
    
    // hằng số
    String CATEGORY = "transport";
}

Phương thức default giải quyết vấn đề kim cương: nếu một lớp triển khai hai interface có cùng phương thức default, trình biên dịch yêu cầu ghi đè rõ ràng. Phương thức static được gọi thông qua tên interface — Vehicle.of("car"), mà không cần instance.

Lỗi thường gặp khi thiết kế interface

Lỗi trong thiết kế interface dẫn đến mã dễ vỡ, phức tạp kiểm thử và vi phạm SOLID. Hãy xem xét ba vấn đề phổ biến.

Interface Pollution — quá nhiều phương thức trong một interface

Interface chứa 15+ phương thức vi phạm Interface Segregation Principle (ISP). Một ví dụ là java.util.Dictionary cũ với 10+ phương thức. Giải pháp: chia thành nhiều interface nhỏ — ReadableRepository, WritableRepository, SearchableRepository. Client (dịch vụ) chỉ phụ thuộc vào các phương thức nó cần.

Trừu tượng quá mức — interface cho mọi lớp

Tạo interface cho mọi lớp mà không có nhu cầu thực sự về đa hình là phản mẫu Interface overkill. Dấu hiệu: interface có đúng một triển khai và dự án không có kế hoạch thêm giải pháp thay thế. Giải pháp: chỉ thêm interface khi xuất hiện tùy chọn triển khai thứ hai hoặc cần mock cho kiểm thử.