---
title: Переопределение
description: override и final, вызов super, конфликт реализаций и ковариантность результата
tags:
  - kotlin
  - oop
---

`override` обязательно. Без него член не переопределяет, а конфликтует с родительским.

```kotlin
open class Animal2 {
    open fun sound() = "..."
}

class Cat : Animal2() {
    override fun sound() = "Мяу"
    // fun sound() = "Мяу"     // ошибка: 'sound' hides member and needs 'override'
}

fun main() {
    val a: Animal2 = Cat()
    println(a.sound())      // Мяу — вызов по фактическому типу
}
```

Это закрывает два класса ошибок: опечатка в имени создала бы новый метод, а добавление метода в базовый класс случайно «переопределилось» бы существующим методом подкласса. В Kotlin и то и другое - ошибка компиляции.

## final override
Переопределённый член остаётся открытым для дальнейшего переопределения. Закрыть ветку - `final`:
```kotlin
open class A5 { open fun f() = "A" }
open class B5 : A5() { final override fun f() = "B" }
// class C5 : B5() { override fun f() = "C" }    // ошибка: f закрыт

fun main() { println(B5().f()) }      // B
```

## super
```kotlin
open class Logger3 {
    open fun log(msg: String) = "[базовый] $msg"
}

class TimestampLogger : Logger3() {
    override fun log(msg: String) = super.log("[время] $msg")
}

fun main() {
    println(TimestampLogger().log("привет"))    // [базовый] [время] привет
}
```
`super` работает и для свойств - через их геттеры:
```kotlin
open class Base20 {
    open val items: List<Int> get() = listOf(1, 2)
}

class Derived20 : Base20() {
    override val items: List<Int> get() = super.items + 3
}

fun main() { println(Derived20().items) }     // [1, 2, 3]
```

Из вложенного класса к `super` внешнего обращаются через `super@Outer`:
```kotlin
open class Base21 {
    open fun name() = "база"
}

class Outer4 : Base21() {
    override fun name() = "внешний"

    inner class Inner4 {
        fun bothNames() = "${name()} / ${super@Outer4.name()}"
    }
}

fun main() { println(Outer4().Inner4().bothNames()) }   // внешний / база
```

## Конфликт реализаций
Если два супертипа дают реализацию одного метода, компилятор требует разрешить конфликт явно:
```kotlin
interface A6 { fun f() = "A" }
interface B6 { fun f() = "B" }

class C6 : A6, B6 {
    override fun f() = super<A6>.f() + super<B6>.f()     // указываем источник
}

fun main() { println(C6().f()) }      // AB
```
Без `override` такой класс не скомпилируется - Kotlin не выбирает реализацию за вас.

То же с классом и интерфейсом:
```kotlin
open class Base22 { open fun f() = "класс" }
interface Mixin { fun f() = "интерфейс" }

class Impl4 : Base22(), Mixin {
    override fun f() = "${super<Base22>.f()} + ${super<Mixin>.f()}"
}

fun main() { println(Impl4().f()) }     // класс + интерфейс
```
Подробнее: [Интерфейсы](Интерфейсы.md)

## Что можно переопределять
| Член | Условие |
|---|---|
| метод | `open` или `abstract` |
| `val` | `open` или `abstract`; можно расширить до `var` |
| `var` | `open` или `abstract`; сузить до `val` нельзя |
| свойство в конструкторе | `override val` в параметре |

```kotlin
abstract class Base23 {
    abstract val size: Int
    abstract var label: String
    abstract fun compute(): Int
}

class Impl5(override var label: String, private val items: List<Int>) : Base23() {
    override val size get() = items.size
    override fun compute() = items.sum()
}

fun main() {
    val i = Impl5("данные", listOf(1, 2, 3))
    println("${i.label} ${i.size} ${i.compute()}")    // данные 3 6
}
```

## Ковариантность результата
Переопределение может сузить тип результата:
```kotlin
open class Animal3
class Dog2 : Animal3()

open class Shelter {
    open fun adopt(): Animal3 = Animal3()
}

class DogShelter : Shelter() {
    override fun adopt(): Dog2 = Dog2()       // Dog2 — подтип Animal3
}

fun main() {
    val s: Shelter = DogShelter()
    println(s.adopt()::class.simpleName)      // Dog2
}
```
Это безопасно: клиент ожидает `Animal3`, а получает `Dog2`, который им является.

Параметры сузить нельзя - это сломало бы контракт:
```kotlin
open class Base24 {
    open fun process(x: Any) = "any: $x"
}

class Derived24 : Base24() {
    override fun process(x: Any) = "переопределено: $x"
    fun process(x: String) = "перегрузка: $x"       // это перегрузка, не override
}

fun main() {
    val d = Derived24()
    println(d.process("текст"))                      // перегрузка: текст
    println((d as Base24).process("текст"))          // переопределено: текст
}
```
Вызов зависит от статического типа ссылки - классическая ловушка смешения перегрузки и переопределения.

## Nullability при переопределении
```kotlin
open class Base25 {
    open fun find(id: Int): String? = null
}

class Derived25 : Base25() {
    override fun find(id: Int): String = "найдено $id"     // сузили String? до String
}

fun main() {
    val b: Base25 = Derived25()
    println(b.find(1))      // найдено 1
}
```
Результат можно сделать non-null - это сужение. А параметр, наоборот, можно расширить до nullable:
```kotlin
open class Base26 {
    open fun handle(x: String) = "строка"
}

class Derived26 : Base26() {
    override fun handle(x: String) = "подкласс: $x"
}

fun main() { println(Derived26().handle("a")) }    // подкласс: a
```

