Что такое Signature?

Method Signature в Java: определение метода

Method Signature — это уникальный идентификатор метода, который состоит из имени метода и типов параметров (в порядке их следования). Это не включает тип возврата!

Основная концепция

public class Calculator {
    
    // Сигнатура: add(int, int)
    public int add(int a, int b) {
        return a + b;
    }
    
    // Сигнатура: add(double, double)
    // ДРУГАЯ сигнатура! (другие типы параметров)
    public double add(double a, double b) {
        return a + b;
    }
    
    // Сигнатура: add(int, int, int)
    // ДРУГАЯ сигнатура! (другое количество параметров)
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // ❌ Ошибка! Сигнатура = add(int, int)
    // public double add(int a, int b) {  // тип возврата не входит в сигнатуру
    //    return a + b;
    // }
    // Компилятор выдаст: Method add(int, int) is already defined
}

Что входит в signature?

Сигнатура = Имя метода + Типы параметров (в порядке)

Входит:
✅ Имя метода
✅ Типы параметров
✅ Порядок параметров

НЕ входит:
❌ Тип возврата
❌ Модификаторы доступа (public, private)
❌ Exceptions (throws)
❌ Имена параметров

Примеры

public class SignatureExamples {
    
    // Сигнатура: print(String)
    public void print(String text) {}
    
    // Сигнатура: print(int)
    public void print(int number) {}  // Другая сигнатура!
    
    // Сигнатура: calculate(int, String)
    public int calculate(int a, String b) {}
    
    // Сигнатура: calculate(String, int)
    public int calculate(String a, int b) {}  // ДРУГАЯ! Порядок параметров важен
    
    // Сигнатура: test()
    public void test() {}
    
    // ❌ Ошибка! Сигнатура совпадает с test()
    // public int test() {}
}

Overloading: множество методов с одинаковым именем

Overloading основано на различных сигнатурах:

public class OverloadingExample {
    
    // Сигнатура: sum(int, int)
    public static int sum(int a, int b) {
        return a + b;
    }
    
    // Сигнатура: sum(double, double)
    public static double sum(double a, double b) {
        return a + b;
    }
    
    // Сигнатура: sum(String, String)
    public static String sum(String a, String b) {
        return a + b;
    }
    
    // Сигнатура: sum(int, int, int)
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }
    
    public static void main(String[] args) {
        System.out.println(sum(1, 2));              // sum(int, int) → 3
        System.out.println(sum(1.5, 2.5));          // sum(double, double) → 4.0
        System.out.println(sum("Hello", " World"));  // sum(String, String) → "Hello World"
        System.out.println(sum(1, 2, 3));           // sum(int, int, int) → 6
    }
}

Compiler сам выбирает правильный метод по сигнатуре

public class MethodSelection {
    
    public void process(Object obj) {
        System.out.println("Object");
    }
    
    public void process(String str) {
        System.out.println("String");
    }
    
    public void process(Integer num) {
        System.out.println("Integer");
    }
    
    public static void main(String[] args) {
        MethodSelection ms = new MethodSelection();
        
        ms.process("hello");   // Сигнатура: process(String) → выведет "String"
        ms.process(42);        // Сигнатура: process(Integer) → выведет "Integer"
        ms.process(3.14);      // Сигнатура: process(Object) → выведет "Object"
                               // (double нет, используется Object как самый близкий)
    }
}

Varargs (переменное количество аргументов)

public class VarargsExample {
    
    // Сигнатура: sum(int[])
    // Varargs конвертируется в массив
    public static int sum(int... numbers) {
        int total = 0;
        for (int n : numbers) {
            total += n;
        }
        return total;
    }
    
    public static void main(String[] args) {
        sum(1);           // Массив: [1]
        sum(1, 2, 3);     // Массив: [1, 2, 3]
        sum(1, 2, 3, 4, 5);  // Массив: [1, 2, 3, 4, 5]
    }
}

Signature в контексте наследования

Override vs Overload

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

class Dog extends Animal {
    // Сигнатура: makeSound()
    // OVERRIDE — сигнатура совпадает с родительским классом
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
    
    // Сигнатура: makeSound(int)
    // OVERLOAD — сигнатура ДРУГАЯ (добавлен параметр)
    // Это не override!
    public void makeSound(int volume) {
        System.out.println("Woof! " + "*".repeat(volume));
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();      // Override → "Woof!"
        dog.makeSound(3);     // Overload → "Woof! ***"
    }
}

Signature и Reflection

import java.lang.reflect.Method;

