Почему переменная Java чаще всего не объявляется как final? Сравните, чтобы ключевое слово было быстрым

см. Следует ли в Java использовать final для параметров и локальных переменных, даже если мне это не нужно?

В основном для полей это полезно, а также изменяет их свойства параллелизма. см. Параллелизм Java: последнее поле (инициализируется в конструкторе) потокобезопасный?

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

public void foo (final int x, final int y){
    try{
        final int z = x+y;
    }
    catch (final Exception z){
        final String message = "";
        throw new RuntimeException(message);
    }
}

по сравнению с

public void foo (int x, int y){
    try{
        int z = x+y;
    }
    catch ( Exception z){
        String message = "";
        throw new RuntimeException(message);
    }
}

Если у вас есть короткие методы (которые обычно должны быть), то в любом случае очевидно, что переменные не меняются.

Поэтому некоторые разработчики предпочитают использовать final из-за его семантического значения, в то время как другие предпочитают не использовать его из-за его многословности.

Java следует традиционному стилю мышления C: если мы что-то создаем (примитивные типы или объекты), по умолчанию это переменная, и вам нужно поставить «final» в java и «const» в C / C ++, чтобы сделать его константой. Swift является очень новым по сравнению с этими языками, и его цели - безопасные шаблоны программирования и простота. Если вы приобретете дополнительный опыт работы с Java, вы узнаете, что люди действительно чаще используют окончательные и лучшие практики. Основная причина, по которой я думаю (как вы также упомянули), заключается в том, что вы мало знакомы с Java.

Почему переменная Java чаще всего не объявляется как final? Что-то мне не хватает?

Вам не хватает «человеческой природы».

Просто синтаксис Java позволяет НЕ добавлять final. И вообще люди этого не делают, потому что этого легче не делать.

Обратите внимание, что проектное решение «переменные не являются окончательными по умолчанию» исходит от предков Java.

Конечно, это не отвечает на ваш подразумеваемый вопрос о том, должны ли программисты Java должны использовать final чаще ¹. Но это вопрос личного мнения, и StackOverflow не одобряет основанные на мнении вопросы и ответы.

^{1 - .... в контекстах, где это было бы целесообразно. Использование final там, где переменная явно должна быть изменяемой, контрпродуктивно.}

Инициализируйте переменную с final в Java allow compiler гарантирует, что вы можете инициализировать ее только один раз. Если это примитивный тип, такой как int или doubles, он может гарантировать, что значение не может измениться. Однако для Object final относится только к самой ссылке, а не к содержимому объекта, на который ссылаются. Это не дает никаких гарантий, что значения внутри упомянутого объекта останутся неизменными.

Например, я могу определить список с final следующим образом:

final List<String> foo = new ArrayList<String>();

Вышеупомянутый List foo не может быть инициализирован снова, но его содержимое может быть изменено, т.е. оно не делает foo неизменяемым. Следовательно, это делает ключевое слово final менее полезным.

Ключевое слово final имеет свое место при объявлении постоянного значения, особенно если нужен только один экземпляр в классе с использованием ключевого слова static. Ниже приведен пример в java.util.Random.Math:

public final class Math {

    public static final double PI = 3.14159265358979323846;

Я думаю, это потому, что в Java нет такой «традиции».

Видите ли, в первой книге, которую я прочитал о Swift (язык программирования Swift 2.0 от Apple Inc.), говорится, что каждая создаваемая вами переменная, которая не изменяется, должна быть объявлена ​​как константа let.

Поскольку Swift Programming Language 2.0 (книга) является официальным руководством по Swift, почти все следят за ним. Даже если люди не читают эту книгу, они будут читать руководства, написанные людьми, которые читали эту книгу. В результате у всех такой стиль программирования.

Напротив, первая книга, которую я прочитал о Java (Programming with Java for Dummies), не подчеркивает, что мы должны использовать final, если значение не изменится. И в официальных документах это тоже не редкость. Так что этому правилу следуют лишь немногие программисты. В результате большинство из них пишет код, который действительно следует этому правилу.

Кроме того, вы должны написать еще 5 символов (слово «final» плюс пробел), чтобы объявить константу в Java, тогда как в Swift вы не пишете никаких дополнительных символов (var и let имеют такое же количество символов) ! Программисты ленивы, понимаете.

По крайней мере, исходя из моего опыта, мне сказали, что рекомендуется использовать final, если переменная не изменяется после запуска. Для примитивного типа JVM будет рассматривать его как постоянный и выполнять некоторую оптимизацию.

В других случаях, например, в Java, все методы по умолчанию являются виртуальными, если не объявлено final. Это также повысит производительность вычислений.