Премиум

В чем разница между ключевым словом final и методом finalize() в Java?

Тип вопроса: Java Core Вероятность: 10% Категория: Java Разработчик

Ответ

Это совершенно разные концепции: final — это ключевое слово для объявления константности, а finalize() — устаревший метод сборки мусора.

Ключевое слово final

Применяется к переменным, методам и классам для наложения ограничений на изменение.

  1. final переменная (поле, локальная переменная, параметр):

    • Значение можно присвоить только один раз (константа или неизменяемая ссылка). 
      final int MAX_USERS = 100;
final List<String> list = new ArrayList<>(); // ссылка final, содержимое можно менять
// list = new LinkedList<>(); // Ошибка компиляции: нельзя изменить ссылку

  2. final метод:

    • Не может быть переопределен (overridden) в подклассах. Гарантирует, что поведение метода останется неизменным. 
      class Parent {
public final void secureMethod() { /* логика */ }
}
class Child extends Parent {
// @Override public void secureMethod() { } // Ошибка компиляции
}

  3. final класс:

    • Не может быть унаследован (extended). Гарантирует, что реализация класса не будет изменена через наследование (например, String, Integer). 
      final class UtilityClass { /* только статические методы */ }
// class SubClass extends UtilityClass { } // Ошибка компиляции

Метод finalize()

  • Защищенный (protected) метод класса Object.
  • Историческое назначение: Вызывается сборщиком мусора (Garbage Collector, GC) перед удалением объекта, чтобы дать шанс освободить внешние ресурсы (например, закрыть файловый дескриптор).
  • Проблемы и статус:
    • Непредсказуемость: Время вызова (и будет ли он вызван вообще) не гарантируется.
    • Производительность: Замедляет работу GC.
    • Опасность: Может "воскресить" объект, создав новую сильную ссылку на него.
  • Современная альтернатива: Используйте try-with-resources и явное освобождение ресурсов (close()).
// Устаревший и нерекомендуемый подход
@Override
protected void finalize() throws Throwable {
    try {
        resource.close(); // Ненадежно!
    } finally {
        super.finalize();
    }
}

// Правильный современный подход (AutoCloseable)
try (FileInputStream fis = new FileInputStream("file.txt")) {
    // используем ресурс
} // ресурс закроется автоматически

Итог: final — важный инструмент проектирования для безопасности и ясности кода. finalize() — устаревший механизм, от которого следует отказаться в пользу AutoCloseable и явного управления ресурсами.

Ответ 18+ 🔞

Да ты посмотри, какая хуйня! Два слова, вроде похожи, а смысл — как говно и конфета. Один — железная гарантия, а второй — исторический пиздец, который уже давно пора в утиль.

final — это как приговор, ёпта. Ключевое слово, которое намертво прибивает гвоздями.

  1. final переменная. Присвоил значение — и всё, пиши пропало. Второй раз не перепишешь. Константа она и есть константа, хоть обоссысь.

    final int ПИЗДЕЦ_НАСТУПИЛ = 404;
final List<String> список = new ArrayList<>(); // Ссылка прибита. Сам список менять можно, а вот новый прицепить — хуй тебе.
// список = new LinkedList<>(); // Компилятор тебе ебальник набьёт.

  2. final метод. Это знак "Руки прочь, мудак!". Наследуй класс сколько влезет, но этот метод трогать нельзя. Переопределить? Да ты чё, охуел?

    class Родитель {
    public final void священныйМетод() { /* тут логика, не тронь */ }
}
class Дитя extends Родитель {
    // @Override public void священныйМетод() { } // Собирай манатки и иди нахуй с такой идеей. Не скомпилируется.
}

  3. final класс. Абсолютный тупик эволюции. От него нельзя породить наследников. Всё, точка, приехали. Как класс String — священная корова, никому не доверяй.

    final class УтильКласс { /* одни статики */ }
// class Подкласс extends УтильКласс { } // Даже не мечтай. Компилятор засмеёт.

А теперь finalize() — это пиздец, прости Господи. Устаревший метод в классе Object.

  • Что хотел: Дать объекту последний шанс перед тем, как его съест сборщик мусора. Типа, "ой, щас умру, надо файлик закрыть!".
  • Что получилось: Полная непредсказуемость. Вызовут его — хуй знает. Не вызовут — тоже. Может через секунду, а может никогда. Он ещё и воскресить объект может, мудень ебаный!
  • Чем заменить: Да всем уже похуй на него. Есть же try-with-resources — красота, а не жизнь. Сам закроет, не обосрётся.
// Старый, кривой, убогий способ (НЕ ДЕЛАЙ ТАК!)
@Override
protected void finalize() throws Throwable {
    try {
        какойтоРесурс.close(); // А вдруг завтра? А вдруг никогда?
    } finally {
        super.finalize();
    }
}

// Новый, правильный, человеческий способ (ДЕЛАЙ ТАК!)
try (FileInputStream файл = new FileInputStream("file.txt")) {
    // работаем
} // тут автоматом закроется, даже если вылетит исключение. Волшебство, блядь!

Короче, запомни раз и нахуй:
final — это прочный замок, который ты вешаешь сам.
finalize() — это гнилая верёвка, на которой тебя оставили болтаться, и она в любой момент порвётся. Забей на него хуй.

© ХакСобесов, 2026
support@hacksobesov.com