307 lines
13 KiB
Markdown
307 lines
13 KiB
Markdown
---
|
||
title: Абстрактные классы
|
||
description: abstract против open, шаблонный метод и выбор между абстрактным классом и интерфейсом
|
||
tags:
|
||
- kotlin
|
||
- oop
|
||
---
|
||
|
||
Абстрактный класс нельзя создать - только унаследовать.
|
||
|
||
```kotlin
|
||
abstract class Shape4 {
|
||
abstract val area: Double // без реализации
|
||
abstract fun name(): String
|
||
|
||
fun describe() = "${name()}: площадь %.2f".format(java.util.Locale.US, area)
|
||
}
|
||
|
||
class Circle3(val radius: Double) : Shape4() {
|
||
override val area get() = Math.PI * radius * radius
|
||
override fun name() = "круг"
|
||
}
|
||
|
||
class Square3(val side: Double) : Shape4() {
|
||
override val area get() = side * side
|
||
override fun name() = "квадрат"
|
||
}
|
||
|
||
fun main() {
|
||
val shapes = listOf(Circle3(1.0), Square3(2.0))
|
||
shapes.forEach { println(it.describe()) }
|
||
// круг: площадь 3.14
|
||
// квадрат: площадь 4.00
|
||
// println(Shape4()) // ошибка: нельзя создать абстрактный класс
|
||
}
|
||
```
|
||
|
||
## abstract и open
|
||
`abstract` подразумевает `open` - писать его не нужно:
|
||
```kotlin
|
||
abstract class Base32 {
|
||
abstract fun required() // open не нужен, реализации нет
|
||
open fun optional() = "по умолчанию" // есть реализация, но переопределяема
|
||
fun fixed() = "не переопределить" // final
|
||
}
|
||
|
||
class Impl6 : Base32() {
|
||
override fun required() = Unit
|
||
override fun optional() = "своё"
|
||
}
|
||
|
||
fun main() {
|
||
val i = Impl6()
|
||
println("${i.optional()} / ${i.fixed()}") // своё / не переопределить
|
||
}
|
||
```
|
||
|
||
| Модификатор | Реализация | Нужно переопределять |
|
||
|---|---|---|
|
||
| `abstract` | нет | обязательно |
|
||
| `open` | есть | можно |
|
||
| нет модификатора | есть | нельзя |
|
||
|
||
Абстрактный класс может не иметь ни одного абстрактного члена - тогда он просто запрещает создание экземпляра:
|
||
```kotlin
|
||
abstract class Utils {
|
||
fun helper() = "общая логика"
|
||
}
|
||
|
||
class Concrete : Utils()
|
||
|
||
fun main() { println(Concrete().helper()) } // общая логика
|
||
```
|
||
|
||
## Абстрактный класс может иметь состояние
|
||
Это главное отличие от интерфейса:
|
||
```kotlin
|
||
abstract class Repository2(protected val tableName: String) {
|
||
private val cache = mutableMapOf<Int, String>() // состояние
|
||
|
||
protected abstract fun loadFromDb(id: Int): String?
|
||
|
||
fun find(id: Int): String? = cache.getOrPut(id) {
|
||
loadFromDb(id) ?: return null
|
||
}
|
||
|
||
fun cacheSize() = cache.size
|
||
}
|
||
|
||
class UserRepository2 : Repository2("users") {
|
||
override fun loadFromDb(id: Int) = if (id == 1) "Иван" else null
|
||
}
|
||
|
||
fun main() {
|
||
val repo = UserRepository2()
|
||
println(repo.find(1)) // Иван
|
||
println(repo.find(1)) // Иван — из кеша
|
||
println(repo.cacheSize()) // 1
|
||
println(repo.find(99)) // null
|
||
}
|
||
```
|
||
Конструктор, приватные поля, инициализация - всё доступно. У интерфейса этого нет.
|
||
|
||
## Шаблонный метод
|
||
Самое частое применение: алгоритм зафиксирован в базовом классе, шаги переопределяются.
|
||
```kotlin
|
||
abstract class Importer {
|
||
fun import(data: String): String {
|
||
val parsed = parse(data)
|
||
val valid = parsed.filter { validate(it) }
|
||
return "загружено ${valid.size} из ${parsed.size}: $valid"
|
||
}
|
||
|
||
protected abstract fun parse(data: String): List<String>
|
||
protected open fun validate(item: String) = item.isNotBlank()
|
||
}
|
||
|
||
class CsvImporter : Importer() {
|
||
override fun parse(data: String) = data.split(",").map { it.trim() }
|
||
}
|
||
|
||
class StrictCsvImporter : Importer() {
|
||
override fun parse(data: String) = data.split(",").map { it.trim() }
|
||
override fun validate(item: String) = item.length >= 3
|
||
}
|
||
|
||
fun main() {
|
||
println(CsvImporter().import("a, b, , c"))
|
||
// загружено 3 из 4: [a, b, c]
|
||
println(StrictCsvImporter().import("abc, b, defg"))
|
||
// загружено 2 из 3: [abc, defg]
|
||
}
|
||
```
|
||
`import` не `open` - порядок шагов менять нельзя. `parse` обязателен, `validate` имеет разумное поведение по умолчанию.
|
||
|
||
## protected для членов, нужных подклассам
|
||
```kotlin
|
||
abstract class Connection {
|
||
protected var isOpen = false
|
||
private set
|
||
|
||
protected abstract fun doConnect(): Boolean
|
||
|
||
fun connect(): String {
|
||
isOpen = doConnect()
|
||
return if (isOpen) "подключено" else "ошибка"
|
||
}
|
||
}
|
||
|
||
class TcpConnection(private val host: String) : Connection() {
|
||
override fun doConnect() = host.isNotBlank()
|
||
fun status() = if (isOpen) "$host: активно" else "$host: закрыто"
|
||
}
|
||
|
||
fun main() {
|
||
val c = TcpConnection("example.com")
|
||
println(c.connect()) // подключено
|
||
println(c.status()) // example.com: активно
|
||
}
|
||
```
|
||
|
||
## Абстрактный класс или интерфейс
|
||
```kotlin
|
||
interface Drawable { fun draw(): String } // контракт
|
||
|
||
abstract class Widget(val id: String) : Drawable { // + состояние и общая логика
|
||
protected var visible = true
|
||
fun hide() { visible = false }
|
||
override fun draw() = if (visible) render() else ""
|
||
protected abstract fun render(): String
|
||
}
|
||
|
||
class Button(id: String, val label: String) : Widget(id) {
|
||
override fun render() = "[$label]"
|
||
}
|
||
|
||
fun main() {
|
||
val b = Button("b1", "ОК")
|
||
println(b.draw()) // [ОК]
|
||
b.hide()
|
||
println("'${b.draw()}'") // ''
|
||
}
|
||
```
|
||
|
||
| | Интерфейс | Абстрактный класс |
|
||
|---|---|---|
|
||
| сколько можно реализовать | много | один |
|
||
| состояние (свойство с полем) | нет | да |
|
||
| конструктор | нет | да |
|
||
| `init` | нет | да |
|
||
| `private`-члены | да (с реализацией) | да |
|
||
| `protected`-члены | **нет** | да |
|
||
| видимость членов | только `public` или `private` | любая |
|
||
|
||
Правило выбора:
|
||
- **интерфейс** - когда описываете возможность («умеет рисоваться», «сравним»), особенно если её могут захотеть добавить к существующим классам
|
||
- **абстрактный класс** - когда у наследников общее состояние или нужен шаблонный метод с `protected`-шагами
|
||
|
||
На практике часто сочетают: публичный интерфейс для клиентов и абстрактный класс как база для реализаций.
|
||
|
||
Подробнее: [Интерфейсы](Интерфейсы.md)
|
||
|
||
## Абстрактный класс и sealed
|
||
```kotlin
|
||
sealed class Result4 {
|
||
abstract val isSuccess: Boolean
|
||
}
|
||
|
||
class Ok2(val data: String) : Result4() {
|
||
override val isSuccess = true
|
||
}
|
||
|
||
class Fail(val error: String) : Result4() {
|
||
override val isSuccess = false
|
||
}
|
||
|
||
fun handle(r: Result4) = when (r) { // else не нужен
|
||
is Ok2 -> "данные: ${r.data}"
|
||
is Fail -> "ошибка: ${r.error}"
|
||
}
|
||
|
||
fun main() {
|
||
println(handle(Ok2("готово"))) // данные: готово
|
||
println(Fail("сбой").isSuccess) // false
|
||
}
|
||
```
|
||
`sealed` класс абстрактен по определению. Разница: `abstract` допускает наследников где угодно, `sealed` - только в своём модуле и пакете, зато даёт исчерпывающий `when`. Подробнее: [Sealed class и interface](../Синтаксис%20и%20типы/Базовые%20типы%20ООП/Sealed%20class%20и%20interface.md)
|
||
|
||
> [!info] Отличия от Java
|
||
> | Java | Kotlin |
|
||
> |---|---|
|
||
> | `abstract class A` | то же |
|
||
> | `abstract void f();` | `abstract fun f()` |
|
||
> | поля `protected` | свойства `protected` |
|
||
> | абстрактное поле невозможно | `abstract val` |
|
||
> | `default`-методы в интерфейсе (Java 8+) | реализация в интерфейсе без ключевого слова |
|
||
>
|
||
> **`abstract val` - то, чего в Java нет.** Java позволяет объявить абстрактным только метод, поэтому «абстрактное свойство» выражается парой геттер/сеттер:
|
||
> ```java
|
||
> abstract class Shape {
|
||
> abstract double getArea(); // абстрактный геттер
|
||
> }
|
||
> ```
|
||
> В Kotlin `abstract val area: Double` оставляет наследнику выбор: хранимое свойство, геттер или параметр конструктора. Клиент разницы не видит.
|
||
>
|
||
> **`abstract` не требует `open`**, потому что отсутствие реализации уже означает необходимость переопределения. В Java `final abstract` - ошибка компиляции по той же причине.
|
||
>
|
||
> **Доля абстрактных классов в Kotlin ниже.** Часть их задач закрывают другие средства: `sealed` для закрытых иерархий, делегирование для переиспользования кода, функции-расширения для добавления поведения без наследования.
|
||
>
|
||
> Сравнить: [Абстрактные классы в Java](../../Программирование%20на%20Java/ООП/Абстрактные%20классы.md)
|
||
|
||
> [!warning] Подводные камни
|
||
> **Вызов абстрактного метода из `init` - гарантированная ловушка:**
|
||
> ```kotlin
|
||
> abstract class Base33 {
|
||
> init { println("из init: ${describe()}") }
|
||
> abstract fun describe(): String
|
||
> }
|
||
>
|
||
> class Derived32 : Base33() {
|
||
> private val name: String = "Иван"
|
||
> override fun describe() = "name=$name"
|
||
> }
|
||
>
|
||
> fun main() { Derived32() } // из init: name=null
|
||
> ```
|
||
> Подкласс ещё не инициализирован, поэтому non-null свойство оказывается `null`. Подробнее: [Инициализация](Инициализация.md)
|
||
>
|
||
> **Абстрактный класс расходует единственный слот наследования.** Класс, унаследованный от абстрактного, больше ни от чего наследоваться не сможет. Поэтому публичный API лучше начинать с интерфейса.
|
||
>
|
||
> **`protected abstract` - часть контракта с наследниками**, и менять его так же больно, как публичный API: изменение сигнатуры сломает все подклассы.
|
||
>
|
||
> **Абстрактный класс с конструктором усложняет тестирование.** Чтобы проверить логику шаблонного метода, нужен наследник; с интерфейсом достаточно лямбды или объекта-выражения.
|
||
>
|
||
> **`abstract` и `private` несовместимы** - приватный член невозможно переопределить:
|
||
> ```kotlin
|
||
> abstract class Base34 {
|
||
> // private abstract fun f() // ошибка
|
||
> protected abstract fun f(): String
|
||
> fun run3() = f()
|
||
> }
|
||
>
|
||
> class Impl7 : Base34() { override fun f() = "готово" }
|
||
>
|
||
> fun main() { println(Impl7().run3()) } // готово
|
||
> ```
|
||
>
|
||
> **Абстрактное свойство легко переопределить несогласованно:**
|
||
> ```kotlin
|
||
> abstract class Base35 { abstract val id: Int }
|
||
>
|
||
> class Unstable : Base35() {
|
||
> override val id: Int get() = (0..100).random() // разное при каждом чтении
|
||
> }
|
||
>
|
||
> fun main() {
|
||
> val u = Unstable()
|
||
> println(u.id == u.id) // чаще false
|
||
> }
|
||
> ```
|
||
> Контракт «свойство стабильно» компилятором не проверяется; при использовании в `equals` или как ключа это даст тяжёлые для отладки ошибки.
|
||
>
|
||
> **Глубокие абстрактные иерархии трудны для чтения.** Если шаблонный метод вызывает абстрактные шаги, которые вызывают другие шаблонные методы, поведение собирается из четырёх файлов.
|
||
|
||
Дополнительно: [Интерфейсы](Интерфейсы.md)
|
||
Далее: [Интерфейсы](Интерфейсы.md)
|