Для чего используют final над созданным классом и интерфейсом?

Для чего используют final над созданным классом и интерфейсом

Это отличный вопрос, потому что final для классов и интерфейсов работает по-разному и имеет разные назначения.

Final для классов

Когда применяешь final к классу, ты запрещаешь создание подклассов (наследование).

// Класс со статусом final — нельзя создать подкласс
public final class String {
    // Содержимое класса
}

// ❌ ОШИБКА: нельзя наследовать от final класса
public class MyString extends String {
    // Compile error: Cannot extend final class String
}

Зачем запрещать наследование:

1. Безопасность данных (immutability)

// String — неизменяемый класс
public final class String {
    private final char[] value;
    
    // Все методы возвращают новый String вместо изменения
    public String toUpperCase() {
        // Возвращает новый String
        return new String(...);
    }
}

// Если бы можно было создать подкласс:
public class MaliciousString extends String {
    @Override
    public String toUpperCase() {
        // Вредоносный код, нарушающий контракт String
        return "HACKED";
    }
}

// Система безопасности Java опирается на то, что String
// всегда ведёт себя как String, не как подкласс

2. Производительность (JVM оптимизация)

// JVM может оптимизировать final классы
public final class Money {
    private final BigDecimal amount;
    
    public final void transfer(Account to, Money money) {
        // JVM знает, что это не может быть переопределено
        // Может inline-ировать код
    }
}

// Без final: JVM должна допускать, что может быть подкласс
// с переопределённым методом transfer()
// Это замораживает многие оптимизации

3. API контракт (семантика)

public final class DatabaseConnection {
    // Этот класс не должен расширяться
    // Разработчик явно говорит: "Это завершённый класс"
}

public class CacheService {
    // Этот класс можно расширить для кастомной логики
}

Final для интерфейсов

Интересный факт: интерфейсы НЕ могут быть final!

// ❌ ОШИБКА: интерфейс не может быть final
public final interface MyInterface {  // Compile error!
    void doSomething();
}

// Почему? Интерфейс по определению — это контракт для реализации
// Его смысл в том, чтобы классы реализовывали его
// final противоречит самой концепции интерфейса

Вместо этого используются:

// 1. Sealed interfaces (Java 17+)
public sealed interface PaymentMethod
    permits CreditCard, PayPal, ApplePay {
    void pay(Money money);
}

public class CreditCard implements PaymentMethod {
    @Override
    public void pay(Money money) {
        // Реализация
    }
}

public class PayPal implements PaymentMethod {
    @Override
    public void pay(Money money) {
        // Реализация
    }
}

// ❌ ОШИБКА: нельзя реализовать от другого класса
public class Bitcoin implements PaymentMethod {  // Compile error!
    // ...
}

Практические примеры final классов

Пример 1: Неизменяемые (Immutable) классы

public final class User {
    private final long id;
    private final String email;
    private final LocalDateTime createdAt;
    
    public User(long id, String email) {
        this.id = id;
        this.email = email;
        this.createdAt = LocalDateTime.now();
    }
    
    // Только getters
    public long getId() { return id; }
    public String getEmail() { return email; }
    
    // Нет setters — объект неизменяемый
    // Нельзя создать подкласс с setters
}

// Использование
User user = new User(1, "john@example.com");
user.getId();  // ✅ OK
// user.setEmail(...);  // ❌ Метода нет

// ❌ Нельзя создать подкласс
public class ExtendedUser extends User {  // Compile error!
    private String phone;  // Нарушило бы immutability
}

Пример 2: Критичные классы безопасности

public final class SecurityKey {
    private final String secretKey;
    private final long expiresAt;
    
    public SecurityKey(String secretKey, long expiresAt) {
        this.secretKey = secretKey;
        this.expiresAt = expiresAt;
    }
    
    public boolean isValid() {
        return System.currentTimeMillis() < expiresAt &&
               secretKey != null;
    }
    
    public String getKey() {
        return secretKey;
    }
}

