Какая разница, что final делает между кодом ниже. Есть ли преимущество в объявлении аргументов как final.
public String changeTimezone( Timestamp stamp, Timezone fTz, Timezone toTz){
return ....
}
public String changeTimezone(final Timestamp stamp, final Timezone fTz,
final Timezone toTz){
return ....
}
Как параметр формального метода является локальной переменной, вы можете получить к ним доступ из внутренних анонимных классов, только если они объявлены как final.
Это избавит вас от объявления другой локальной конечной переменной в теле метода:
void m(final int param) {
new Thread(new Runnable() {
public void run() {
System.err.println(param);
}
}).start();
}
Извлечь из Последнее слово по ключевому слову final
Конечные параметры
В следующем примере объявляются конечные параметры:
public void doSomething(final int i, final int j)
{
// cannot change the value of i or j here...
// any change would be visible only inside the method...
}
final используется здесь для обеспечения двух индексы я и j не будут случайно reset с помощью метода. Это удобный способ защищать от коварной ошибки что ошибочно изменяет значение ваши параметры. Вообще говоря, короткие методы - лучший способ защищать от этого класса ошибок, но конечные параметры могут быть полезными дополнение к вашему стилю кодирования.
Обратите внимание, что конечные параметры не являются рассматриваемая часть метода подписи и игнорируются компилятор при разрешении вызовов метода. Параметры могут быть объявлены окончательными (или не), не влияя на то, как метод завышен.
Финал не позволяет вам присвоить новое значение переменной, и это может быть полезно при обнаружении опечаток. Стилистически вы можете оставить полученные параметры без изменений и назначить их только локальным переменным, поэтому final поможет реализовать этот стиль.
Должен признать, я редко помню, чтобы использовать final для параметров, может быть, я должен.
public int example(final int basicRate){
int discountRate;
discountRate = basicRate - 10;
// ... lots of code here
if ( isGoldCustomer ) {
basicRate--; // typo, we intended to say discountRate--, final catches this
}
// ... more code here
return discountRate;
}
Это не имеет большого значения. Это просто означает, что вы не можете писать:
stamp = null;
fTz = new ...;
но вы все равно можете написать:
stamp.setXXX(...);
fTz.setXXX(...);
В основном это подсказка для программиста по обслуживанию, который следует за вами, что вы не собираетесь назначать новое значение параметру где-то посередине вашего метода, где это не очевидно и может вызвать путаницу.
Конечное ключевое слово, используемое для параметров/переменных в Java, обозначает ссылку как окончательную. В случае передачи объекта другому методу система создает копию ссылочной переменной и передает ее методу. Отметив новые ссылки final, вы защитите их от переназначения. Иногда он считал хорошей практикой кодирования.
Для тела этого метода ключевое слово final будет препятствовать случайному переназначению ссылок на аргументы, давая ошибку компиляции в этих случаях (большинство IDE будут жаловаться сразу). Некоторые могут утверждать, что использование final в общем случае, когда это возможно, ускорит процесс, но это не так в недавних JVM.
Его просто конструкция на Java, чтобы помочь вам определить контракт и придерживаться его. Аналогичное обсуждение здесь: http://c2.com/cgi/wiki?JavaFinalConsideredEvil
BTW - (как говорит twiki), обозначение args как final обычно является избыточным, если вы следуете хорошим принципам программирования и выполняете hass reissign/redefine ссылку на входящие аргументы.
В худшем случае, если вы переопределите ссылку args, это не повлияет на фактическое значение, переданное функции, поскольку передано только сообщение.
Я говорю о маркировке переменных и полей final в целом - не просто применяется к аргументам метода. (Методы маркировки/классы final - это совсем другое).
Это услуга для читателей/будущих сопровождающих вашего кода. Вместе с разумным именем переменной полезно и обнадеживает читатель вашего кода, чтобы увидеть/понять, что представляют собой переменные, о которых идет речь, - и это обнадеживает читателя, что всякий раз, когда вы видите переменную в той же области действия, смысл остается то же самое, поэтому (а) он не должен почесывать голову, чтобы всегда понять, что означает переменная в каждом контексте. Мы видели слишком много злоупотреблений в отношении "повторного использования" переменных, что затрудняет понимание даже короткого фрагмента кода.
- В прошлом (до Java 8 :-))
Явное использование ключевого слова "final" повлияло на доступность переменной метода для внутренних анонимных классов.
- В современном (Java 8+) языке нет необходимости в таком использовании:
Java представила "эффективно финальные" переменные. Локальные переменные и параметры метода считаются окончательными, если код не предполагает изменения значения переменной. Поэтому, если вы видите такое ключевое слово в Java 8+, вы можете предположить, что оно не нужно. Введение "эффективно финального" заставляет нас меньше набирать код при использовании лямбды.
Конечное ключевое слово не позволяет назначить новое значение параметру. Я хотел бы объяснить это простым примером
Предположим, что у нас есть метод
метод1() {
Дата dateOfBirth = новая дата ( "1/1/2009" );
метод2 (DateOfBirth);
method3 (DateOfBirth); }
public mehod2 (Дата dateOfBirth) {
....
....
....
}public mehod2 (Дата dateOfBirth) {
....
....
....
}
В приведенном выше случае, если "dateOfBirth" присвоено новое значение в методе2, это приведет к неправильному выводу метода method3. Поскольку значение, которое передается методу3, не является тем, что было перед передачей методу2. Поэтому, чтобы избежать этого ключевого слова final используется для параметров.
И это также одна из лучших практик Java Coding.