## Переопределение equals, hashCode, toString
Члены `Any` открыты всегда:
```kotlin
class Point4(val x: Int, val y: Int) {
    override fun equals(other: Any?) = other is Point4 && other.x == x && other.y == y
    override fun hashCode() = 31 * x + y
    override fun toString() = "($x, $y)"
}

fun main() {
    println(Point4(1, 2))                    // (1, 2)
    println(Point4(1, 2) == Point4(1, 2))    // true
}
```
Подробнее: [equals, hashCode и toString](../Синтаксис%20и%20типы/Базовые%20типы%20ООП/equals,%20hashCode%20и%20toString.md)

## Переопределение и расширения
Функция-расширение **не** переопределяется - она разрешается статически, по типу ссылки:
```kotlin
open class Base27
class Derived27 : Base27()

fun Base27.describe() = "база"
fun Derived27.describe() = "подкласс"

fun main() {
    val d: Base27 = Derived27()
    println(d.describe())             // база — по типу переменной!
    println(Derived27().describe())    // подкласс
}
```
Это принципиальное отличие от методов. Если нужен полиморфизм - нужен метод класса. Подробнее: [Функции-расширения](../Функциональный%20Kotlin/Функции-расширения.md)

Расширение не может скрыть метод с той же сигнатурой: метод всегда побеждает.
```kotlin
class Service13 {
    fun run2() = "метод"
}

fun Service13.run2() = "расширение"     // никогда не вызовется

fun main() { println(Service13().run2()) }    // метод
```

> [!info] Отличия от Java
> | Java | Kotlin |
> |---|---|
> | `@Override` опциональна | `override` обязательно |
> | метод виртуален, `final` закрывает | нужен `open`, иначе финален |
> | переопределённый метод остаётся виртуальным | то же, закрывается `final override` |
> | `super.method()` | то же |
> | `A.super.method()` при конфликте | `super<A>.method()` |
> | поля скрываются | свойства переопределяются |
> | ковариантный результат (Java 5+) | то же |
>
> **Обязательный `override`** - главное практическое улучшение. В Java `@Override` необязательна, поэтому опечатка в имени тихо создаёт новый метод, который никогда не вызовется.
>
> **Конфликт реализаций интерфейсов** решается похоже, но синтаксис другой: `A.super.f()` в Java против `super<A>.f()` в Kotlin. Требование явно разрешать конфликт одинаково строгое в обоих языках.
>
> **Сокрытие полей** - проблема Java, которой в Kotlin нет. Поле подкласса с тем же именем скрывает поле базового класса, и какое из них увидит код, зависит от типа ссылки:
> ```java
> class Base { int value = 1; }
> class Derived extends Base { int value = 2; }
> Base b = new Derived();
> // b.value == 1, ((Derived) b).value == 2
> ```
> В Kotlin свойства - это методы доступа, поэтому `override` работает полиморфно.
>
> **Статические методы в Java не переопределяются, а скрываются.** В Kotlin статики нет; члены `companion object` тоже не переопределяются, но путаницы меньше, потому что компаньон не наследуется.
>
> Сравнить: [Переопределение в Java](../../Программирование%20на%20Java/ООП/Наследование/Переопределение.md), [Сокрытие](../../Программирование%20на%20Java/ООП/Наследование/Сокрытие.md), [Ad-hoc полиморфизм](../../Программирование%20на%20Java/ООП/Полиморфизм/Ad-hoc%20(перегрузка).md)

> [!warning] Подводные камни
> **Расширение не переопределяется** - выбор идёт по статическому типу. Это самая частая ошибка ожиданий:
> ```kotlin
> open class Base28
> class Derived28 : Base28()
>
> fun Base28.name() = "база"
> fun Derived28.name() = "подкласс"
>
> fun main() {
>     val list: List<Base28> = listOf(Derived28())
>     println(list[0].name())      // база — не "подкласс"
> }
> ```
>
> **Перегрузка вместо переопределения компилируется молча:**
> ```kotlin
> open class Base29 { open fun f(x: Any) = "any" }
> class Derived29 : Base29() {
>     override fun f(x: Any) = "override"
>     fun f(x: Int) = "overload"
> }
>
> fun main() {
>     val d = Derived29()
>     println(d.f(1))                   // overload — точнее по типу
>     println((d as Base29).f(1))       // override — по типу ссылки
> }
> ```
>
> **Вызов `open`-метода из конструктора попадает в подкласс до его инициализации.** Подробнее: [Инициализация](Инициализация.md)
>
> **`super` в лямбде внутри метода работает, а в объекте-выражении - относится к нему:**
> ```kotlin
> open class Base30 { open fun f() = "база" }
>
> class Derived30 : Base30() {
>     override fun f() = "подкласс"
>     fun test(): String {
>         val fromLambda = listOf(1).map { super.f() }.first()     // база
>         return fromLambda
>     }
> }
>
> fun main() { println(Derived30().test()) }    // база
> ```
>
> **Переопределение `equals` без `hashCode` ломает хеш-коллекции.** Компилятор не предупреждает.
>
> **Сужение видимости при переопределении запрещено**, а расширение - разрешено и легко делается случайно: `public override` у `protected`-метода публикует внутреннюю деталь.
>
> **Делегат свойства не наследуется.** Переопределяя `val x by lazy { }`, подкласс должен задать своё хранилище - делегат базового класса не переиспользуется:
> ```kotlin
> open class Base31 {
>     open val value: String by lazy { "база" }
> }
>
> class Derived31 : Base31() {
>     override val value: String by lazy { "подкласс" }     // свой делегат
> }
>
> fun main() { println(Derived31().value) }    // подкласс
> ```

Дополнительно: [Полиморфизм](Полиморфизм.md)
Далее: [Абстрактные классы](Абстрактные%20классы.md)