// ❌ НЕПРАВИЛЬНО: создать подкласс и переопределить isValid()
public class MaliciousKey extends SecurityKey {
    @Override
    public boolean isValid() {
        return true;  // Всегда валидный!
    }
}

// С final класс SecurityKey защищён от такой атаки

Пример 3: Классы библиотеки

// Java Core классы: почти все key классы final
public final class Integer extends Number {
    private final int value;
    // ...
}

public final class Double extends Number {
    private final double value;
    // ...
}

public final class BigDecimal extends Number {
    private final BigInteger unscaledValue;
    private final int scale;
    // ...
}

// Это гарантирует, что поведение этих классов
// всегда будет как задумано разработчиками Java

Best Practices

✅ ИСПОЛЬЗУЙ final для класса когда:

// 1. Класс неизменяемый (immutable)
public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    // Все поля final, нет setters
}

// 2. Класс критичен для безопасности
public final class PasswordHash {
    private final String hash;
    // Нельзя создать подкласс, который вернёт неправильный пароль
}

// 3. Класс имеет строгий контракт
public final class EmailAddress {
    private final String email;
    
    public EmailAddress(String email) {
        if (!isValidEmail(email)) {
            throw new IllegalArgumentException();
        }
        this.email = email;
    }
    // Подкласс может нарушить валидацию
}

// 4. Нет известного варианта расширения
public final class OrderNumber {
    private final String number;
    // Это просто value object, расширение не предусмотрено
}

❌ НЕ ИСПОЛЬЗУЙ final когда:

// 1. Класс разработан для наследования
public class PaymentProcessor {
    // Предполагается наследование для разных способов оплаты
    public void process(Payment payment) {
        // Базовая реализация
    }
}

// 2. Это абстрактный класс
public abstract class Animal {
    // Предназначен для наследования
    abstract void makeSound();
}

// 3. Нет веской причины
public class SimpleService {
    // Обычный сервисный класс
    // final здесь просто усложнит тестирование
}

Sealed классы (Java 17+ альтернатива)

Для большей гибкости можно использовать sealed:

// Запрещает наследование, но разрешает конкретные подклассы
public sealed class Vehicle
    permits Car, Motorcycle, Truck {
    protected String brand;
    
    public abstract void drive();
}

public final class Car extends Vehicle {
    private int doors;
    
    @Override
    public void drive() {
        System.out.println("Driving car");
    }
}

public final class Motorcycle extends Vehicle {
    @Override
    public void drive() {
        System.out.println("Driving motorcycle");
    }
}

// ❌ ОШИБКА: не в списке permits
public class Bicycle extends Vehicle {  // Compile error!
    // ...
}

Sealed лучше чем final потому что:

• Разрешает контролируемое наследование
• Явно показывает, какие подклассы существуют
• JVM может оптимизировать как final, но с гибкостью

Тестирование: как final влияет

// ❌ ПРОБЛЕМА: final класс сложнее тестировать
public final class UserService {
    private final UserRepository repo;
    
    public UserService(UserRepository repo) {
        this.repo = repo;
    }
    
    public User getUser(long id) {
        return repo.findById(id);
    }
}

// Тест
@Test
void testGetUser() {
    // Нельзя создать мок-подкласс UserService
    // Но это нормально — используем инъекцию зависимостей
    UserRepository mockRepo = mock(UserRepository.class);
    UserService service = new UserService(mockRepo);
    
    when(mockRepo.findById(1)).thenReturn(new User(1, "John"));
    User user = service.getUser(1);
    
    assertEquals("John", user.getName());
}

Итоговый ответ

Final для класса:

• Запрещает наследование (создание подклассов)
• Используется для: неизменяемых классов, классов безопасности, API контрактов
• Преимущества: безопасность данных, JVM оптимизация, ясный контракт
• Примеры: String, Integer, final классы в Java Core

Final для интерфейса:

• Невозможен — интерфейс по определению для реализации
• Альтернатива: sealed интерфейсы (Java 17+)
• Sealed разрешает: контролируемое наследование с явным списком подклассов

Правило: Используй final для классов по умолчанию (безопасность и производительность), открывай для наследования только если это явно предусмотрено дизайном.