En Java, ¿debo usar "final" para parámetros y locales incluso cuando no sea necesario?

Java permite marcar variables (campos / locales / parámetros) como final, para evitar la reasignación en ellas. Me resulta muy útil con los campos, ya que me ayuda a ver rápidamente si algunos atributos, o toda una clase, están destinados a ser inmutables.

Por otro lado, me parece mucho menos útil con los parámetros locales y, y generalmente evito marcarlos como finalsi nunca fueran reasignados (con la excepción obvia cuando necesitan ser utilizados en una clase interna) . Últimamente, sin embargo, me encontré con un código que usaba final siempre que podía, lo que supongo que técnicamente proporciona más información.

Ya no confío en mi estilo de programación, me pregunto cuáles son otras ventajas y desventajas de aplicar en finalcualquier lugar, cuál es el estilo más común de la industria y por qué.

Yo uso finallo mismo que tú. Para mí, parece superfluo en variables locales y parámetros de métodos, y no transmite información adicional útil.

Una cosa importante es esforzarme por mantener mis métodos cortos y limpios , cada uno haciendo una sola tarea. Por lo tanto, mis variables y parámetros locales tienen un alcance muy limitado y se usan solo para un único propósito. Esto minimiza las posibilidades de reasignarlos inadvertidamente.

Además, como seguramente sabe, finalno garantiza que no pueda cambiar el valor / estado de una variable (no primitiva). Solo que no puede reasignar la referencia a ese objeto una vez inicializado. En otras palabras, funciona a la perfección solo con variables de tipos primitivos o inmutables. Considerar

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

Esto significa que en muchos casos aún no hace que sea más fácil entender lo que sucede dentro del código, y un malentendido de hecho puede causar errores sutiles que son difíciles de detectar.

Su estilo de programación Java y sus pensamientos están bien, no necesita dudar de sí mismo allí.

Por otro lado, me parece mucho menos útil con los parámetros locales y, y generalmente evito marcarlos como finales, incluso si nunca serán reasignados (con la obvia excepción cuando deben usarse en una clase interna). )

Esto es exactamente por qué debe usar la finalpalabra clave. Usted declara que USTED sabe que nunca será reasignado, pero nadie más lo sabe. Usar finalinmediatamente desambigua su código un poquito más.

Una ventaja de usar final/ constsiempre que sea posible es que reduce la carga mental para el lector de su código.

Puede estar seguro de que el valor / referencia nunca se modifica más adelante. Por lo tanto, no necesita prestar atención a las modificaciones para comprender el cálculo.

He cambiado de opinión al respecto después de aprender lenguajes de programación puramente funcionales. Chico, qué alivio, si puedes confiar en una "variable" para mantener siempre su valor inicial.

Considero finalque los parámetros del método y las variables locales son ruido de código. Las declaraciones de métodos Java pueden ser bastante largas (especialmente con los genéricos); no es necesario hacerlas por más tiempo.

Si las pruebas unitarias se escriben correctamente, la asignación de parámetros que es "perjudicial" va a ser recogido, por lo que nunca debería realmente ser un problema. La claridad visual es más importante que evitar un posible error que no se detecta porque las pruebas de su unidad no tienen una cobertura suficiente.

Herramientas como FindBugs y CheckStyle que se pueden configurar para romper la compilación si se realiza una asignación a parámetros o variables locales, si se preocupa profundamente por tales cosas.

Por supuesto, si necesita hacerlos finales, por ejemplo, porque está usando el valor en una clase anónima, entonces no hay problema: esa es la solución más simple y limpia.

Además del efecto obvio de agregar palabras clave adicionales a sus parámetros y, por lo tanto, en mi humilde opinión, camuflarlas, agregar los parámetros finales al método a menudo puede hacer que el código en el cuerpo del método sea menos legible, lo que empeora el código: para ser "bueno", el código debe ser lo más legible y simple posible. Para un ejemplo artificial, digamos que tengo un método que debe funcionar sin distinción entre mayúsculas y minúsculas.

Sin final:

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

Sencillo. Limpiar. Todos saben lo que está pasando.

Ahora con 'final', opción 1:

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

Si bien la configuración de los parámetros finalimpide que el codificador agregue código más abajo de pensar que está trabajando con el valor original, existe el mismo riesgo de que el código más abajo pueda usar en inputlugar de lowercaseInput, lo que no debería y de lo que no puede protegerse, porque puede ' t sacarlo del alcance (o incluso asignar nulla inputsi eso ayudaría de todos modos).

Con 'final', opción 2:

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

Ahora acabamos de crear aún más ruido de código e introdujimos un golpe de rendimiento al tener que invocar toLowerCase()n veces.

Con 'final', opción 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
}

Habla sobre el ruido de código. Este es un choque de trenes. Tenemos un nuevo método, un bloque de excepción requerido, porque otro código puede invocarlo incorrectamente. Más pruebas unitarias para cubrir la excepción. Todo para evitar una línea simple, y en mi humilde opinión preferible e inofensiva.

También está el problema de que los métodos no deberían ser tan largos que no se puedan asimilar visualmente y saber de un vistazo que se ha realizado una asignación a un parámetro.

Creo que es una buena práctica / estilo que si asigna un parámetro lo hace al principio del método, preferiblemente en primera línea o inmediatamente después de la verificación de entrada básica, reemplazándolo efectivamente por todo el método, lo que tiene un efecto consistente dentro del método método. Los lectores saben que cualquier tarea debe ser obvia (cerca de la declaración de firma) y en un lugar coherente, lo que mitiga en gran medida el problema que está tratando de evitar la adición final. En realidad, rara vez asigno parámetros, pero si lo hago, siempre lo hago en la parte superior de un método.

Tenga en cuenta también que en finalrealidad no lo protege como puede parecer a primera vista:

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

final no lo protege completamente a menos que el tipo de parámetro sea primitivo o inmutable.

Dejo que eclipse se coloque finalantes de cada variable local, ya que considero que hace que el programa sea más fácil de leer. No lo hago con parámetros, ya que quiero mantener la lista de parámetros lo más corta posible, idealmente debería caber en una línea.