Можно ли в методе создать аргумент и переменную с одинаковым названием?

Можно ли в методе создать аргумент и переменную с одинаковым названием?

Нет, нельзя — это ошибка компиляции. Аргументы метода и локальные переменные находятся в одном scope, поэтому они не могут иметь одинаковые имена.

Основное правило: Duplicate Variable Names запрещены

public void badMethod(String name) {  // параметр: name
    String name = "John";              // ОШИБКА КОМПИЛЯЦИИ!
    // error: variable name is already defined
}

Компилятор выдаст ошибку:

error: variable name is already defined in method badMethod(String)
    String name = "John";
           ^

Почему это запрещено

Причина 1: Одинаковый scope

Параметры метода и локальные переменные находятся в одном scope — методе:

public void method(int a, int b) {
    // Scope: весь метод
    // 'a' и 'b' - параметры
    // Локальные переменные должны быть уникальны внутри этого scope
    
    int a = 5;  // ОШИБКА - 'a' уже есть как параметр
    int b = 10; // ОШИБКА - 'b' уже есть как параметр
    int c = 15; // OK - 'c' новое имя
}

Причина 2: Неоднозначность

public void confusing(String value) {
    String value = "test";  // Ошибка, но если бы работало:
    
    System.out.println(value);  // Какой value? Параметр или переменная?
    // Код был бы неоднозначным
}

Пример компиляционной ошибки

public class VariableScope {
    public void process(String data, int count) {
        // Параметры: data, count
        
        String data = "processed";  // ОШИБКА!
        // error: variable data is already defined
        
        int count = 0;  // ОШИБКА!
        // error: variable count is already defined
        
        String result = "ok";  // OK - новое имя
        int index = 0;         // OK - новое имя
    }
    
    public static void main(String[] args) {
        // Это не скомпилируется
    }
}

Разные scopes: вложенные блоки

В разных scope'ах МОЖНО переиспользовать имена:

public void differentScopes(String name) {  // параметр: name
    // Outer scope: name параметр
    
    if (true) {
        String name = "inner";  // ОШИБКА - всё равно одинаковый scope
        // Java не позволяет даже в nested блоках
    }
    
    for (int i = 0; i < 10; i++) {
        String other = "ok";  // OK
    }
}

Да, даже во вложенных блоках (if, for, while) имена параметра и локальной переменной конфликтуют:

public void withNestedBlocks(String param) {
    // scope: всего метода
    
    {
        String param = "nested";  // ОШИБКА - конфликт с параметром
    }
    
    if (true) {
        String param = "if block";  // ОШИБКА
    }
    
    for (int i = 0; i < 10; i++) {
        String param = "loop";  // ОШИБКА
    }
}

Всё это ошибка компиляции!

Но вложенные блоки между собой OK

public void nestedBlocksOK() {
    // Блоки независимо друг от друга могут переиспользовать имена
    // НО параметр всегда в scope
    
    if (true) {
        String x = "first";  // OK
    }
    
    if (true) {
        String x = "second";  // OK - другой if блок
    }
    
    for (int i = 0; i < 10; i++) {
        String x = "third";  // OK - другой for блок
    }
}

Здесь нет конфликта, потому что каждый блок заканчивается.

Практические примеры ошибок

Ошибка 1: Зачем переприсваивать параметр?

// НЕПРАВИЛЬНО - ошибка компиляции
public void updateUser(User user) {
    User user = getDefaultUser();  // ОШИБКА
}

// ПРАВИЛЬНО - переприсвой параметр
public void updateUser(User user) {
    user = getDefaultUser();  // OK - переприсваиваешь параметр
}

// ПРАВИЛЬНО - создай новую переменную
public void updateUser(User user) {
    User newUser = getDefaultUser();  // OK - новое имя
}

Ошибка 2: Параметр из цикла и локальная переменная

// НЕПРАВИЛЬНО
public void processNames(List<String> names) {
    for (String name : names) {  // параметр цикла: name
        String name = "processed";  // ОШИБКА!
        // error: variable name is already defined
    }
}

// ПРАВИЛЬНО
public void processNames(List<String> names) {
    for (String name : names) {
        String processedName = "processed";  // OK - новое имя
        System.out.println(processedName);
    }
}

Ошибка 3: Параметр вариадического метода

// НЕПРАВИЛЬНО
public void printValues(int... values) {  // параметр: values
    int[] values = {1, 2, 3};  // ОШИБКА!
    // error: variable values is already defined
}

// ПРАВИЛЬНО
public void printValues(int... values) {
    int[] newValues = {1, 2, 3};  // OK - новое имя
    for (int v : values) {
        System.out.println(v);
    }
}

Scope иерархия в Java

Уровень 1: Package scope
│
├── Уровень 2: Class scope
│   │
│   ├── Уровень 3: Method scope
│   │   │
│   │   ├── Параметры метода     <- здесь
│   │   ├── Блок if {...}        <- и здесь в одном scope
│   │   ├── Блок for (...)       <- и здесь
│   │   ├── Блок while (...)     <- и здесь
│   │   └── Блок try-catch {...} <- и здесь
│   │
│   └── Method scope (другой метод)
│
└── Уровень 2: Interface scope

Важный момент: Параметры метода находятся на ОДНОМ уровне со всеми локальными переменными и вложенными блоками.

Можно ли в разных методах одинаковые имена?

Да, абсолютно OK:

public class MyClass {
    public void method1(String name) {
        String data = "test";  // name, data
    }
    
    public void method2(String name) {  // Одинаковый name - OK!
        String data = "test";  // Одинаковые имена - OK!
    }
    
    public void method3(String name, int name) {  // ОШИБКА!
        // Два параметра в ОДНОМ методе не могут иметь одинаковые имена
    }
}

Жадный параметр одного метода НЕ конфликтует с параметром другого метода.

Лучшие практики

Правило 1: Давай понятные имена

// ПЛОХО - неясно что переменная
public void process(String s) {
    String s1 = "processed";  // Ошибка, но даже если была OK, плохое имя
}

// ХОРОШО
public void process(String input) {
    String output = processInput(input);
}

Правило 2: Используй параметр напрямую, не переприсваивай

// Менее хорошо
public void updateUser(User user) {
    user = new User();  // Переприсвоил параметр
}

// Лучше
public void updateUser(User user) {
    user.setName("New name");  // Модифицировал объект
}

// Или
public User createUser(User template) {
    return new User(template);  // Создал новый
}

Правило 3: Если нужна новая переменная — дай ей новое имя

public void transform(String original) {
    String transformed = original.toUpperCase();  // Новое имя
    String result = transformed + "!";  // Ещё новое имя
}

Compilation vs Runtime

Это compile-time ошибка, не runtime:

public void badMethod(String name) {
    String name = "test";  // КОМПИЛЯТОР ЛОВИТ ЭТО
}

// Ошибка компиляции:
// javac не даст скомпилировать
// Класс не будет создан
// Program не запустится

Так что проблема выявляется сразу при компиляции, не при запуске.

Вывод

Нельзя — это ошибка компиляции:

1. Параметр метода и локальная переменная — не могут иметь одинаковое имя
2. Параметр и переменная в nested блоке — всё равно конфликт
3. Два параметра в одном методе — тоже не могут совпадать
4. Но в разных методах — можно переиспользовать имена

Почему запрещено:

• Неоднозначность кода
• Все имена в методе должны быть уникальны
• Scope параметров = scope метода
• Компилятор это проверяет

Что делать:

• Используй разные имена
• Переприсвой параметр если нужен новый объект
• Дай параметрам понятные имена (name, original, input, template)
• Дай локальным переменным описательные имена (result, processed, transformed)