Что такое Overload?

Method Overloading (Перегрузка методов)

Method overloading (перегрузка методов) — это возможность создавать несколько методов с одинаковым именем, но разными параметрами. Это один из столпов полиморфизма в Java и Kotlin.

Основное определение

Оверлоад позволяет вызывать один и тот же метод с разными параметрами. Компилятор выбирает нужную версию метода на основе:

• Типа параметров
• Количества параметров
• Порядка параметров

Правила перегрузки

Методы считаются перегруженными только если они отличаются:

• Количество параметров — разное количество аргументов
• Тип параметров — разные типы данных
• Порядок параметров — разный порядок типов

НЕ может быть изменен только:

• Возвращаемый тип (return type)
• Модификаторы доступа (public, private, etc.)

Примеры в Kotlin/Android

Базовый пример:

class Calculator {
    // Перегрузка 1: два Int
    fun add(a: Int, b: Int): Int {
        return a + b
    }
    
    // Перегрузка 2: два Double
    fun add(a: Double, b: Double): Double {
        return a + b
    }
    
    // Перегрузка 3: три Int
    fun add(a: Int, b: Int, c: Int): Int {
        return a + b + c
    }
}

val calc = Calculator()
calc.add(5, 10)           // вызовет Int версию
calc.add(5.5, 10.5)       // вызовет Double версию
calc.add(1, 2, 3)         // вызовет три параметра версию

В Android контексте - построение объектов:

class User {
    var name: String
    var email: String
    var age: Int
    
    // Перегрузка 1: все параметры
    constructor(name: String, email: String, age: Int) {
        this.name = name
        this.email = email
        this.age = age
    }
    
    // Перегрузка 2: только имя и email
    constructor(name: String, email: String) : this(name, email, 0)
    
    // Перегрузка 3: только имя
    constructor(name: String) : this(name, "", 0)
}

val user1 = User("John", "john@mail.com", 30)
val user2 = User("Jane", "jane@mail.com")
val user3 = User("Bob")

Использование в интерфейсах:

interface Logger {
    fun log(message: String)
    fun log(message: String, level: String)
    fun log(throwable: Throwable)
}

Преимущества Overload

✅ Лучшая читаемость — один метод имеет одно имя, упрощает понимание

✅ Удобство API — пользователь может вызвать с нужными параметрами

✅ Гибкость — поддержка разных типов данных

✅ Меньше копирования — не нужны add(), addInt(), addDouble()

Недостатки и когда избежать

❌ Путаница — слишком много перегрузок затрудняет понимание

❌ Type erasure в Kotlin — если типы после стирания одинаковые:

// ❌ Не компилируется в Kotlin!
fun process(list: List<String>) {}
fun process(list: List<Int>) {}  // Ошибка!

Перегрузка vs Default Parameters в Kotlin

В Kotlin часто используют default parameters вместо overload:

// ❌ Много перегрузок
fun createUser(name: String, email: String, age: Int = 0) {}
fun createUser(name: String, email: String) = createUser(name, email, 0)
fun createUser(name: String) = createUser(name, "", 0)

// ✅ Лучше — default parameters
fun createUser(name: String, email: String = "", age: Int = 0) {}

Заключение

Overload — мощный инструмент для создания гибких и удобных API. В Java используется часто через конструкторы. В Kotlin предпочитают default параметры и named arguments для лучшей читаемости. Ключ — баланс: используй overload когда это действительно улучшает API, а не усложняет его.