Какая разница, которую 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();
}
Выдержка из Последнее слово на последнем ключевом слове
Окончательные параметры
В следующем примере объявляются окончательные параметры:
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 используется здесь, чтобы гарантировать, что два индекса i и j не будут случайно сброшены методом. Это удобный способ защиты от коварной ошибки, ошибочно изменяющей значение ваших параметров. Вообще говоря, короткие методы - лучший способ защиты от этого класса ошибок, но конечные параметры могут быть полезным дополнением к вашему стилю кодирования.
Обратите внимание, что окончательные параметры не считаются частью сигнатуры метода и игнорируются компилятором при разрешении вызовов метода. Параметры могут быть объявлены окончательными (или нет) без влияния на способ переопределения метода.
Последний предотвращает присвоение переменной нового значения, и это может быть полезно при обнаружении опечаток. Стилистически вы можете оставить полученные параметры неизменными и назначить их только локальным переменным, поэтому 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(...);
В основном это подсказка программисту по обслуживанию, который следует за вами, что вы не собираетесь присваивать новое значение параметру где-то в середине вашего метода, где это неочевидно и, следовательно, может вызвать путаницу.
Ключевое слово final при использовании для параметров / переменных в Java отмечает ссылку как окончательную. В случае передачи объекта другому методу система создает копию ссылочной переменной и передает ее методу. Помечая новые ссылки как окончательные, вы защищаете их от переназначения. Иногда это считается хорошей практикой кодирования.
Для тела этого метода ключевое слово final предотвратит случайное переназначение ссылок аргументов, что приведет к ошибке компиляции в этих случаях (большинство IDE сразу же пожалуются). Некоторые могут возразить, что использование final в целом, когда это возможно, ускорит процесс, но это не относится к недавним JVM.
Перечислены два преимущества, которые я вижу:
Из твоего примера
public String changeTimezone(final Timestamp stamp, final Timezone fTz,
final Timezone toTz){
// THIS WILL CAUSE COMPILATION ERROR as fTz is marked as final argument
fTz = Calendar.getInstance().getTimeZone();
return ..
}
В сложном методе отметка аргументов как final поможет в случайной интерпретации этих аргументов как локальных переменных метода, а переназначение в качестве компилятора пометит эти случаи, как показано в примере.
Поскольку формальный параметр метода является локальной переменной, вы можете получить к ним доступ из внутренних анонимных классов, только если они объявлены как final.
- В прошлом (до Java 8 :-))
Использование Explit ключевого слова final повлияло на доступность переменной метода для внутренних анонимных классов.
- В современном (Java 8+) языке нет необходимости в таком использовании:
В Java были введены «фактически конечные» переменные. Локальные переменные и параметры метода считаются окончательными, если код не предполагает изменения значения переменной. Поэтому, если вы видите такое ключевое слово в Java8 +, вы можете считать, что оно не нужно. Введение «фактически окончательного» заставляет нас печатать меньше кода при использовании лямбда-выражений.
Это просто конструкция в Java, которая поможет вам определить контракт и придерживаться его. Аналогичное обсуждение здесь: http://c2.com/cgi/wiki?JavaFinalConsideredEvil
BTW - (как говорится в twiki), маркировка args как final обычно избыточна, если вы следуете хорошим принципам программирования и если вы сделали переназначение / переопределение ссылки на входящий аргумент.
В худшем случае, если вы переопределите ссылку args, это не повлияет на фактическое значение, передаваемое функции, поскольку была передана только ссылка.
Я говорю о маркировке переменных и полей как окончательные в целом - не только применительно к аргументам метода. (Пометить методы / классы final - совсем другое дело).
Это услуга читателям / будущим сопровождающим ваш код. Вместе с разумным именем переменной для читателя вашего кода полезно и обнадеживает возможность увидеть / понять, что представляют собой переменные, о которых идет речь, - и обнадеживает читателя, что всякий раз, когда вы видите переменную в той же области видимости, значение остается то же самое, поэтому ему не нужно чесать голову, чтобы всегда понимать, что означает переменная в каждом контексте. Мы видели слишком много случаев злоупотребления «повторным использованием» переменных, что затрудняет понимание даже короткого фрагмента кода.
Последнее ключевое слово не позволяет вам присвоить новое значение параметру. Я хотел бы пояснить это на простом примере
Предположим, у нас есть метод
method1 () {
Дата dateOfBirth = новая дата (01.01.2009);
метод2 (дата рождения);
method3 (дата рождения); }
public mehod2 (Date dateOfBirth) {
....
....
....
}public mehod2 (Date dateOfBirth) {
....
....
....
}
В приведенном выше случае, если dateOfBirth присваивается новое значение в method2, это приведет к неправильному выводу из method3. Поскольку значение, передаваемое методу 3, не то, что было перед передачей методу 2. Поэтому, чтобы избежать этого, последнее ключевое слово используется для параметров.
И это также одна из рекомендаций по программированию на Java.