public class ReflectionSignature {
    public static void main(String[] args) throws NoSuchMethodException {
        // Получить метод по сигнатуре используя reflection
        
        // Сигнатура: divide(int, int)
        Method method = Calculator.class.getMethod(
            "divide",  // имя метода
            int.class, int.class  // типы параметров
        );
        
        System.out.println("Method: " + method.getName());
        System.out.println("Return type: " + method.getReturnType().getName());
        System.out.println("Parameter count: " + method.getParameterCount());
        
        // Вызвать метод через reflection
        try {
            Object result = method.invoke(new Calculator(), 10, 2);
            System.out.println("Result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Calculator {
    public int divide(int a, int b) {
        return a / b;
    }
}

Generic методы и их сигнатуры

public class GenericMethods {
    
    // Сигнатура: swap(Object[], int, int)
    // Generic type <T> не входит в сигнатуру на уровне runtime
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    
    // Сигнатура: max(Comparable[])
    public static <T extends Comparable<T>> T max(T... elements) {
        T max = elements[0];
        for (T elem : elements) {
            if (elem.compareTo(max) > 0) {
                max = elem;
            }
        }
        return max;
    }
    
    public static void main(String[] args) {
        Integer[] numbers = {5, 2, 8, 1};
        swap(numbers, 0, 3);  // [1, 2, 8, 5]
        
        System.out.println(max(1, 2, 3, 4, 5));  // 5
        System.out.println(max("apple", "banana", "cherry"));  // cherry
    }
}

Type Erasure: дополнение о generic сигнатурах

// ⚠️ Важно: Generic информация стирается при compile-time

public class GenericSignature {
    
    // Сигнатура в исходном коде: process(List<String>)
    public void process(List<String> items) {}
    
    // Сигнатура после compile-time (Type Erasure):
    // process(List)  ← типы параметров <String> удаляются!
    
    // ❌ Поэтому это нельзя сделать:
    // public void process(List<Integer> items) {}
    // Ошибка: сигнатура совпадает! Оба метода = process(List)
}

Practical: использование сигнатур в API дизайне

@RestController
@RequestMapping("/api/v1/users")
public class UserController {
    
    // Сигнатура: create(CreateUserRequest)
    @PostMapping
    public ResponseEntity<UserDTO> create(@RequestBody CreateUserRequest request) {
        return ResponseEntity.ok(userService.createUser(request));
    }
    
    // Сигнатура: getById(Long)
    @GetMapping("/{id}")
    public ResponseEntity<UserDTO> getById(@PathVariable Long id) {
        return ResponseEntity.ok(userService.getUserById(id));
    }
    
    // Сигнатура: search(String, int)
    @GetMapping("/search")
    public ResponseEntity<List<UserDTO>> search(
            @RequestParam String query,
            @RequestParam(defaultValue = "10") int limit) {
        return ResponseEntity.ok(userService.search(query, limit));
    }
    
    // Сигнатура: update(Long, UpdateUserRequest)
    @PutMapping("/{id}")
    public ResponseEntity<UserDTO> update(
            @PathVariable Long id,
            @RequestBody UpdateUserRequest request) {
        return ResponseEntity.ok(userService.updateUser(id, request));
    }
}

Ошибки связанные с сигнатурами

public class SignatureErrors {
    
    public void method(int a) {}
    
    // ❌ Ошибка: сигнатура совпадает
    // public double method(int a) {
    //     return a;
    // }
    
    // ✅ Правильно: другая сигнатура (другой тип параметра)
    public void method(String a) {}
    
    // ✅ Правильно: другая сигнатура (больше параметров)
    public void method(int a, int b) {}
    
    // ❌ Ошибка: параметры переставлены? Нет!
    // public void method(int b, int a) {}  — это ЖЕ сигнатура method(int, int)
    
    // ❌ Ошибка: имена параметров не важны
    // public void method(int x, int y) {}  — это ЖЕ сигнатура method(int, int)
}

Вывод

Method Signature — это фундаментальная концепция Java:

1. Определение: имя метода + типы параметров (в порядке)
2. Не входит: тип возврата, имена параметров, модификаторы
3. Overloading: несколько методов с одинаковым именем, но разными сигнатурами
4. Override: метод с точно такой же сигнатурой в подклассе
5. Reflection: можно получить метод по сигнатуре
6. Generic erasure: типы удаляются, остается только базовый тип

На собеседовании важно понимать:

• Что входит/не входит в сигнатуру
• Разницу между overloading и override
• Как compiler выбирает правильный метод
• Практическое применение в API дизайне