tipos - En Java, ¿deberían declararse las variables en la parte superior de una función, o según se necesiten?

se crea una instancia de un objeto y se manda llamas el constructor de una clase

Question

Estoy limpiando el código Java para alguien que comienza sus funciones declarando todas las variables arriba, e inicializándolas en nulo / 0 / lo que sea, en lugar de declararlas como se necesitan más adelante.

¿Cuáles son las pautas específicas para esto? ¿Hay razones de optimización para una u otra manera, o una de las formas es solo una buena práctica? ¿Hay algún caso en que sea aceptable desviarse de la forma correcta de hacerlo?

Answer 1

Creo que en realidad es objetivamente demostrable que el estilo de declarar en la cima es más propenso a errores.

Si muta el código de prueba en cualquier estilo moviendo líneas al azar (para simular una fusión que se dañó o alguien cortó o pegó irreflexivamente), entonces el estilo de declarar en la parte superior tiene una mayor probabilidad de compilación aunque funcionalmente incorrecto.

No creo que declarar-en-la-cima tenga ninguna ventaja correspondiente que no se reduzca a preferencia personal.

Entonces, suponiendo que quieras escribir un código confiable, aprende a preferir hacer una declaración justo a tiempo.

Answer 2

De la Guía de estilo de Google Java :

4.8.2.2 Declarado cuando sea necesario

Las variables locales no se declaran habitualmente al inicio de su bloque contenedor o construcción tipo bloque. En cambio, las variables locales se declaran cercanas al punto en que se usan por primera vez (dentro de lo razonable), para minimizar su alcance. Las declaraciones de variables locales generalmente tienen inicializadores o se inicializan inmediatamente después de la declaración.

Bueno, seguiría lo que hace Google, en un nivel superficial podría parecer que declarar todas las variables en la parte superior del método / función sería "más ordenado", es bastante evidente que sería beneficioso declarar las variables como necesarias. Sin embargo, es subjetivo, lo que sea intuitivo para ti.

Answer 3

De las Convenciones del Código de Java , Capítulo 6 sobre Declaraciones :

6.3 Ubicación

Ponga declaraciones solo al comienzo de los bloques. (Un bloque es cualquier código rodeado de llaves "{" y "}".) No espere a declarar variables hasta su primer uso; puede confundir al programador incauto y obstaculizar la portabilidad del código dentro del alcance.

void myMethod() {
int int1 = 0; // beginning of method block
if (condition) {
int int2 = 0; // beginning of "if" block
...
}
}

La única excepción a la regla son los índices de bucles for, que en Java se pueden declarar en la instrucción for:

for (int i = 0; i < maxLoops; i++) { ... }

Evita las declaraciones locales que ocultan declaraciones en niveles superiores. Por ejemplo, no declare el mismo nombre de variable en un bloque interno:

int count;
...
myMethod() {
if (condition) {
int count = 0; // AVOID!
...
}
...
}

Answer 4

Declare las variables lo más cerca posible del primer punto que las use. No tiene nada que ver con la eficiencia, pero hace que tu código sea mucho más legible. Cuanto más cerca esté declarada una variable de dónde se utiliza, menos desplazamiento / búsqueda tendrá que hacer al leer el código más tarde. Declarar las variables más cerca del primer lugar en el que se usan también reducirá naturalmente su scope .

Answer 5

Definir variables en un alcance más amplio que el necesario dificulta bastante la comprensión. El alcance limitado indica que esta variable solo tiene un significado para este pequeño bloque de código y no se puede pensar al leer más. Este es un tema bastante importante debido a la pequeña memoria de trabajo a corto plazo que tiene el cerebro (dijo que, en promedio, puede realizar un seguimiento de solo 7 cosas). Algo menos de lo que hacer un seguimiento es significativo.

De manera similar, debería tratar de evitar las variables en el sentido literal. Intente asignar todas las cosas una vez y declararlas definitivas para que el lector las conozca. No tener que controlar si algo cambia o no realmente reduce la carga cognitiva.

Answer 6

Es una cuestión de legibilidad y preferencia personal en lugar de rendimiento. Al compilador no le importa y generará el mismo código de todos modos.

Answer 7

Estoy haciendo lo mismo en este momento. Todas las variables en el código que estoy reelaborando se declaran en la parte superior de la función. He visto como he estado viendo a través de esto que se declaran varias variables pero NUNCA se usan o se declaran y se realizan operaciones con ellas (es decir, analizar una String y luego establecer un objeto Calendar con los valores de fecha / hora del cadena) pero luego el objeto de Calendar resultante NUNCA se usa.

Estoy revisando y limpiando esto tomando las declaraciones de la parte superior y moviéndolas hacia abajo en la función a un lugar más cercano a donde se usa.

Answer 8

He descubierto que declararlos como necesarios da como resultado menos errores que declararlos al principio. También he encontrado que declararlos en el alcance mínimo posible también para evitar errores.

Cuando miré el código de bytes generado por la ubicación de la declaración hace unos años, descubrí que eran más o menos idénticos. Hubo ocasionalmente diferencias dependiendo de cuándo fueron asignados. Incluso algo como:

for(Object o : list) {
Object temp = ...; //was not "redeclared" every loop iteration
}

vs

Object temp;
for(Object o : list) {
temp = ...; //nearly identical bytecoode, if not exactly identical.
}

Salió más o menos idéntico

Answer 9

He visto personas declarar en la parte superior y en la parte inferior de las funciones. Prefiero la parte superior, donde puedo verlos rápidamente. Es una cuestión de elección y preferencia.

Answer 10

La forma correcta es declarar las variables exactamente cuando se usan por primera vez y minimizar su alcance para que el código sea más fácil de entender.

Declarar variables en la parte superior de las funciones es un remanente de C (donde fue requerido), y no tiene absolutamente ninguna ventaja (el alcance variable existe solo en el código fuente, en el código de bytes todas las variables locales existen en secuencia en la pila de todos modos). Simplemente no lo hagas, nunca.

Algunas personas pueden intentar defender la práctica diciendo que es "más ordenada", pero cualquier necesidad de "organizar" el código dentro de un método suele ser un fuerte indicio de que el método es demasiado largo.

Answer 11

Principio: Coloque las declaraciones de variables locales tan cerca de su primer uso como sea posible, y NO simplemente en la parte superior de un método. Considera este ejemplo:

/** Return true iff s is a blah or a blub. */
public boolean checkB(String s) {
// Return true if s is a blah
... code to return true if s is a blah ...
// Return true if s is a blub. */
int helpblub= s.length() + 1;
... rest of code to return true is s is a blah.
return false;
}

Aquí, el helpblub variable local se coloca donde es necesario, en el código para probar si s es un blub. Es parte del código que implementa "Return true is s is blub". No tiene ningún sentido lógico poner la declaración de helpblub como la primera declaración del método. El lector pobre se preguntaría, ¿por qué es esa variable allí? ¿Para qué sirve?

Answer 12

Si tiene una variable kabillion utilizada en varios lugares aislados dentro del cuerpo de una función, su función es demasiado grande.

Si su función es de un tamaño cómodamente comprensible, no hay diferencia entre "todo al frente" y "exactamente como sea necesario".

La única variable no inicial estaría en el cuerpo de una declaración for .

for( Iterator i= someObject.iterator(); i.hasNext(); )