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

Java позволяет помечать переменные (поля / локальные объекты / параметры) как final, чтобы предотвратить переназначение в них. Я нахожу это очень полезным с полями, так как это помогает мне быстро увидеть, являются ли некоторые атрибуты - или целый класс - неизменяемыми.

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

Я больше не уверен в своем стиле программирования. Интересно, какие еще преимущества и недостатки применяются в finalлюбом месте, каков наиболее распространенный отраслевой стиль и почему.

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

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

Более того, как вы наверняка знаете, finalне гарантирует, что вы не можете изменить значение / состояние (не примитивной) переменной. Только то, что вы не можете переназначить ссылку на этот объект после инициализации. Другими словами, он работает без проблем только с переменными примитивных или неизменных типов. Рассмотреть возможность

final String s = "forever";
final int i = 1;
final Map<String, Integer> m = new HashMap<String, Integer>();

s = "never"; // compilation error!
i++; // compilation error!
m.put(s, i); // fine

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

Ваш стиль программирования Java и ваши мысли в порядке - не нужно сомневаться в этом.

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

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

Одним из преимуществ использования final/ constвезде, где это возможно, является то, что это уменьшает умственную нагрузку для читателя вашего кода.

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

Я изменил свое мнение об этом после изучения чисто функциональных языков программирования. Мальчик, какое облегчение, если вы можете доверять «переменной», чтобы всегда держать ее начальное значение.

finalВ параметрах метода и локальных переменных я считаю шум кода. Объявления методов Java могут быть довольно длинными (особенно с обобщениями) - больше нет необходимости их делать.

Если модульные тесты написаны правильно, присваивая параметры , что является «вредным» будет подобрано, поэтому он никогда не должен фактически быть проблемой. Визуальная ясность важнее, чем избегать возможной ошибки, которая не обнаружена , потому что ваши юнит-тесты имеют недостаточный охват.

Такие инструменты, как FindBugs и CheckStyle, которые можно настроить для разрыва сборки, если присваиваются параметры или локальные переменные, если вы серьезно заботитесь о таких вещах

Конечно, если вам нужно сделать их окончательными, например, потому что вы используете значение в анонимном классе, то нет проблем - это самое простое и чистое решение.

Помимо очевидного эффекта добавления дополнительных ключевых слов к вашим параметрам и, тем самым, ИМХО их маскировки, добавление окончательных параметров метода часто может сделать код в теле метода менее читабельным, что делает код хуже - «хорошим» кодом. должно быть максимально читабельным и максимально простым. Для надуманного примера, скажем, у меня есть метод, который должен работать без учета регистра.

Без final:

public void doSomething(String input) {
    input = input.toLowerCase();
    // do a few things with input
}

Просто. Clean. Все знают, что происходит.

Теперь с «окончательным», вариант 1:

public void doSomething(final String input) {
    final String lowercaseInput = input.toLowerCase();
    // do a few things with lowercaseInput
}

Хотя создание параметров finalне позволяет кодеру добавлять код дальше от мысли о том, что он работает с исходным значением, существует равный риск того, что код, который находится ниже, может использовать inputвместо того lowercaseInput, чего он не должен и который не может защитить, потому что вы можете ' т вывести его из сферы (или даже назначить nullна inputесли бы даже помочь в любом случае).

С 'final', вариант 2:

public void doSomething(final String input) {
    // do a few things with input.toLowerCase()
}

Теперь мы просто создали еще больше шума в коде и представили снижение производительности из-за необходимости вызывать toLowerCase()n раз.

С 'final', вариант 3:

public void doSomething(final String input) {
    doSomethingPrivate(input.toLowerCase());
}

/** @throws IllegalArgumentException if input not all lower case */
private void doSomethingPrivate(final String input) {
    if (!input.equals(input.toLowerCase())) {
        throw new IllegalArgumentException("input not lowercase");
    }
    // do a few things with input
}

Поговорим о кодовом шуме. Это крушение поезда. У нас есть новый метод, обязательный блок исключений, потому что другой код может вызвать его неправильно. Дополнительные юнит-тесты для исключения. Все, чтобы избежать одной простой и ИМХО предпочтительной и безвредной линии.

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

Я действительно считаю хорошей практикой / стилем, что если вы назначаете параметр, вы делаете это каждый в начале метода, предпочтительно в первой строке или сразу после базовой проверки ввода, эффективно заменяя его для всего метода, что оказывает последовательный эффект в пределах метод. Читатели знают, что любое назначение должно быть очевидным (рядом с объявлением подписи) и в согласованном месте, что значительно смягчает проблему, которую пытается избежать добавление final. На самом деле я редко назначаю параметры, но если я это делаю, я всегда делаю это в начале метода.

Обратите внимание, что finalэто не защищает вас так, как это может показаться на первый взгляд:

public void foo(final Date date) {
    date.setTime(0); 
    // code that uses date
}

final не защищает вас полностью, если тип параметра не является примитивным или неизменным.

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