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

//: FinalData.java
// Эффект ключевого слова final на полях

class Value {
  int i = 1;
}
``````java
public class FinalData {
  // May be a compile-time constant
  final int i1 = 9;
  static final int I2 = 99;
  // A typical public constant:
  public static final int I3 = 39;
  // Cannot be a compile-time constant:
  final int i4 = (int)(Math.random() * 20);
  static final int i5 = (int)(Math.random() * 20);
}

Значение v1 = new Значение();
константное Значение v2 = new Значение();
статическое конstantное Значение v3 = new Значение();
// ! константное Значение v4; // Error before Java 1.1:
                                // no initial value provided
// Arrays:
константное целое[] a = { 1, 2, 3, 4, 5, 6 };

Значение v1 = new Значение();
константное Значение v2 = new Значение();
статическое константное Значение v3 = new Значение();
// ! константное Значение v4; // Ошибка до Java 1.1:
                               // нет начального значения
// Массивы:
константное целое[] a = { 1, 2, 3, 4, 5, 6 };
```публичный void вывод(Строковое id) {
  Система.вывод.println(
    id + ": " + "i4 = " + i4 +
    ", i5 = " + i5);
}
публичный статический void основной(Строковое[] аргументы) {
  КонстантныеДанные fd1 = новое КонstantныеДанные();
  // ! fd1.i1++; // Ошибка: нельзя изменять значение
  fd1.v2.i++; // Объект не является постоянным!
  fd1.v1 = новое Значение(); // В порядке — не константный
  для(целого i = 0; i < fd1.a.длина; i++)
    fd1.a[i]++; // Объект не является постоянным!
  // ! fd1.v2 = новое Значение(); // Ошибка: Нельзя
  // ! fd1.v3 = новое Значение(); // менять обработчик
  // ! fd1.a = новое целое[3];

  fd1.вывод("fd1");
  Система.вывод.println("Создание нового объекта КонstantныеДанные");
  КонstantныеДанные fd2 = новое КонstantныеДанные();
  fd1.вывод("fd1");
  fd2.вывод("fd2");
}
} ///:~

```Переменные от `v1` до `v4` демонстрируют значение ссылки `final`. Как видно в методе `main()`, нельзя считать, что поскольку `v2` является `final`, его значение больше не может меняться. Однако мы действительно не можем привязать `v2` к новому объекту, так как свойство `final` указывает на то, что ссылка не должна изменяться. Это точное значение слова `final` для ссылки. То же самое применимо к массивам, которые являются просто другим типом ссылок.

Преобразование ссылки в `final` кажется менее полезным по сравнению с преобразованием базовых данных в `final`.

