Что такое Interface?

Interface в Java/Kotlin: контракт между объектами

Interface — это абстрактный тип, который определяет что должен делать класс, но не как это делать. Interface похож на контракт или договор: класс, реализующий interface, обещает реализовать все его методы. Это фундамент полиморфизма и loose coupling в объектно-ориентированном программировании.

Основные характеристики Interface

В Java:

• Содержит только сигнатуры методов (до Java 8 — без реализации)
• С Java 8 можно иметь default методы с реализацией
• Может содержать статические методы и константы
• Не может иметь состояния (только финальные переменные)
• Класс может реализовать несколько интерфейсов (множественное наследование)

В Kotlin:

interface UserRepository {
    // Абстрактный метод (без реализации)
    suspend fun getUser(id: Int): User
    
    // Default метод (с реализацией)
    fun getUsersCount(): Int = 0
    
    // Свойства
    val cacheSize: Int
}

Пример Interface для Android

// Определение контракта
interface ApiService {
    suspend fun fetchPosts(): List<Post>
    suspend fun fetchPost(id: Int): Post
    suspend fun createPost(post: Post): Post
}

// Реализация через Retrofit
class RetrofitApiService(private val retrofit: Retrofit) : ApiService {
    private val api = retrofit.create(PostApi::class.java)
    
    override suspend fun fetchPosts(): List<Post> = api.getPosts()
    override suspend fun fetchPost(id: Int): Post = api.getPost(id)
    override suspend fun createPost(post: Post): Post = api.createPost(post)
}

// Альтернативная реализация с mock данными
class MockApiService : ApiService {
    override suspend fun fetchPosts(): List<Post> = emptyList()
    override suspend fun fetchPost(id: Int): Post = Post(id, "Mock")
    override suspend fun createPost(post: Post): Post = post
}

// Использование — код не знает деталей реализации
class PostViewModel(private val apiService: ApiService) : ViewModel() {
    fun loadPosts() {
        viewModelScope.launch {
            val posts = apiService.fetchPosts()  // Работает с любой реализацией
            _posts.value = posts
        }
    }
}

Зачем нужны Interface?

1. Абстракция и полиморфизм

• Код работает с interface, не конкретной реализацией
• Можно менять реализацию без изменения кода

2. Тестирование

// В production используем настоящий API
val apiService: ApiService = RetrofitApiService(retrofit)

// В тестах используем mock
val apiService: ApiService = MockApiService()
val viewModel = PostViewModel(apiService)

3. Dependency Injection

// Constructor injection — interface в качестве параметра
class UserViewModel(
    private val repository: UserRepository,
    private val analytics: Analytics
) { }

// Легко подменять реализации (Hilt, Dagger, Koin)

4. Контракт и документация

// Interface сразу показывает, какие операции поддерживает класс
interface Database {
    suspend fun insert(entity: T)
    suspend fun update(entity: T)
    suspend fun delete(id: Int)
    suspend fun getById(id: Int): T?
}

Interface vs Abstract Class

// Interface — чистый контракт
interface Drawable {
    fun draw()
}

// Abstract class — частичная реализация
abstract class Shape {
    abstract fun draw()
    fun getArea(): Double = 0.0  // По умолчанию
    private val color = "black"
}

Best Practices

Создавай маленькие, сфокусированные интерфейсы

// ✅ Хорошо — интерфейс для одной ответственности
interface Logger {
    fun log(message: String)
}

// ❌ Плохо — слишком много методов
interface MegaService {
    fun log()
    fun sendRequest()
    fun saveData()
    fun notify()
}

Используй Dependency Inversion Principle

// ❌ Плохо — зависит от конкретного класса
class UserViewModel(private val retrofitService: RetrofitApiService) { }

// ✅ Хорошо — зависит от интерфейса
class UserViewModel(private val apiService: ApiService) { }

Interface в Android Framework

• View.OnClickListener — обработка кликов
• RecyclerView.Adapter — адаптер для списков
• Room.Dao — доступ к базе данных
• Retrofit — HTTP-клиент
• LiveData.Observer — наблюдение за изменениями

Interface — это не просто техническая особенность языка, это архитектурный инструмент для создания гибких, тестируемых, поддерживаемых приложений. Хороший Android-разработчик понимает, как правильно проектировать интерфейсы для своего приложения.