Что нельзя делать с final методом

Что нельзя делать с final методом в Java

Final метод — это метод, который помечен ключевым словом final. Основное ограничение: нельзя переопределять (override) final метод в подклассах. Но есть и другие важные правила.

Основное правило: Нельзя переопределять

public class Parent {
    public final void doSomething() {
        System.out.println("Parent behavior");
    }
}

public class Child extends Parent {
    // ОШИБКА КОМПИЛЯЦИИ!
    @Override
    public final void doSomething() {
        System.out.println("Child behavior");
    }
}

// Ошибка:
// error: overriding method is final

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

The method doSomething() of type Child must override or implement
a supertype method, but it is declared final

Пример 1: Попытка переопределения

public class BaseService {
    public final void executeTransaction() {
        startTransaction();
        try {
            doWork();
            commitTransaction();
        } catch (Exception e) {
            rollbackTransaction();
        }
    }
    
    // Подклассы МОГУТ переопределить doWork
    protected void doWork() {
        // по умолчанию ничего
    }
}

public class UserService extends BaseService {
    // НЕЛЬЗЯ переопределить executeTransaction - она final!
    // Но МОЖНО переопределить doWork
    @Override
    protected void doWork() {
        // своя реализация
    }
}

Что именно нельзя делать

1. Переопределять final метод

public final void lockmedown() {}

// НЕЛЬЗЯ:
@Override
public void lockmedown() {}  // Компиляция ошибка

2. Переопределять с другим модификатором доступа

public class Parent {
    public final void method() {}
}

// НЕЛЬЗЯ даже так:
public class Child extends Parent {
    protected final void method() {}  // Ошибка!
    private final void method() {}    // Ошибка!
}

3. Убирать final при переопределении

Это невозможно, потому что переопределение вообще запрещено.

// НЕЛЬЗЯ:
@Override
public void method() {}  // Всё равно ошибка

Почему использовать final методы?

Причина 1: Template Method паттерн

Finalize метод — это каркас, который нельзя менять. Подклассы переопределяют только расширения:

public abstract class DatabaseConnection {
    
    // Это final - структура ВСЕГДА одинаковая
    public final void executeQuery(String sql) {
        validateSQL(sql);              // Всегда
        logQuery(sql);                 // Всегда
        Connection conn = getConnection();  // Всегда
        try {
            ResultSet rs = conn.createStatement().executeQuery(sql);
            processResults(rs);         // Может быть разная
        } finally {
            closeConnection(conn);      // Всегда
        }
    }
    
    // Подклассы переопределяют ЭТО
    protected abstract void processResults(ResultSet rs);
    protected abstract Connection getConnection();
    
    // Логирование одинаковое для всех
    private void logQuery(String sql) {
        System.out.println("Executing: " + sql);
    }
}

Причина 2: Безопасность и консистентность

public class BankAccount {
    private double balance = 1000;
    
    // Final - невозможно обойти логику
    public final boolean withdraw(double amount) {
        if (amount <= 0) return false;
        if (amount > balance) return false;
        balance -= amount;
        logTransaction("WITHDRAW", amount);
        return true;
    }
    
    // Если бы он БЫЛ НЕ final, подклас мог бы:
    // @Override
    // public boolean withdraw(double amount) {
    //     balance -= amount;  // Без проверок!
    //     return true;
    // }
}

Причина 3: Производительность

Компилятор и JIT могут оптимизировать final методы:

public class OptimizedClass {
    public final int multiply(int a, int b) {
        return a * b;  // JIT может inlinить это
    }
}

// JIT может заменить
int result = obj.multiply(5, 10);
// На
int result = 5 * 10;  // Прямая подстановка

Правила при работе с final методами

Правило 1: Нельзя переопределять

public class Parent {
    public final void secure() {}
}

public class Child extends Parent {
    // КОМПИЛЯЦИЯ ОШИБКА
    @Override
    public void secure() {}
}

Правило 2: Можно вызывать из подклассов

public class Parent {
    public final void secure() {
        System.out.println("Secure");
    }
}

public class Child extends Parent {
    public void test() {
        super.secure();  // OK - можно вызвать
        this.secure();   // OK - можно вызвать
    }
}

Правило 3: Можно создавать анонимные классы, но нельзя переопределять final методы

public class Parent {
    public final void secure() {}
    public void flexible() {}
}

Parent obj = new Parent() {
    @Override
    public void flexible() {}  // OK
    
    // НЕЛЬЗЯ переопределять secure - это final
};

Final в разных контекстах

Final класс:

// НЕЛЬЗЯ наследоваться вообще
public final class ImmutableClass {
    // Никакой подкласс невозможен
}

// ОШИБКА:
public class Child extends ImmutableClass {}  // Компиляция ошибка

Final переменная:

public final int CONSTANT = 10;
// НЕЛЬЗЯ изменять
CONSTANT = 20;  // Ошибка компиляции

Final параметр метода:

public void method(final String param) {
    param = "new value";  // Ошибка компиляции
    // НЕЛЬЗЯ переприсвоивать
}

Final метод (наш случай):

public final void method() {
    // НЕЛЬЗЯ переопределять в подклассах
}

Типичные ошибки

Ошибка 1: Забыть, что метод final

public class Parent {
    public final void execute() {}
}

public class Child extends Parent {
    @Override
    public void execute() {}  // Забыл что final!
    // Компиляция ошибка: cannot override final method
}

Ошибка 2: Пытаться сделать final отменяемым методом

// Нельзя для abstract методов:
public abstract final void method();  // Синтаксическая ошибка
// abstract требует переопределения, final запрещает

Ошибка 3: Неправильно понять инкапсуляцию

public class Parent {
    public final void doSomething() {
        helper();  // Это НЕ final
    }
    
    protected void helper() {}
}

public class Child extends Parent {
    // Нельзя переопределить doSomething
    // Но МОЖНО переопределить helper
    @Override
    protected void helper() {
        // Подкласс может менять поведение helper
    }
}

Когда использовать final

1. Template Method паттерн

public abstract class Report {
    public final void generate() {
        collectData();
        process();
        render();
    }
    
    protected abstract void collectData();
    protected abstract void process();
    protected abstract void render();
}

2. Критичная бизнес-логика

public class Payment {
    public final boolean processPayment(BigDecimal amount) {
        // Критична - нельзя трогать
    }
}

3. Immutable объекты

public final class User {  // Класс final
    private final String name;  // Переменная final
    
    public final String getName() {  // Метод final
        return name;
    }
}

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

Хорошо:

// Final для стабильного API
public final void coreOperation() {
    // Гарантирует поведение
}

// Переопределяемые методы для расширения
protected void customBehavior() {
    // Подклассы могут менять
}

Плохо:

// Случайные final без причины
public final void randomMethod() {}

// Слишком много final методов ограничивает гибкость
public final void method1() {}
public final void method2() {}
public final void method3() {}
// Подкласс не может ничего переопределить

Вывод

Нельзя делать с final методом:

1. Переопределять в подклассах — это основное ограничение
2. Изменять сигнатуру — даже тип возврата
3. Убирать модификатор final при переопределении (невозможно, потому что переопределение запрещено)
4. Использовать в abstract классе с другими требованиями — противоречиво

Final метод это:

• Гарантия поведения
• Template Method каркас
• Защита от неправильного использования
• Возможность для JIT оптимизации

Используй final, когда метод критичен и его поведение не должно меняться!