Что такое Overload?

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

Method Overloading (перегрузка методов) — это возможность в Java определить несколько методов с одинаковым именем, но разными параметрами. Это позволяет одной и той же операции работать с разными типами данных или количеством аргументов.

Правила для перегрузки методов

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

1. Одинаковое имя метода
2. Разные типы параметров (по крайней мере один параметр должен отличаться)
3. Разное количество параметров
4. Разный порядок параметров (если типы разные)

Не влияют на перегрузку:

• Тип возвращаемого значения
• Модификаторы доступа
• Исключения которые выбрасывает метод

Примеры перегрузки методов

public class Calculator {
    
    // Метод 1: два int параметра
    public int add(int a, int b) {
        return a + b;
    }
    
    // Метод 2: два double параметра (разные типы)
    public double add(double a, double b) {
        return a + b;
    }
    
    // Метод 3: три int параметра (разное количество)
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // Метод 4: varargs (переменное количество)
    public int add(int... numbers) {
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return sum;
    }
}

Перегрузка с разными типами параметров

public class StringProcessor {
    
    // Перегрузка для String
    public void process(String str) {
        System.out.println("Processing string: " + str);
    }
    
    // Перегрузка для int
    public void process(int num) {
        System.out.println("Processing integer: " + num);
    }
    
    // Перегрузка для List
    public void process(java.util.List<String> list) {
        System.out.println("Processing list with " + list.size() + " items");
    }
    
    // Перегрузка для double
    public void process(double d) {
        System.out.println("Processing double: " + d);
    }
}

Использование перегруженных методов

public class OverloadExample {
    
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        
        System.out.println(calc.add(5, 10));         // вызывает add(int, int)
        System.out.println(calc.add(5.5, 10.5));     // вызывает add(double, double)
        System.out.println(calc.add(5, 10, 15));     // вызывает add(int, int, int)
        System.out.println(calc.add(1, 2, 3, 4, 5)); // вызывает add(int...)
    }
}

Перегрузка конструкторов

Так же часто используется перегрузка конструкторов:

public class Person {
    private String name;
    private int age;
    private String email;
    
    // Конструктор 1: только имя
    public Person(String name) {
        this.name = name;
        this.age = 0;
        this.email = "unknown@example.com";
    }
    
    // Конструктор 2: имя и возраст
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.email = "unknown@example.com";
    }
    
    // Конструктор 3: все поля
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
}

Type Promotion в перегрузке

Компилятор автоматически повышает типы если нет точного совпадения:

public class TypePromotion {
    
    public void method(int x) {
        System.out.println("int method");
    }
    
    public void method(long x) {
        System.out.println("long method");
    }
    
    public void method(double x) {
        System.out.println("double method");
    }
    
    public static void main(String[] args) {
        TypePromotion tp = new TypePromotion();
        
        tp.method(5);           // вызывает method(int)
        tp.method(5L);          // вызывает method(long)
        tp.method(5.0);         // вызывает method(double)
        tp.method((byte) 5);    // byte -> int, вызывает method(int)
    }
}

Перегрузка с Generics

public class GenericOverload {
    
    // Перегрузка с generic типами
    public <T> void process(T item) {
        System.out.println("Generic method: " + item);
    }
    
    // Перегрузка для List
    public <T> void process(java.util.List<T> list) {
        System.out.println("List method with " + list.size() + " items");
    }
    
    // Перегрузка для String
    public void process(String str) {
        System.out.println("String method: " + str);
    }
}

Overload vs Override

Overload (Перегрузка):

• Несколько методов с одинаковым именем
• Разные параметры
• Возвращаемый тип может быть разным
• Разрешение во время компиляции (compile-time)
• Может быть в одном классе

Override (Переопределение):

• Один метод переопределяется в подклассе
• Одинаковые параметры
• Одинаковый возвращаемый тип
• Разрешение во время выполнения (runtime)
• Нужна иерархия классов

Best Practices для Overload

• Семантика одинакова — все перегруженные методы должны выполнять похожие действия
• Не злоупотребляй — слишком много перегрузок усложняют код
• Документируй — объясни когда использовать какой метод
• Используй this() — в конструкторах для избежания дублирования
• Помни о type promotion — неожиданное повышение типа может привести к неправильному вызову

Overloading — мощный механизм в Java, который делает код более интуитивным и гибким. Правильное использование перегрузки повышает читаемость и удобство использования методов.