Сколько абстрактных классов может наследовать класс?

Краткий ответ

Один. В Java (и, соответственно, в Android/Kotlin) класс может наследовать только от одного абстрактного класса. Это прямое следствие принципа единого наследования (single inheritance), который является фундаментальным ограничением для классов в этих языках.

Подробное объяснение

Ключевое правило: наследование реализации (extends) в иерархии классов допускается только от одного предка, независимо от того, является ли он абстрактным или конкретным. Это ограничение введено для избежания проблем, присущих множественному наследованию, таких как "проблема ромба (Diamond Problem)".

Пример в Java:

// Абстрактный класс A
abstract class A {
    abstract void methodFromA();
}

// Абстрактный класс B
abstract class B {
    abstract void methodFromB();
}

// Класс НЕ МОЖЕТ наследовать от двух абстрактных классов
// class MyClass extends A, B { // <- Это вызовет ошибку компиляции
// }

// Правильно: наследование только от одного абстрактного класса
class CorrectClass extends A {
    @Override
    void methodFromA() {
        // реализация
    }
}

Пример в Kotlin:

abstract class AbstractLogger {
    abstract fun log(message: String)
}

abstract class AbstractParser {
    abstract fun parse(data: String): Result
}

// ОШИБКА: Only one class may appear in a supertype list
// class MyService : AbstractLogger(), AbstractParser()

// ПРАВИЛЬНО: Наследование только от одного абстрактного класса
class MyService : AbstractLogger() {
    override fun log(message: String) {
        println(message)
    }
}

Обход ограничения и альтернативы

Хотя прямое множественное наследование классов невозможно, существуют мощные механизмы для достижения похожих целей:

1. Цепочка наследования (Multi-level inheritance)

Вы можете создать иерархию, где абстрактный класс наследует от другого абстрактного.

abstract class BaseRepository {
    abstract fun save()
}

abstract class NetworkRepository : BaseRepository() {
    abstract fun fetch()
}

// UserRepository косвенно "получает" методы от обоих абстрактных классов
class UserRepository : NetworkRepository() {
    override fun save() { /* реализация */ }
    override fun fetch() { /* реализация */ }
}

2. Интерфейсы (в Java) / Интерфейсы в Kotlin

Интерфейсы позволяют реализовывать множественное "наследование" поведения (контракта), но не состояния (полей) до Java 8. Начиная с Java 8 и в Kotlin, интерфейсы могут иметь реализации методов по умолчанию (default в Java, обычные методы в Kotlin) и свойства.

// Множественное наследование типов ЧЕРЕЗ ИНТЕРФЕЙСЫ - разрешено
interface Logger {
    fun log(message: String) { // Реализация по умолчанию
        println("Log: $message")
    }
}

interface Parser {
    fun parse(data: String): Result
}

// Класс может реализовать несколько интерфейсов
class DataProcessor : Logger, Parser {
    override fun parse(data: String): Result {
        // реализация
        return Result.Success
    }
    // Метод log() можно не переопределять, используется реализация по умолчанию
}

3. Композиция (Composition over Inheritance)

Это предпочтительный паттерн, рекомендованный во многих случаях вместо глубоких иерархий наследования.

abstract class Validator {
    abstract fun isValid(input: String): Boolean
}

abstract class Formatter {
    abstract fun format(input: String): String
}

// Вместо наследования используем композицию
class TextProcessor(
    private val validator: Validator,
    private val formatter: Formatter
) {
    fun process(input: String): String? {
        return if (validator.isValid(input)) {
            formatter.format(input)
        } else {
            null
        }
    }
}

Почему такое ограничение?

Принцип единого наследования в Java и Kotlin был сознательным дизайн-решением, принятым для:

• Упрощения языка и его обучения
• Избежания неоднозначностей (той самой "проблемы ромба"), когда два родительских класса имеют методы с одинаковой сигнатурой
• Повышения предсказуемости и надежности кода
• Продвижения композиции как более гибкой альтернативы наследованию

Итог

• Класс может наследовать только от одного абстрактного (или конкретного) класса.
• Для реализации поведения нескольких типов используйте интерфейсы.
• Паттерн "Композиция предпочтительнее наследования" часто является более гибким и поддерживаемым решением.
• В Kotlin, помимо интерфейсов, для повторного использования кода также можно использовать расширения (extensions) и классы-делегаты (by delegation).