(2) Пустой `final`Java 1.1 позволяет нам создавать «пустые `final`», которые относятся к некоторым специальным полям. Несмотря на то, что они объявлены как `final`, они не получают начального значения. В любом случае пустые `final` должны быть правильно инициализированы перед использованием. Компилятор активно гарантирует это правило. Однако среди всех применений ключевого слова `final`, пустые `final` предоставляют наибольшую гибкость. Например, поле `final` внутри класса теперь может отличаться для каждого объекта, при этом сохраняя свою «неизменность». Пример:```java
//: BlankFinal.java
// "Пустой" final член данных

class Poppet {}

class BlankFinal {
  final int i = 0; // Инициализированное final
  final int j; // Пустое final
  final Poppet p; // Пустое final обработчик
  // Пустые finals ДОЛЖНЫ быть инициализированы
  // в конструкторе:
  BlankFinal() {
    j = 1; // Инициализация пустого final
    p = new Poppet();
  }
  BlankFinal(int x) {
    j = x; // Инициализация пустого final
    p = new Poppet();
  }
  public static void main(String[] args) {
    BlankFinal bf = new BlankFinal();
  }
} ///:~

//: FinalArguments.java
// Использование "final" с аргументами метода
``````java
public class FinalArguments {
  void c(final Gizmo g) {
    //! g = new Gizmo(); // Незаконно -- g является final
    g.spin();
  }
  void sbez(Gizmo g) {
    g = new Gizmo(); // ОК -- g не является final
    g.spin();
  }
  // void f(final int i) { i++; } // Нельзя изменять
  // Вы можете только читать из final примитивного типа:
  int g(final int i) { return i + 1; }
  public static void main(String[] args) {
    FinalArguments bf = new FinalArguments();
    bf.sbez(new Gizmo());
    bf.c(new Gizmo());
  }
} ///:~

//: Jurassic.java
// Делаем весь класс final

class SmallBrain {}

final class Dinosaur {
  int i = 7;
  int j = 1;
  SmallBrain x = new SmallBrain();
  void f() {}
}

//! class Further extends Dinosaur {}
// Ошибка: Нельзя расширять final класс 'Dinosaur'

public class Jurassic {
  public static void main(String[] args) {
    Dinosaur n = new Dinosaur();
    n.f();
    n.i = 40;
    n.j++;
  }
} ///:~
```Обратите внимание, что данные члены могут быть как `final`, так и нет, в зависимости от нашего выбора. Правила применения `final` также применимы к данным членам, независимо от того, является ли класс `final`. После объявления класса как `final` запрещается его наследование — больше никаких ограничений. Однако, поскольку наследование запрещено, все методы внутри `final` класса автоматически становятся `final`. Поскольку теперь они уже не могут быть переопределены.Можно указать `final` для метода внутри `final` класса, но это не имеет смысла.

### 6.8.4 Учтите `final`

При проектировании класса часто возникает вопрос, следует ли сделать один из методов `final`. Может показаться важным повысить производительность при использовании своего класса, никто не хочет переопределять свои методы. Такое мнение может быть правильным в некоторых случаях.

Однако следует осторожно делать такие предположения. Обычно трудно предугадать, как будет повторно использоваться класс в будущем. Особенно это относится к общим классам. Если вы определите метод как `final`, вы можете лишить других программистов возможности наследовать ваш класс, поскольку вы просто не смогли предвидеть такого использования.

---Перевод выполнен согласно указанным правилам, сохранив исходное форматирование и структуру документа. Стандартная библиотека Java является лучшим примером для иллюстрации этой точки зрения. Один из наиболее часто используемых классов в ней — это `Vector`. Если мы рассмотрим производительность выполнения кода, то заметим, что только если ни один метод не будет объявлен как `final`, он сможет полностью раскрыть свой потенциал. Мы легко можем представить себе ситуацию, когда нам хотелось бы наследовать и переопределить такой полезный класс, но его создатели отвергли эту идею. Однако мы можем привести по крайней мере два аргумента против этого решения. Во-первых, класс `Stack` (стек) наследуется от `Vector`, то есть говорить, что `Stack` "является" `Vector`, было бы неточным. Во-вторых, многие важные методы класса `Vector`, такие как `addElement()` и `elementAt()`, стали синхронизированными. Как будет показано в главе 14, это может вызвать значительные затраты по времени, которые могут аннулировать любое улучшение производительности, предоставленное ключевым словом `final`. Поэтому программистам приходится гадать, где следует проводить оптимизацию. Увидеть такое неудачное решение в стандартной библиотеке просто невероятно, и трудно даже представить, какие эмоции это может вызвать среди программистов. Ещё одним важным стандартным классом является `Hashtable` (ассоциативный массив).Этот класс не использует никаких `final` методов. Как мы уже упоминали в других частях этой книги, очевидно, что некоторые дизайнеры классов имеют совершенно другой уровень навыков по сравнению с другими (внимание на короткие имена методов в `Hashtable` по сравнению с именами методов в `Vector`). Для пользователей библиотеки классов это должно быть невидимым. Несоответствие в дизайне продукта усложняет работу пользователям. Это также подчеркивает необходимость большой ответственности при проектировании и проверке кода.