|
Espacios en blanco
Los espacios en blanco y líneas vacías proporcionan mayor legibilidad al código que se escribe, tanto porque las sentencias se visualizan mucho más claramente como porque las secciones de código diferentes se encuentran separadas adecuadamente.
Líneas en blanco
Se debe utilizar siempre una línea en blanco de separación en las siguientes circunstancias:
- Entre métodos
- Entre las variables locales en un método y su primera sentencia
- Antes de un bloque de código o un comentario de una línea
- Entre secciones lógicas dentro de un método para incrementar la legibilidad del código
Es conveniente el uso de dos líneas en blanco en las circunstancias que se indican:
- Entre secciones dentro de un fichero fuente
- Entre las definiciones de clases e interfaces
Espacios en blanco
Se deberían utilizar espacios en blanco de separación en las siguientes circunstancias:
- Una palabra clave seguida por un paréntesis debería ir separada por un espacio en blanco, bien antes o después del paréntesis. Por ejemplo:
while (true) {
...
}
aunque también sería admisible,
while( true ) {
...
}
Entre el nombre de un método y su paréntesis de apertura, no debe colocarse ningún espacio en blanco, sino después del paréntesis, tal como el segundo ejemplo anterior. Esto ayuda a distinguir claramente las palabras clave de la llamada al método.
- Se debe colocar un espacio de separación entre los argumentos de la lista de comandos, después de las comas.
- Todos los operadores, excepto el punto (.), debería separarse de sus operandos mediante espacios. No obstante, espacios en blanco no deben separar nunca operadores unarios como el menos unario, o los operadores unarios de incremento y decremento, de sus operadores.
a += c + d;
a = (a + b) / (c * d);
while (d++ = s++) {
n++;
}
prints("size is " + foo + "\n");
- Las expresiones en una sentencia for deben ir separadas mediante espacios en blanco.
for (expr1; expr2; expr3)
- Los moldeos (casting) deben ir seguidos de un espacio en blanco. Por ejemplo:
myMethod( (byte) aNum, (Object) x );
myFunc( (int) (cp + 5), ((int) (i + 3)) + 1 );
Convenciones de nomenclatura
Las convenciones de nomenclatura hacen que los programas sean más estándar y fáciles de leer, ya que cualquier programador está acostumbrado a tratar con código escrito de forma semejante. Además, proporcionan información sobre la funcionalidad del identificador; por ejemplo, si es una constante, un paquete o una clase, lo que también redunda en una ayuda adicional a la hora de entender el código.
Las convenciones que se indican aquí son de muy alto nivel y muy generales. Probablemente sea necesario, en proyectos de al menos una envergadura mediana, proporcionar convenciones más específicas.
|
Identificador |
Reglas de Nomenclatura |
Ejemplo |
|
Clases |
Los nombres de clases deben ser palabras completas, en mayúsculas y minúsculas, con la primera letra de cada palabra en mayúscula. Los nombres de clases deben ser simples y descriptivos, utilizando palabras completas y acrónimos o abreviaturas (a no ser que la abreviatura sea ampliamente conocida, como URL o HTML). |
class Raster;
class ImageSprite; |
|
Interfaces |
Los nombre de interfaces deberías seguir las mismas reglas indicadas para las clases. |
interface RasterDelegate;
interface Storing; |
|
Métodos |
Los métodos deberían ser verbos, en mayúsculas y minúsculas, con la primera letra en minúscula, y la primera letra de cada una de las palabras internas en mayúscula. |
run();
runFast();
getBackground(); |
|
Variables |
Todas los nombres de variables de instancia o de clase deben estar constituidos por palabras con la primera letra de la primera palabra en minúscula y la primera letra de las palabras internas en mayúscula.
Los nombres de variables deben ser cortos y significativos. La elección de un nombre de variable debe ser mnemotécnico, es decir, pensado para que un lector casual al verla comprenda su uso. Se deben evitar las variables de una sola letra, excepto en variables temporales de corto uso. Nombres comunes para este tipo de variables son: i, j, k, m y n para enteros; c, d, y e para caracteres. |
int i;
char *cp;
float myWidth; |
|
Constantes |
Los nombres de variables declaradas como constantes de clase y constantes ANSI, deberías escribirse siempre en mayúsculas, con las palabras internas separadas por el signo de subrayado ("_"). Las constantes ANSI se deben evitar en lo posible, para facilitar la depuración del código. |
int MIN_WIDTH = 4;
int MAX_WIDTH = 999;
int GET_THE_CPU = 1; |
Técnicas de programación
Estas son algunas sugerencias acerca de cuestiones de programación más habituales y comunes.
Proporcionar acceso a variables de clase e instancia
No hacer nunca una instancia o una variable de clase pública sin una buena razón. Normalmente, las variables de instancia necesitan que sus valores sean fijados o recogidos explícitamente; a menudo esto es un efecto lateral de la llamada al método.
Un ejemplo de uso adecuado de las variables de instancia públicas es el caso en que la clase es esencialmente una estructura de datos, sin ninguna funcionalidad. Es decir, si se desea utilizar una estructura en lugar de una clase (si la estructura está soportada por Java), entonces sí es apropiado el uso de variables de instancia públicas.
Referencias variables y métodos de clase
Evitar el uso de un objeto para acceder a una variable de clase (estática) o método. Utilizar el nombre de la clase en su lugar. Por ejemplo:
classMethod(); // OK
AClass.classMethod(); // OK
anObject.classMethod(); // EVITARLO!
Asignación de variables
Las constantes numéricas (literales) no deben codificarse directamente, excepto para –1, 0 y 1; porque pueden aparecer en un bucle for como valores de contador.
Técnicas varias
Evitar la asignación de diferentes variables con el mismo valor en una misma sentencia. Esto es muy difícil de leer. Por ejemplo:
fooBar.fChar = barFoo.lchar = 'c'; // EVITARLO!
No utilizar el operador de asignación en un lugar donde puede confundirse fácilmente con un operador condicional. Por ejemplo:
if (c++ = d++) { // EVITARLO! Java lo rechaza
...
}
debería escribirse de la siguiente forma:
if ((c++ = d++) != 0) {
...
}
No utilizar asignaciones embebidas, en un intento de mejorar el rendimiento en tiempo de ejecución. Esto es un trabajo que debe realizar el compilador, y actualmente, rara vez es una ayuda. Por ejemplo:
d = (a = b + c) + r; // EVITARLO!
debería escribirse de la siguiente forma:
a = b + c;
d = a + r;
Paréntesis
Es siempre una buena idea el uso abundante de paréntesis en expresiones que involucren a varios operadores para evitar los problemas generados por la precedencia de operadores. Incluso aunque la precedencia de los operadores parezca clara al programador, es posible que no lo sea tanto para otros, por lo que se debe asumir que esa precedencia no es bien conocida por todo el mundo. Y además, los paréntesis son gratis, así que pueden usarse libremente.
if (a == b && c == d) // EVITARLO!
if ((a == b) && (c == d)) // CORRECTO
Retorno de valores
Intentar que la estructura del programa coincida con la intención, sin abundar en lo ya evidente.
if (expresionBooleana) {
return TRUE;
} else {
return FALSE;
}
debería escribirse de la siguiente forma:
return expresionBooleana;
De forma semejante,
if (condicion) {
return x;
}
return y;
debería escribirse de la siguiente forma:
return (condicion ? x : y);
Expresión antes del ? de una condición
Si una expresión conteniendo un operador binario se coloca antes del interrogante en una expresión ternaria del tipo ¿: debería colocarse entre paréntesis. Por ejemplo:
(x >= 0) ? x : -x
Comentarios especiales
Utilizar XXX, o alguna otra secuencia convenida, como comentario e indicador de algo que se está probando y que aparentemente funciona. Usar FIXME, o alguna otra secuencia convenida, como comentario e indicador de algo que se está probando y funciona mal, erráticamente o se está mejorando.
|
