Как создать экземпляр анонимного интерфейса в Kotlin?

Question

stack_user25 · 09.05.2026

Как создать экземпляр анонимного интерфейса в Kotlin?

Всем привет! Я только начал изучать Kotlin после Java и столкнулся с проблемой. В Java я часто использовал анонимные классы для интерфейсов, например, для обработчиков кликов или слушателей. Вот как я делал это в Java:

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        System.out.println("Clicked!");
    }
});

Теперь я пытаюсь сделать то же самое в Kotlin, но у меня не получается. У меня есть простой интерфейс:

interface ClickListener {
    fun onClick()
}

Я хочу создать экземпляр этого интерфейса прямо в коде, без создания отдельного класса. В Java это было просто: `new ClickListener() { ... }`. Но в Kotlin я пробую разные варианты, и ни один не работает:

// Вариант 1 - не компилируется
val listener = ClickListener() {
    println("Clicked!")
}

// Вариант 2 - тоже ошибка
val listener = object : ClickListener {
    println("Clicked!")
}

Второй вариант даже не даёт нормальной подсказки от IDE. Я уже прочитал несколько статей, но всё равно путаюсь. Подскажите, как правильно создавать анонимные реализации интерфейсов в Kotlin? И можно ли использовать лямбда-выражения, если в интерфейсе только один метод? Буду благодарен за примеры с пояснениями. <<>>

Правильный способ создания анонимного интерфейса в Kotlin

В Kotlin для создания анонимного экземпляра интерфейса используется ключевое слово object. Ваш второй вариант был почти правильным, но не хватало фигурных скобок для тела объекта. Вот корректный синтаксис:

interface ClickListener {
    fun onClick()
}

// Правильный способ создания анонимного экземпляра
val listener = object : ClickListener {
    override fun onClick() {
        println("Clicked!")
    }
}

// Использование
listener.onClick() // Выведет: Clicked!

Обратите внимание на ключевые моменты:

Используется конструкция object : ИмяИнтерфейса
Обязательно нужно переопределить все методы интерфейса с помощью override
Тело объекта заключается в фигурные скобки { }

Использование SAM-конверсии для интерфейсов с одним методом

Если ваш интерфейс содержит только один абстрактный метод (такие интерфейсы называются SAM — Single Abstract Method), Kotlin позволяет использовать лямбда-выражения. Однако есть важный нюанс: SAM-конверсия работает только для интерфейсов, объявленных в Java, или для функций, которые принимают такие интерфейсы в качестве параметров.

Для интерфейса, объявленного в Kotlin, SAM-конверсия не работает автоматически. Но вы можете сделать её явно, пометив интерфейс ключевым словом fun:

// Объявляем функциональный интерфейс (SAM)
fun interface ClickListener {
    fun onClick()
}

// Теперь можно использовать лямбду!
val listener = ClickListener { println("Clicked!") }

// Или ещё короче:
val listener2 = { println("Clicked!") } as ClickListener

// Использование
listener.onClick() // Выведет: Clicked!

Пример с передачей в функцию

Чаще всего анонимные интерфейсы используются при передаче в функции. Вот как это выглядит на практике:

// Функция, принимающая слушатель
fun setOnClickListener(listener: ClickListener) {
    listener.onClick()
}

// Передача анонимного объекта
setOnClickListener(object : ClickListener {
    override fun onClick() {
        println("Вызов через анонимный объект")
    }
})

// Если интерфейс функциональный — можно лямбду
setOnClickListener(ClickListener { println("Вызов через лямбду") })

// Или даже так (если параметр последний):
setOnClickListener { println("Ещё проще!") }

Что делать, если интерфейс уже объявлен без fun?

Если вы работаете с существующим интерфейсом, который нельзя изменить (например, из библиотеки), используйте object. Это универсальный способ, который работает всегда:

interface OldClickListener {
    fun onClick()
    fun onLongClick()
}

// Только через object, так как методов больше одного
val listener = object : OldClickListener {
    override fun onClick() { println("Click") }
    override fun onLongClick() { println("Long click") }
}

Запомните простое правило: если в интерфейсе один метод — можно сделать его fun interface и использовать лямбды. Если методов несколько или вы не можете менять интерфейс — используйте object : ИмяИнтерфейса { ... }.

<<>>

Альтернативный подход: использование лямбд без SAM-интерфейсов

Если вы не хотите менять объявление интерфейса или используете сторонний код, можно обойтись без анонимных классов вообще. Вместо интерфейса с одним методом часто лучше передавать лямбду напрямую:

// Вместо интерфейса ClickListener
typealias ClickHandler = () -> Unit

// Функция принимает лямбду
fun setOnClick(handler: ClickHandler) {
    handler()
}

// Использование
setOnClick { println("Лямбда без интерфейса!") }

Этот подход более идиоматичен для Kotlin. В стандартной библиотеке Kotlin вы редко встретите интерфейсы-слушатели — вместо них используются функциональные типы. Например, в Android-разработке с Jetpack Compose:

Button(onClick = { println("Нажали!") })

Здесь onClick — это просто лямбда () -> Unit, а не экземпляр интерфейса. Советую привыкать к такому стилю, он делает код короче и понятнее.

Если же вам обязательно нужен анонимный класс (например, для совместимости с Java-библиотеками), используйте object — это надёжный и читаемый способ.

0 ответов