В чем разница между полиморфизмом времени компиляции и полиморфизмом времени выполнения?

Полиморфизм времени компиляции vs времени выполнения

В объектно-ориентированном программировании полиморфизм (способность объектов разных классов обрабатываться через единый интерфейс) реализуется в двух формах, различающихся временем разрешения вызовов методов.

Полиморфизм времени компиляции (статический)

Полиморфизм времени компиляции разрешается во время компиляции через механизм перегрузки методов (method overloading). Компилятор определяет, какой конкретный метод должен быть вызван на основе сигнатуры (имени, количества и типа параметров).

Ключевые характеристики:

• Реализуется через перегрузку методов в одном классе
• Также называется статическим связыванием (static binding)
• Решение о вызове метода принимается компилятором
• Проявляется на уровне одного класса
• Повышает читаемость кода (единое имя для схожих операций)

class Calculator {
    // Перегрузка метода add
    fun add(a: Int, b: Int): Int {
        return a + b
    }
    
    fun add(a: Double, b: Double): Double {
        return a + b
    }
    
    fun add(a: String, b: String): String {
        return a + b
    }
}

// Использование
val calc = Calculator()
println(calc.add(5, 3))      // Вызов add(Int, Int)
println(calc.add(2.5, 3.7))  // Вызов add(Double, Double)

Полиморфизм времени выполнения (динамический)

Полиморфизм времени выполнения разрешается во время выполнения программы через механизм переопределения методов (method overriding). JVM определяет, какой метод вызывать, основываясь на фактическом типе объекта.

Ключевые характеристики:

• Реализуется через переопределение методов и наследование
• Также называется динамическим связыванием (dynamic binding)
• Решение о вызове метода принимается JVM во время выполнения
• Требует отношения наследования между классами
• Основа инкапсуляции и гибкости ООП

open class Animal {
    open fun makeSound() {
        println("Some generic animal sound")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        println("Woof woof!")
    }
}

class Cat : Animal() {
    override fun makeSound() {
        println("Meow meow!")
    }
}

// Использование
fun playWithAnimal(animal: Animal) {
    animal.makeSound() // Какой метод вызовется - определится в runtime
}

val animals: List<Animal> = listOf(Dog(), Cat(), Animal())
animals.forEach { it.makeSound() }
// Вывод:
// Woof woof!
// Meow meow!
// Some generic animal sound

Сравнительная таблица

Практическое значение в Android разработке

В Android разработке оба вида полиморфизма критически важны:

1. Полиморфизм времени выполнения используется постоянно:

   • Обработка кликов через View.OnClickListener
   • Адаптеры RecyclerView
   • Fragment lifecycle методы
   • Обработка событий в Jetpack Compose

2. Полиморфизм времени компиляции улучшает API:

   • Перегрузка конструкторов View
   • Различные варианты методов для Intent
   • Множественные фабричные методы

// Пример из Android: полиморфизм времени выполнения
class MainActivity : AppCompatActivity(), View.OnClickListener {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        findViewById<Button>(R.id.button).setOnClickListener(this)
    }
    
    // JVM определит вызов этого метода во время выполнения
    override fun onClick(v: View?) {
        // Обработка клика
    }
}

Заключение: Обе формы полиморфизма дополняют друг друга. Статический полиморфизм обеспечивает удобство API через перегрузку, а динамический полиморфизм обеспечивает гибкость и расширяемость системы через наследование и переопределение. В Android разработке понимание этих концепций особенно важно для создания гибких, поддерживаемых приложений с чистым кодом.