308 lines
14 KiB
Markdown
308 lines
14 KiB
Markdown
---
|
||
title: Наследование
|
||
description: open, вызов конструктора базового класса, наследование свойств и выбор в пользу композиции
|
||
tags:
|
||
- kotlin
|
||
- oop
|
||
---
|
||
|
||
Класс закрыт для наследования, пока не объявлен `open`.
|
||
|
||
```kotlin
|
||
open class Animal(val name: String) {
|
||
open fun sound() = "..."
|
||
fun describe() = "$name говорит ${sound()}" // final: переопределить нельзя
|
||
}
|
||
|
||
class Dog(name: String) : Animal(name) {
|
||
override fun sound() = "Гав"
|
||
}
|
||
|
||
fun main() {
|
||
println(Dog("Рекс").describe()) // Рекс говорит Гав
|
||
}
|
||
```
|
||
`describe()` не `open`, но вызывает `sound()`, который переопределён - это и есть полиморфизм: шаблон поведения в базовом классе, детали в подклассе.
|
||
|
||
## Вызов конструктора базового класса
|
||
Указывается в заголовке:
|
||
```kotlin
|
||
open class Base12(val id: Int)
|
||
|
||
class Derived12(id: Int, val name: String) : Base12(id)
|
||
|
||
fun main() {
|
||
val d = Derived12(1, "Иван")
|
||
println("${d.id} ${d.name}") // 1 Иван
|
||
}
|
||
```
|
||
Аргументы можно вычислять:
|
||
```kotlin
|
||
open class Shape2(val area: Double)
|
||
|
||
class Circle2(val radius: Double) : Shape2(Math.PI * radius * radius)
|
||
|
||
fun main() {
|
||
println("%.2f".format(java.util.Locale.US, Circle2(1.0).area)) // 3.14
|
||
}
|
||
```
|
||
|
||
Если у подкласса нет основного конструктора, базовый вызывается из каждого вторичного через `super`:
|
||
```kotlin
|
||
open class Base13(val source: String)
|
||
|
||
class Derived13 : Base13 {
|
||
constructor(file: java.io.File) : super("файл ${file.name}")
|
||
constructor(url: String, port: Int) : super("$url:$port")
|
||
}
|
||
|
||
fun main() {
|
||
println(Derived13("http://x.ru", 80).source) // http://x.ru:80
|
||
}
|
||
```
|
||
|
||
Скобки в заголовке обязательны, даже если конструктор без параметров:
|
||
```kotlin
|
||
open class Base14
|
||
class Derived14 : Base14() // скобки = вызов конструктора
|
||
|
||
interface Marker2
|
||
class Impl3 : Marker2 // у интерфейса скобок нет
|
||
|
||
fun main() { println(Derived14()::class.simpleName) } // Derived14
|
||
```
|
||
Наличие скобок различает класс и интерфейс в списке супертипов.
|
||
|
||
## Что можно наследовать
|
||
```kotlin
|
||
open class Base15 {
|
||
open val version: Int = 1
|
||
open var state: String = "новый"
|
||
open fun run2() = "база"
|
||
val fixed = "не переопределить" // не open
|
||
}
|
||
|
||
class Derived15 : Base15() {
|
||
override val version = 2
|
||
override var state: String = "изменённый"
|
||
override fun run2() = "подкласс"
|
||
}
|
||
|
||
fun main() {
|
||
val d: Base15 = Derived15()
|
||
println("${d.version} ${d.state} ${d.run2()} ${d.fixed}")
|
||
// 2 изменённый подкласс не переопределить
|
||
}
|
||
```
|
||
`open` нужен каждому члену отдельно: открытый класс не делает своих членов открытыми.
|
||
|
||
### val можно переопределить как var
|
||
```kotlin
|
||
open class Base16 {
|
||
open val value: Int = 1
|
||
}
|
||
|
||
class Derived16 : Base16() {
|
||
override var value: Int = 2 // добавили сеттер
|
||
}
|
||
|
||
fun main() {
|
||
val d = Derived16()
|
||
d.value = 5
|
||
println(d.value) // 5
|
||
}
|
||
```
|
||
Обратное запрещено: `var` нельзя сузить до `val` - это сломало бы код, который присваивает значение.
|
||
|
||
### Переопределение свойства геттером
|
||
```kotlin
|
||
open class Base17 {
|
||
open val size: Int = 0
|
||
}
|
||
|
||
class Derived17(private val items: List<Int>) : Base17() {
|
||
override val size: Int get() = items.size // вычисляемое вместо хранимого
|
||
}
|
||
|
||
fun main() {
|
||
println(Derived17(listOf(1, 2, 3)).size) // 3
|
||
}
|
||
```
|
||
|
||
## Свойство в конструкторе подкласса
|
||
```kotlin
|
||
open class Base18 {
|
||
open val name: String = "базовое"
|
||
}
|
||
|
||
class Derived18(override val name: String) : Base18()
|
||
|
||
fun main() {
|
||
println(Derived18("своё").name) // своё
|
||
}
|
||
```
|
||
`override` прямо в параметре конструктора - короткая и частая форма.
|
||
|
||
## Абстрактный член не требует open
|
||
```kotlin
|
||
abstract class Shape3 {
|
||
abstract val area: Double // open подразумевается
|
||
abstract fun describe(): String
|
||
open fun show() = "фигура: ${describe()}"
|
||
}
|
||
|
||
class Square2(val side: Double) : Shape3() {
|
||
override val area get() = side * side
|
||
override fun describe() = "квадрат со стороной $side"
|
||
}
|
||
|
||
fun main() {
|
||
println(Square2(2.0).show()) // фигура: квадрат со стороной 2.0
|
||
}
|
||
```
|
||
Подробнее: [Абстрактные классы](Абстрактные%20классы.md)
|
||
|
||
## Одиночное наследование, множественные интерфейсы
|
||
```kotlin
|
||
open class Entity(val id: Int)
|
||
interface Serializable2 { fun serialize(): String }
|
||
interface Validatable { fun validate(): Boolean }
|
||
|
||
class User4(id: Int, val name: String) : Entity(id), Serializable2, Validatable {
|
||
override fun serialize() = """{"id":$id,"name":"$name"}"""
|
||
override fun validate() = name.isNotBlank()
|
||
}
|
||
|
||
fun main() {
|
||
val u = User4(1, "Иван")
|
||
println(u.serialize()) // {"id":1,"name":"Иван"}
|
||
println(u.validate()) // true
|
||
}
|
||
```
|
||
Класс в списке супертипов идёт первым - это соглашение, а не требование компилятора.
|
||
|
||
## Что наследовать нельзя
|
||
```kotlin
|
||
class Final2 // закрыт по умолчанию
|
||
data class Point3(val x: Int) // data class не может быть open
|
||
@JvmInline value class Id2(val value: Int) // value class тоже
|
||
object Singleton2 // object
|
||
enum class Status2 { OK } // enum
|
||
sealed class Limited // только в своём модуле и пакете
|
||
|
||
fun main() { println("перечислены закрытые формы") }
|
||
```
|
||
Для `enum` есть исключение: отдельная константа может переопределить метод, образуя анонимный подкласс. Подробнее: [Enum class](../Синтаксис%20и%20типы/Базовые%20типы%20ООП/Enum%20class.md)
|
||
|
||
## Композиция вместо наследования
|
||
Наследование связывает подкласс с реализацией базового класса. Изменение базового класса может сломать подкласс, даже если публичный контракт не менялся - это проблема хрупкого базового класса.
|
||
|
||
Классический пример - подсчёт добавленных элементов:
|
||
```kotlin
|
||
// плохо: наследование от реализации
|
||
class CountingList<T> : ArrayList<T>() {
|
||
var added = 0
|
||
override fun add(element: T): Boolean {
|
||
added++
|
||
return super.add(element)
|
||
}
|
||
override fun addAll(elements: Collection<T>): Boolean {
|
||
added += elements.size
|
||
return super.addAll(elements) // внутри может вызвать add()!
|
||
}
|
||
}
|
||
|
||
fun main() {
|
||
val list = CountingList<Int>()
|
||
list.addAll(listOf(1, 2, 3))
|
||
println("добавлено: ${list.added}, реально: ${list.size}")
|
||
}
|
||
```
|
||
На текущем JDK выведется `добавлено: 3, реально: 3` - потому что `ArrayList.addAll` копирует массив напрямую и `add` не вызывает. Но это не гарантия: реализация, которая реализует `addAll` через цикл с `add`, удвоит счётчик. Корректность класса зависит от внутренностей базового, а они не входят в его контракт и могут измениться между версиями JDK.
|
||
|
||
Композиция такой зависимости не создаёт:
|
||
```kotlin
|
||
class CountingList2<T> {
|
||
private val items = mutableListOf<T>()
|
||
var added = 0
|
||
private set
|
||
|
||
fun add(element: T) { added++; items.add(element) }
|
||
fun addAll(elements: Collection<T>) { elements.forEach { add(it) } }
|
||
val size: Int get() = items.size
|
||
}
|
||
|
||
fun main() {
|
||
val list = CountingList2<Int>()
|
||
list.addAll(listOf(1, 2, 3))
|
||
println("добавлено: ${list.added}, реально: ${list.size}") // 3, 3
|
||
}
|
||
```
|
||
Kotlin делает композицию такой же короткой, как наследование, - через делегирование `by`. Подробнее: [Делегирование](Делегирование.md)
|
||
|
||
> [!info] Отличия от Java
|
||
> | Java | Kotlin |
|
||
> |---|---|
|
||
> | `class A extends B` | `class A : B()` |
|
||
> | `implements I` | та же запись через запятую |
|
||
> | класс открыт, `final` закрывает | закрыт, `open` открывает |
|
||
> | метод виртуален по умолчанию | финален по умолчанию |
|
||
> | `super(args)` первой строкой тела | `: Base(args)` в заголовке |
|
||
> | `@Override` опциональна | `override` обязательно |
|
||
> | нельзя переопределить поле | свойство переопределяется |
|
||
>
|
||
> **Закрытость по умолчанию - осознанный выбор.** Проектировать класс под наследование дорого: нужно документировать, какие методы вызывают какие, и поддерживать это между версиями. Java по умолчанию делает всё наследуемым, из-за чего библиотечные классы либо получают `final`, либо навсегда остаются связанными своими внутренностями.
|
||
>
|
||
> **Переопределение свойств** в Java невозможно - поля скрываются, а не переопределяются:
|
||
> ```java
|
||
> class Base { int value = 1; }
|
||
> class Derived extends Base { int value = 2; } // сокрытие, не переопределение
|
||
> // ((Base) new Derived()).value == 1
|
||
> ```
|
||
> Обращение по ссылке базового типа даст поле базового класса. В Kotlin свойство - это методы доступа, поэтому `override` работает полиморфно и такой ловушки нет.
|
||
>
|
||
> Сравнить: [Наследование в Java](../../Программирование%20на%20Java/ООП/Наследование/Наследование.md), [Сокрытие](../../Программирование%20на%20Java/ООП/Наследование/Сокрытие.md)
|
||
|
||
> [!warning] Подводные камни
|
||
> **`open` у класса не открывает его члены** - каждый метод и свойство нужно помечать отдельно.
|
||
>
|
||
> **Переопределённый метод остаётся `open`.** Чтобы закрыть ветку иерархии, нужен `final override`:
|
||
> ```kotlin
|
||
> open class A4 { open fun f() = "A" }
|
||
> open class B4 : A4() { final override fun f() = "B" }
|
||
> // class C4 : B4() { override fun f() = "C" } // ошибка: f закрыт
|
||
>
|
||
> fun main() { println(B4().f()) } // B
|
||
> ```
|
||
>
|
||
> **Вызов `open`-метода из конструктора видит неинициализированный подкласс:**
|
||
> ```kotlin
|
||
> open class Base19 {
|
||
> init { println("из init: ${describe()}") }
|
||
> open fun describe() = "база"
|
||
> }
|
||
>
|
||
> class Derived19 : Base19() {
|
||
> private val name: String = "Иван"
|
||
> override fun describe() = "подкласс, name=$name"
|
||
> }
|
||
>
|
||
> fun main() { Derived19() } // из init: подкласс, name=null
|
||
> ```
|
||
> Подробнее: [Инициализация](Инициализация.md)
|
||
>
|
||
> **Скобки обязательны при наследовании класса**: `: Base()`, а не `: Base`. Без скобок компилятор ищет интерфейс.
|
||
>
|
||
> **`protected` в Kotlin не даёт доступа из пакета** - только из подклассов. Код, перенесённый из Java, может перестать компилироваться.
|
||
>
|
||
> **`var` нельзя переопределить как `val`** - только наоборот.
|
||
>
|
||
> **Наследование от классов стандартной библиотеки хрупко.** `ArrayList`, `HashMap` и подобные не документируют, какие методы вызывают друг друга внутри. Используйте делегирование.
|
||
>
|
||
> **Глубокие иерархии трудно читать.** Чтобы понять поведение класса в иерархии из пяти уровней, нужно просмотреть все пять. Практическое правило: наследование - для «является» и когда базовый класс спроектирован под него; во всех остальных случаях - композиция.
|
||
>
|
||
> **Нельзя наследоваться от `data class`**, поэтому иерархии носителей данных строят на `sealed`-интерфейсах с `data class`-реализациями.
|
||
|
||
Дополнительно: [Переопределение](Переопределение.md)
|
||
Далее: [Переопределение](Переопределение.md)
|