326 lines
16 KiB
Markdown
326 lines
16 KiB
Markdown
---
|
||
title: Полиморфизм
|
||
description: Полиморфизм подтипов, перегрузка, параметрический полиморфизм и что разрешается статически
|
||
tags:
|
||
- kotlin
|
||
- oop
|
||
---
|
||
|
||
Полиморфизм - возможность работать с разными типами через один интерфейс. В Kotlin четыре формы:
|
||
|
||
| Форма | Механизм | Когда выбирается реализация |
|
||
|---|---|---|
|
||
| подтипов | `override` | в рантайме, по фактическому типу |
|
||
| ad-hoc (перегрузка) | одно имя, разные параметры | при компиляции |
|
||
| параметрический | дженерики | при компиляции (типы стираются) |
|
||
| через `when` по sealed | сопоставление типов | в рантайме, но проверяется компилятором |
|
||
|
||
## Полиморфизм подтипов
|
||
```kotlin
|
||
interface Shape5 {
|
||
fun area(): Double
|
||
fun name(): String
|
||
}
|
||
|
||
class Circle5(val r: Double) : Shape5 {
|
||
override fun area() = Math.PI * r * r
|
||
override fun name() = "круг"
|
||
}
|
||
|
||
class Square4(val side: Double) : Shape5 {
|
||
override fun area() = side * side
|
||
override fun name() = "квадрат"
|
||
}
|
||
|
||
fun describe(s: Shape5) = "${s.name()}: %.2f".format(java.util.Locale.US, s.area())
|
||
|
||
fun main() {
|
||
val shapes: List<Shape5> = listOf(Circle5(1.0), Square4(2.0))
|
||
shapes.forEach { println(describe(it)) }
|
||
// круг: 3.14
|
||
// квадрат: 4.00
|
||
println(shapes.sumOf { it.area() } > 7) // true
|
||
}
|
||
```
|
||
Функция `describe` написана один раз и работает с любым `Shape5`, включая те, которые появятся позже. Выбор реализации происходит в рантайме по фактическому типу объекта - это динамическая диспетчеризация.
|
||
|
||
## Перегрузка
|
||
Одно имя, разные параметры. Выбор - при компиляции, по статическим типам аргументов:
|
||
```kotlin
|
||
fun format2(value: Int) = "целое: $value"
|
||
fun format2(value: Double) = "дробное: $value"
|
||
fun format2(value: String) = "строка: '$value'"
|
||
fun format2(value: Any?) = "что-то: $value"
|
||
|
||
fun main() {
|
||
println(format2(1)) // целое: 1
|
||
println(format2(1.0)) // дробное: 1.0
|
||
println(format2("текст")) // строка: 'текст'
|
||
println(format2(listOf(1))) // что-то: [1]
|
||
|
||
val x: Any = 1 // статический тип Any!
|
||
println(format2(x)) // что-то: 1 — не "целое: 1"
|
||
}
|
||
```
|
||
Последняя строка показывает суть: компилятор видит тип переменной, а не объекта. Это основное отличие от полиморфизма подтипов.
|
||
|
||
В Kotlin перегрузка нужна реже - её заменяют значения по умолчанию:
|
||
```kotlin
|
||
fun connect(host: String, port: Int = 8080, secure: Boolean = false) =
|
||
"$host:$port secure=$secure"
|
||
|
||
fun main() {
|
||
println(connect("localhost")) // localhost:8080 secure=false
|
||
println(connect("localhost", secure = true)) // localhost:8080 secure=true
|
||
}
|
||
```
|
||
Подробнее: [Функции](../Синтаксис%20и%20типы/Работа%20с%20данными/Функции.md)
|
||
|
||
## Параметрический полиморфизм
|
||
Один код для любого типа:
|
||
```kotlin
|
||
fun <T> firstOrDefault(items: List<T>, default: T): T =
|
||
if (items.isEmpty()) default else items[0]
|
||
|
||
class Box4<T>(private val value: T) {
|
||
fun get(): T = value
|
||
fun <R> map(f: (T) -> R): Box4<R> = Box4(f(value))
|
||
}
|
||
|
||
fun main() {
|
||
println(firstOrDefault(listOf(1, 2), 0)) // 1
|
||
println(firstOrDefault(emptyList(), "нет")) // нет
|
||
println(Box4(5).map { it * 2 }.get()) // 10
|
||
}
|
||
```
|
||
Ограничение параметра типа позволяет вызывать методы:
|
||
```kotlin
|
||
fun <T : Comparable<T>> maxOf2(a: T, b: T): T = if (a > b) a else b
|
||
|
||
fun main() {
|
||
println(maxOf2(3, 7)) // 7
|
||
println(maxOf2("abc", "abd")) // abd
|
||
}
|
||
```
|
||
Подробнее: [Параметрический полиморфизм](../Дженерики/Параметрический%20полиморфизм.md)
|
||
|
||
## Полиморфизм через sealed и when
|
||
```kotlin
|
||
sealed interface Payment {
|
||
data class Card(val number: String) : Payment
|
||
data class Cash(val amount: Long) : Payment
|
||
data object Invoice : Payment
|
||
}
|
||
|
||
fun process2(p: Payment): String = when (p) {
|
||
is Payment.Card -> "карта ****${p.number.takeLast(4)}"
|
||
is Payment.Cash -> "наличные ${p.amount}"
|
||
Payment.Invoice -> "счёт"
|
||
}
|
||
|
||
fun main() {
|
||
println(process2(Payment.Card("1234567890123456"))) // карта ****3456
|
||
println(process2(Payment.Cash(500))) // наличные 500
|
||
println(process2(Payment.Invoice)) // счёт
|
||
}
|
||
```
|
||
Это альтернатива полиморфизму подтипов с обратным распределением ответственности:
|
||
|
||
| | метод в классе | `when` по sealed |
|
||
|---|---|---|
|
||
| добавить новый тип | правок в одном месте | компилятор найдёт все `when` |
|
||
| добавить новую операцию | правка во всех классах | один новый `when` |
|
||
| логика операции | размазана по классам | собрана в одном месте |
|
||
|
||
Выбор зависит от того, что меняется чаще. Набор типов стабилен, а операций много - `sealed` + `when`. Операции стабильны, а типы добавляются - методы в классах.
|
||
|
||
Подробнее: [Sealed class и interface](../Синтаксис%20и%20типы/Базовые%20типы%20ООП/Sealed%20class%20и%20interface.md)
|
||
|
||
## Что разрешается статически
|
||
Это главный источник ошибок ожиданий. Статически (по типу ссылки, а не объекта) выбираются:
|
||
|
||
**Функции-расширения:**
|
||
```kotlin
|
||
open class Base37
|
||
class Derived33 : Base37()
|
||
|
||
fun Base37.describe() = "база"
|
||
fun Derived33.describe() = "подкласс"
|
||
|
||
fun main() {
|
||
val d: Base37 = Derived33()
|
||
println(d.describe()) // база — по типу переменной!
|
||
println(Derived33().describe()) // подкласс
|
||
}
|
||
```
|
||
|
||
**Перегруженные функции:**
|
||
```kotlin
|
||
open class Animal4
|
||
class Dog3 : Animal4()
|
||
|
||
fun feed(a: Animal4) = "корм для животного"
|
||
fun feed(d: Dog3) = "корм для собаки"
|
||
|
||
fun main() {
|
||
val a: Animal4 = Dog3()
|
||
println(feed(a)) // корм для животного
|
||
println(feed(Dog3())) // корм для собаки
|
||
}
|
||
```
|
||
|
||
**Члены `companion object`** - они не переопределяются:
|
||
```kotlin
|
||
open class Base38 {
|
||
companion object { fun create() = "из Base" }
|
||
}
|
||
|
||
class Derived34 : Base38() {
|
||
companion object { fun create() = "из Derived" }
|
||
}
|
||
|
||
fun main() {
|
||
println(Base38.create()) // из Base
|
||
println(Derived34.create()) // из Derived — выбор по имени класса
|
||
}
|
||
```
|
||
|
||
Динамически выбираются только **члены класса**, помеченные `open`/`abstract` и переопределённые через `override`.
|
||
|
||
## Приведение и проверка типа
|
||
```kotlin
|
||
fun handle(x: Any): String = when (x) {
|
||
is String -> "строка длины ${x.length}" // умное приведение
|
||
is Int -> "число ${x + 1}"
|
||
is List<*> -> "список из ${x.size}"
|
||
else -> "неизвестно: ${x::class.simpleName}"
|
||
}
|
||
|
||
fun main() {
|
||
println(handle("abc")) // строка длины 3
|
||
println(handle(5)) // число 6
|
||
println(handle(listOf(1, 2))) // список из 2
|
||
println(handle(1.0)) // неизвестно: Double
|
||
}
|
||
```
|
||
Длинная цепочка `is` часто означает, что иерархия просит `sealed`-типа или полиморфного метода. Подробнее: [Приведение типов](../Синтаксис%20и%20типы/Работа%20с%20данными/Приведение%20типов.md)
|
||
|
||
## Вариантность
|
||
Полиморфизм распространяется на дженерики через `out` и `in`:
|
||
```kotlin
|
||
open class Animal5(val name: String)
|
||
class Dog4(name: String) : Animal5(name)
|
||
|
||
fun printAll(animals: List<Animal5>) = animals.joinToString { it.name }
|
||
|
||
fun main() {
|
||
val dogs: List<Dog4> = listOf(Dog4("Рекс"), Dog4("Бобик"))
|
||
println(printAll(dogs)) // Рекс, Бобик — List<Dog4> подходит как List<Animal5>
|
||
}
|
||
```
|
||
Это работает, потому что `List<out E>` ковариантен. С `MutableList` так нельзя - он инвариантен. Подробнее: [Вариантность](../Дженерики/Вариантность.md)
|
||
|
||
> [!info] Отличия от Java
|
||
> | Java | Kotlin |
|
||
> |---|---|
|
||
> | метод виртуален по умолчанию | нужен `open` |
|
||
> | `@Override` опциональна | `override` обязательно |
|
||
> | перегрузка для опциональных параметров | значения по умолчанию |
|
||
> | `instanceof` + каст | `is` + умное приведение |
|
||
> | `switch` с pattern matching (Java 21) | `when` с `is` |
|
||
> | Visitor для операций над иерархией | `sealed` + `when` |
|
||
> | статические методы скрываются | члены компаньона не наследуются |
|
||
>
|
||
> **Механика полиморфизма подтипов идентична** - это та же виртуальная диспетчеризация JVM. Отличается значение по умолчанию: в Kotlin метод финален, пока не помечен `open`.
|
||
>
|
||
> **Visitor почти не нужен.** В Java для добавления операций к закрытой иерархии без правки классов применяют паттерн Visitor: интерфейс с методом на каждый тип, метод `accept` в каждом классе. `sealed` + `when` даёт ту же проверку полноты компилятором, но без дополнительного кода:
|
||
> ```kotlin
|
||
> sealed interface Expr2 {
|
||
> data class Num2(val value: Int) : Expr2
|
||
> data class Add2(val l: Expr2, val r: Expr2) : Expr2
|
||
> }
|
||
>
|
||
> fun eval(e: Expr2): Int = when (e) {
|
||
> is Expr2.Num2 -> e.value
|
||
> is Expr2.Add2 -> eval(e.l) + eval(e.r)
|
||
> }
|
||
>
|
||
> fun show(e: Expr2): String = when (e) { // новая операция — один when
|
||
> is Expr2.Num2 -> "${e.value}"
|
||
> is Expr2.Add2 -> "(${show(e.l)} + ${show(e.r)})"
|
||
> }
|
||
>
|
||
> fun main() {
|
||
> val expr = Expr2.Add2(Expr2.Num2(1), Expr2.Num2(2))
|
||
> println("${show(expr)} = ${eval(expr)}") // (1 + 2) = 3
|
||
> }
|
||
> ```
|
||
>
|
||
> **Умное приведение убирает двойную работу.** В Java после `instanceof` нужен явный каст (до версии 16, где появился pattern matching).
|
||
>
|
||
> Сравнить: [Полиморфизм в Java](../../Программирование%20на%20Java/ООП/Полиморфизм/Полиморфизм.md), [Полиморфизм подтипов](../../Программирование%20на%20Java/ООП/Полиморфизм/Полиморфизм%20подтипов.md), [Ad-hoc полиморфизм](../../Программирование%20на%20Java/ООП/Полиморфизм/Ad-hoc%20(перегрузка).md)
|
||
|
||
> [!warning] Подводные камни
|
||
> **Расширения не полиморфны** - выбор по статическому типу. Это самая частая ошибка:
|
||
> ```kotlin
|
||
> open class Base39
|
||
> class Derived35 : Base39()
|
||
>
|
||
> fun Base39.name() = "база"
|
||
> fun Derived35.name() = "подкласс"
|
||
>
|
||
> fun main() {
|
||
> println(listOf<Base39>(Derived35()).first().name()) // база
|
||
> }
|
||
> ```
|
||
> Нужен полиморфизм - нужен член класса.
|
||
>
|
||
> **Перегрузка выбирается по типу ссылки, а не объекта.** Код ведёт себя по-разному в зависимости от того, как объявлена переменная.
|
||
>
|
||
> **Смешение перегрузки и переопределения даёт неочевидный результат:**
|
||
> ```kotlin
|
||
> open class Base40 { open fun f(x: Any) = "any" }
|
||
> class Derived36 : Base40() {
|
||
> override fun f(x: Any) = "override"
|
||
> fun f(x: Int) = "overload"
|
||
> }
|
||
>
|
||
> fun main() {
|
||
> val d = Derived36()
|
||
> println(d.f(1)) // overload
|
||
> println((d as Base40).f(1)) // override
|
||
> }
|
||
> ```
|
||
>
|
||
> **Вызов `open`-метода из конструктора попадает в подкласс до его инициализации.** Подробнее: [Инициализация](Инициализация.md)
|
||
>
|
||
> **Стирание типов ломает перегрузку по дженерикам:**
|
||
> ```kotlin
|
||
> // fun show(items: List<String>) = "строки"
|
||
> // fun show(items: List<Int>) = "числа" // ошибка: та же JVM-сигнатура
|
||
>
|
||
> @JvmName("showStrings")
|
||
> fun show2(items: List<String>) = "строки: ${items.size}"
|
||
> fun show2(items: List<Int>) = "числа: ${items.size}"
|
||
>
|
||
> fun main() { println(show2(listOf("a"))) } // строки: 1
|
||
> ```
|
||
> Обойти можно через `@JvmName`, но обычно это признак, что нужен один дженерик-метод.
|
||
>
|
||
> **Длинная цепочка `is` вместо полиморфизма.** Если `when (x) { is A -> ...; is B -> ... }` повторяется в нескольких местах, логику стоит перенести в методы типов или закрыть иерархию через `sealed`, чтобы компилятор контролировал полноту.
|
||
>
|
||
> **Члены `companion object` не переопределяются.** Попытка «переопределить» фабрику в подклассе создаёт независимый компаньон; вызов `Derived.create()` работает только потому, что имя разрешается статически.
|
||
>
|
||
> **Массивы инвариантны, а `List` ковариантен** - в отличие от Java, где массивы ковариантны и могут бросить `ArrayStoreException`:
|
||
> ```kotlin
|
||
> fun main() {
|
||
> val strings: List<String> = listOf("a")
|
||
> val anys: List<Any> = strings // ok
|
||
> println(anys.size) // 1
|
||
> // val arr: Array<Any> = arrayOf("a") // ошибка компиляции
|
||
> }
|
||
> ```
|
||
|
||
Дополнительно: [Переопределение](Переопределение.md)
|
||
Далее: [Система исключений](../Исключения/Система%20исключений.md)
|