Что такое сигнатура метода?

Сигнатура метода в Java

Сигнатура метода — это уникальный идентификатор метода, который определяется его именем и типами параметров (в порядке их следования). Сигнатура НЕ включает тип возвращаемого значения и модификаторы доступа.

Структура сигнатуры метода

Сигнатура состоит из двух частей:

1. Имя метода — идентификатор, выбранный программистом
2. Список параметров — типы и количество аргументов в скобках

public class MethodSignature {
    // Сигнатура: method()
    public void method() {
    }
    
    // Сигнатура: method(int)
    public void method(int x) {
    }
    
    // Сигнатура: method(int, String)
    public void method(int x, String name) {
    }
    
    // Сигнатура: method(String, int)
    // Отличается от предыдущей! Порядок параметров имеет значение
    public void method(String name, int x) {
    }
    
    // Сигнатура: method(double)
    public void method(double value) {
    }
}

Что входит в сигнатуру

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

Что НЕ входит в сигнатуру

• Тип возвращаемого значения
• Модификаторы доступа (public, private, protected)
• Ключевые слова (static, final, abstract)
• Проверяемые исключения (throws)

public class SignatureComparison {
    // Сигнатура: getValue()
    public int getValue() {
        return 42;
    }
    
    // Это ДРУГАЯ сигнатура, хотя тип возврата отличается
    // Ошибка компиляции! Нельзя просто изменить тип возврата
    // public double getValue() {
    //     return 42.0;
    // }
    
    // Сигнатура: process(int)
    public static void process(int value) {
    }
    
    // Это ДРУГАЯ сигнатура, хотя отличается только static
    // Сигнатура: process(int) — ТАКАЯ ЖЕ!
    // Ошибка: метод с такой сигнатурой уже определён
    // public void process(int value) {
    // }
}

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

Перегрузка методов основана на сигнатурах. Можно определить несколько методов с одним именем, но разными сигнатурами:

public class MathUtils {
    // Сигнатура: add(int, int)
    public static int add(int a, int b) {
        return a + b;
    }
    
    // Сигнатура: add(double, double)
    public static double add(double a, double b) {
        return a + b;
    }
    
    // Сигнатура: add(String, String)
    public static String add(String a, String b) {
        return a + b;
    }
    
    // Сигнатура: add(int, int, int)
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public static void main(String[] args) {
        System.out.println(add(5, 10));              // Вызывает add(int, int)
        System.out.println(add(5.5, 10.5));          // Вызывает add(double, double)
        System.out.println(add("Hello", " World")); // Вызывает add(String, String)
        System.out.println(add(5, 10, 15));          // Вызывает add(int, int, int)
    }
}

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

Два метода могут иметь одно имя только если их сигнатуры отличаются:

public class OverloadingRules {
    // Правильно: разные типы параметров
    public void display(int x) {
    }
    
    public void display(String x) {
    }
    
    // Правильно: разное количество параметров
    public void display(int x) {
    }
    
    public void display(int x, int y) {
    }
    
    // Правильно: разный порядок параметров
    public void display(int x, String y) {
    }
    
    public void display(String x, int y) {
    }
}

Сигнатура и полиморфизм

При переопределении методов (Override) в подклассе сигнатура должна быть точно такой же:

public class Animal {
    // Сигнатура: speak()
    public void speak() {
        System.out.println("Animal sound");
    }
}

public class Dog extends Animal {
    // Переопределение: сигнатура ДОЛЖНА быть точно такой же
    @Override
    public void speak() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    // Ошибка! Другая сигнатура — это перегрузка, не переопределение
    // public void speak(String message) {
    //     System.out.println("Meow: " + message);
    // }
}

Сигнатура в контексте интерфейсов

Классы, реализующие интерфейс, должны реализовать все методы с точными сигнатурами из интерфейса:

public interface Calculator {
    int calculate(int a, int b);
}

public class SimpleCalculator implements Calculator {
    // Сигнатура ДОЛЖНА совпадать: calculate(int, int)
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

Примеры сигнатур

public class SignatureExamples {
    // Сигнатура: process()
    public void process() {
    }
    
    // Сигнатура: process(String)
    public void process(String input) {
    }
    
    // Сигнатура: process(String, int)
    public void process(String input, int count) {
    }
    
    // Сигнатура: process(int, String) — отличается от предыдущей!
    public void process(int count, String input) {
    }
    
    // Сигнатура: process(int[])
    public void process(int[] array) {
    }
    
    // Сигнатура: process(List)
    public void process(java.util.List list) {
    }
    
    // Сигнатура: process(String...)
    public void process(String... args) {
    }
}

Важные моменты

• Сигнатура уникально идентифицирует метод внутри класса
• Две разные сигнатуры позволяют определить два метода с одним именем (перегрузка)
• При переопределении методов в наследовании сигнатура должна совпадать полностью
• Компилятор использует сигнатуру для определения, какой метод вызвать
• Рефлексия в Java также работает с сигнатурами методов

Понимание сигнатур методов критически важно для корректного использования перегрузки, переопределения и рефлексии в Java