Java

Gua de programacin
Edicin 1.2

06/08/2007 GFD

Edicin 1.1

12/04/2007 GFD

Edicin 1.0

09/04/2007 - GFD

Gua de programacin java

versin 1.0 - 09/04/2007 - GFD

Indice de Contenidos
1 Descripcin General.......................................................................................................................... 3
2 Estructura de archivos de cdigo fuente........................................................................................4
2.1 Comentarios Iniciales......................................................................................................................................... 4
2.2 Sentencias package e import............................................................................................................................. 4
2.3 Declaraciones de clase e interfaz...................................................................................................................... 4

3 Guas generales de codificacin......................................................................................................5

3.1 Tabulacin.......................................................................................................................................................... 5
3.2 Longitud de lnea................................................................................................................................................ 5
3.2.1 Ruptura de lneas (Wrapping lines)...........................................................................................................5

4 Comentarios...................................................................................................................................... 6
4.1 comentarios de implementacin........................................................................................................................ 7
4.1.1 Comentarios de bloque............................................................................................................................. 7
4.1.2 Comentarios de una sola lnea.................................................................................................................. 7
4.1.3 Comentarios por detrs............................................................................................................................. 7
4.1.4 Comentarios de final de lnea.................................................................................................................... 8
4.2 comentarios de documentacin......................................................................................................................... 8
4.2.1 Javadoc..................................................................................................................................................... 8

5 Guas especificas de codificacin JAVA.........................................................................................9

5.1
5.2
5.3
5.4
5.5

Declaraciones.................................................................................................................................................... 9
Inicializacin..................................................................................................................................................... 10
Colocacin....................................................................................................................................................... 10
Declaraciones de clase e interfaz.................................................................................................................... 11
Sentencias....................................................................................................................................................... 11
5.5.1 Sentencias simples................................................................................................................................. 11
5.5.2 Sentencias compuestas.......................................................................................................................... 11
5.5.3 Sentencias return.................................................................................................................................... 11
5.5.4 Sentencias if, if-else, if-else-if-else..........................................................................................................12
5.5.5 Sentencias for......................................................................................................................................... 12
5.5.6 Sentencias while..................................................................................................................................... 13
5.5.7 Sentencias do-while................................................................................................................................ 13
5.5.8 Sentencias switch.................................................................................................................................... 13
5.5.9 Sentencias try-catch................................................................................................................................ 13
5.6 Espacios en blanco.......................................................................................................................................... 14
5.6.1 Lneas en blanco..................................................................................................................................... 14
5.6.2 Espacios en blanco................................................................................................................................. 14
5.7 Convenciones de nombrado............................................................................................................................ 15
5.7.1 Paquetes................................................................................................................................................. 15
5.7.2 Clases..................................................................................................................................................... 15
5.7.3 Interfaces................................................................................................................................................. 15
5.7.4 Mtodos................................................................................................................................................... 15
5.7.5 Variables................................................................................................................................................. 15
5.7.6 Constantes.............................................................................................................................................. 16
5.8 Prcticas de varias........................................................................................................................................... 16
5.8.1 Proporcionar acceso a variables de clase e instancia............................................................................16
5.8.2 Referenciar variables y mtodos de clase..............................................................................................16
5.8.3 Generales................................................................................................................................................ 16
5.8.4 Constantes.............................................................................................................................................. 16
5.8.5 Asignaciones de variables....................................................................................................................... 17
5.8.6 Parntesis............................................................................................................................................... 17
5.8.7 Devolver valores...................................................................................................................................... 17
5.8.8 Expresiones antes de '?' en el operador condicional..............................................................................18
5.8.9 Comentarios especiales.......................................................................................................................... 18
5.8.10 Main....................................................................................................................................................... 18

pg. 2

Java

Gua de programacin
El presente documento pretende ser una gua normativa de practicas de buena formas de programacin para lenguaje java.

1 Descripcin General
El presente documento especificar una serie de practicas recomendadas para la codificacin de proyectos en java, esto no
posee ms pretensiones que el de ser una gua descriptiva quedando de absoluta responsabilidad del programador la
aplicacin con ms o menos rigidez los temas que aqu se expresen. El contenido de este documento esta basado en las
normas descritas por SUN para java y solo fueron discriminadas algunos puntos para poder llegar a un criterio nico y en
pequeos casos se complemento con informacin adicional considerada valiosa.

2 Estructura de archivos de cdigo fuente

Los Archivos de cdigo fuente Java tienen la siguiente estructura:

Comentarios iniciales

Sentencias package e import

Declaraciones de clase y/o interfaz

2.1 Comentarios Iniciales

Todos los archivos de cdigo fuente deberan comenzar con un comentario que muestre el nombre de la clase, informacin
sobre la versin, la fecha y el autor
/*
* Nombre de la clase
* Informacin sobre la versin
* Fecha
* Copyright
*/

2.2 Sentencias package e import

La primera lnea que no sea un comentario de todos los archivos de cdigo fuente Java es una sentencia package. Despus,
puede haber sentencias import. Por ejemplo:
package cl.directemar.meteo.pronosticos;
import java.util.List;
import java.net.*;

El primer componente de un nombre de paquete nico estara siempre escrito en letras ASCII minsculas y sera uno de los
nombres de dominio de nivel superior (actualmente com, edu, gov, mil, net, org uno de los cdigos de pas de dos letras,
como se especifica en el estndar ISO 3166).
Minimice las formas * en los import, Sea preciso acerca de lo que esta importando, Chequee que todo los import sean
usados. De esta forma evita que otros lectores de su cdigo gasten mucho tiempo y tengas dificultades para entender sus
contextos y dependencias.

2.3 Declaraciones de clase e interfaz

El siguiente listado describe las partes de una declaracin de clase o interfaz, en el orden que deben aparecer. En Ejemplo
de Cdigo Fuente Java hay un ejemplo que incluye comentarios.
1.

Comentario de documentacin de la clase/interfaz: (/** ? */) Ver punto 4 para detalle de comentarios.

2.

Sentencia class interface.

3.

Comentario de la implementacin de la clase/interfaz: si fuera necesario (/* ? */) Este comentario debera contener
cualquier informacin relativa a toda la clase o interfaz, que no sea apropiada para el comentario de documentacin.

4.

Variables de clase (estticas) (static): Primero las variables pblicas (public), luego las protegidas (protected),
despus las de paquete (sin modificador de acceso) y por ltimo las privadas (private).

5.

Variables de instancia: Primero las variables pblicas (public), luego las protegidas (protected), despus las de
paquete (sin modificador de acceso) y por ltimo las privadas (private).

6.

Constructores

7.

Mtodos, Estos mtodos deberan estar agrupados por funcionalidad en lugar de por mbito o accesibilidad.
Por ejemplo, un mtodo esttico privado puede estar entre dos mtodos de instancia pblicos.

3 Guas generales de codificacin

En este capitulo se explicarn gua de programacin aplicables no tan solo a java, sino normas generales que ayudan a dar
forma a un cdigo entendible y mantenible.

3.1 Tabulacin
La unidad de tabulacin deberan ser cuatro espacios.

3.2 Longitud de lnea

Evitar las lneas de ms de 80 caracteres, esto ayuda a evitar problemas con diffs, patches, CVS history y annotations.

3.2.1 Ruptura de lneas (Wrapping lines)

Cuando una expresin no cabe en una nica lnea, se debe romper de acuerdo a estos principios generales:

Romper despus de una coma.

Romper antes de un operador.

Preferir las rupturas de alto nivel a las de bajo nivel.

Alinear la nueva lnea con el principio de la expresin al mismo nivel que la lnea anterior.

Aqu hay algunos ejemplos de llamadas a mtodos en varias lneas:

someMethod(longExpression1, longExpression2, longExpression3,
longExpression4, longExpression5);
var = someMethod1(longExpression1,
someMethod2(longExpression2,
longExpression3));

A continuacin hay dos ejemplos de cmo tabular declaraciones de mtodos.

El primero es el caso convencional.
El segundo dejara la segunda y tercera lneas demasiado pegadas al margen derecho si se usara la tabulacin convencional,
por eso en cambio se tabula slo con 8 espacios.
// Tabulacin convencional
someMethod(int
yetAnotherArg,

anArg,

Object

Object andStillAnother) {
?
}

anotherArg,

String

// Usar 8 espacios para evitar pegarse al margen derecho

private static synchronized horkingLongMethodName(int anArg,
Object anotherArg, String yetAnotherArg,
Object andStillAnother) {
?
}

La ruptura de lneas para las sentencias if debera usar generalmente la regla de los 8 espacios, ya que la tabulacin
convencional (4 espacios) dificulta la lectura del cuerpo de la sentencia if.
Por ejemplo:
// NO UTILIZAR ESTA TABULACION
if ((condition1 && condition2)
|| (condition3 && condition4)
||!(condition5 && condition6)) { // MALAS RUPTURAS
doSomethingAboutIt(); // HACEN QUE ESTA LINEA SE PIERDA
}

// USAR ESTA TABULACION EN SU LUGAR

if ((condition1 && condition2)
|| (condition3 && condition4)
||!(condition5 && condition6)) {
doSomethingAboutIt();
}

// O USAR ESTA OTRA

if ((condition1 && condition2) || (condition3 && condition4)
||!(condition5 && condition6)) {
doSomethingAboutIt();
}

4 Comentarios
Los comentarios son un punto muy importante en lo que a un proyecto de software se refiere, por eso se dedicara este
captulo a analizar estos, si bien hay puntos comunes en la forma de comentar distintos tipos de lenguajes, no se pretende
generalizar y se intentar mantener el foco directamente sobre el lenguaje Java que es nuestro objetivo.
Los programas en Java pueden tener dos tipos de comentarios:

comentarios de implementacin

comentarios de documentacin.

Los comentarios deberan contener solamente informacin que sea relevante para la lectura y comprensin del programa.

Por ejemplo, informacin sobre cmo se construye el paquete correspondiente o en qu directorio reside, no debera ser
incluida como comentario.

4.1 comentarios de implementacin

Los comentarios de implementacin son como los de C++, los cuales estn delimitados por /* ? */ y //. Los comentarios de
implementacin estn destinados a comentar el cdigo o para comentarios sobre la implementacin en particular.
Los programas pueden tener cuatro estilos de comentarios de implementacin:

de bloque

de una sola lnea

por detrs

de final de lnea.

4.1.1 Comentarios de bloque

Los comentarios de bloque se usan para proporcionar descripciones de archivos, mtodos, estructuras de datos y algoritmos.
Los comentarios de bloque pueden ser usados al principio de cada fichero y antes de cada mtodo. Tambin pueden ser
usados en otros lugares, como en el interior de los mtodos. Los comentarios de bloque dentro de una funcin o mtodo
deberan estar tabulados al mismo nivel que el cdigo que describen.
Un comentario de bloque debera estar precedido por una lnea en blanco para apartarlo del resto del cdigo.
/*
* Este es un comentario de bloque
*/

4.1.2 Comentarios de una sola lnea

Los comentarios cortos pueden aparecer en una sola lnea tabulada al nivel del cdigo que le sigue. Si un comentario no
puede ser escrito en una sola lnea, debera seguir el formato del comentario de bloque.
Un comentario de una sola linea debera ser precedido por una lnea en blanco. A continuacin, un comentario de una sola
lnea en un cdigo Java:
if (condition) {
/* Tratar la condicin. */
?
}

4.1.3 Comentarios por detrs

Los comentarios muy cortos pueden aparecer en la misma que el cdigo que describen, pero deben estar suficientemente
separados de las sentencias. Si en un trozo de cdigo aparece ms de un comentario corto, todos deberan tabularse al
mismo nivel.
Un ejemplo de comentario por detrs en un cdigo Java:
if (a == 2) {
return true;
} else {
return isPrime(a);
}

/* caso especial */
/* funciona solo con impares */

4.1.4 Comentarios de final de lnea

El delimitador de comentario // puede comentar una lnea completa o slo una parte de una lnea. No debera ser usado en
mltiples lneas consecutivas para comentarios de texto. Sin embargo, puede ser utilizado en mltiples lneas consecutivas
para comentar secciones de cdigo.
A continuacin, ejemplos de los tres estilos:
if (foo > 1) {
// Do a double-flip.
?
}
else {
return false;
// Explicar por qu aqu.
}
//if (bar > 1) {
//
//
// Do a triple-flip.
//
?
//}
//else {
//
return false;
//}

4.2 comentarios de documentacin

Los comentarios de documentacin (conocidos como "comentarios Javadoc") son especficos de Java y estn delimitados por
/** ? */. Los comentarios de documentacin se pueden extraer a ficheros HTML usando la herramienta javadoc y/o HTML,
PDF y otros con Doxygen. Los comentarios de documentacin estn destinados a describir la especificacin del cdigo,
desde una perspectiva independiente de la implementacin, para ser ledos por desarrolladores que pueden no tener
necesariamente el cdigo fuente a mano.

4.2.1 Javadoc
Javadoc es un estandart dentro de la programacin java , en si se puede decir que es un protocolo que define uns et de
comandos (o marcas) que permiten que un procesador javadoc las interprete generando un documento descriptivo de el o los
cdigos procesados, este documento no profundizara en este tema sino que dar una breve descripcin de los comandos
ms usados, para ms detalles se puede ver en http://java.sun.com/j2se/javadoc/writingdoccomments/index.html cuya lectura
es altamente recomendada.
Comando
Descripcin
@see

Especifica una referencia a otro item documentado (Clase, Interface, Mtodo)

@version

Especifica la versin del item en que se asocie.

@author

Especifica el autor de cdigo asociado

@deprecated

Especifica que el item asociado se encuentra deprecado , por ende no debiera ser utilizado.

@param

Especifica los detalles de un parmetro de mtodo, se acompaa del nombre del parmetro y una
breve descripcin

@return

Especifica el retorno de un mtodo.

{@link}

Tag usado para incluir un link dentro de la documentacin.

Un punto especial a notar es como documentar paquetes y/o directorios, dado que son elementos implcitos que no poseen
lugar para agregar documentacin de forma natural, para esto javadoc nos da la posibilidad de agregar dentro de la
estructura de directorios de nuestros fuentes archivos de texto de nombre package.html en los se puede incluir la
documentacin asociada al directorio o package que defina esa ubicacin, lo exigido es que dentro del archivo se incluya el

tag <body></body> dado que javadoc buscar el contenido de este tag para incluir su informacin en la documentacin a
generar.
Ejemplos:

/**
* A class representing a window on the screen.
* For example:
* <pre>
* Window win = new Window(parent);
* win.show();
* </pre>
*
* @see
awt.BaseWindow
* @see
awt.Button
* @version 1.2 31 Jan 1995
* @author Bozo the Clown
**/
class Window extends BaseWindow {
...
}
/**
* The current number of elements.
* must be non-negative, and less than or equal to capacity.
**/
protected int count_;
/**
* Insert element at front of the sequence
*
* @param element the element to add
* @return condition:
* <PRE>
* size() == PREV(this).size()+1 &&
* at(0).equals(element) &&
* foreach (int i in 1..size()-1) at(i).equals(PREV(this).at(i-1))
* </PRE>
**/
public void

addFirst(Object element);

5 Guas especificas de codificacin JAVA

5.1 Declaraciones
Se recomienda una declaracin por lnea ya que fomenta los comentarios.
int level; // nivel de tabulacin
int size; // tamao de la tabla
es preferido antes que

int level, size;

No poner tipos diferentes en la misma lnea. Por ejemplo:

int foo, fooarray[]; // MAL!
Los ejemplos anteriores usan un espacio entre el tipo y el identificador. Otra alternativa aceptable es usar tabuladores, ej:
int
level;
int
size;
Object currentEntry;

// nivel de tabulacin
// tamao de la tabla
// elemento de la tabla seleccionado

5.2 Inicializacin
Hay que intentar inicializar las variables locales donde se declaren. La nica razn para no inicializar una variable donde se
declara es si el valor inicial depende de algn clculo que debe ocurrir primero.

5.3 Colocacin
Poner las declaraciones slo al principio de los bloques. (Un bloque es cualquier cdigo rodeado por llaves "{" y "}".) No
esperar a declarar las variables hasta su primer uso; puede confundir a un programador y dificultar la portabilidad del cdigo
dentro del mbito.
void myMethod() {
int int1 = 0;
if (condition) {
int int2 = 0;
?
}

// principio del bloque de mtodo

// principio del bloque de "if"

La nica excepcin a esta regla es el ndice de los bucles for, que en Java se puede declarar dentro de la sentencia for:
for (int i = 0; i < maxLoops; i++) { ? }

Evitar declaraciones locales que oculten declaraciones de ms alto nivel. Por ejemplo, no declare el mismo nombre de
variable en un bloque interno:
int count;
?
myMethod() {
if (condition) {
int count = 0;
?
}
?
}

// EVITAR

5.4 Declaraciones de clase e interfaz

Mientras se codifican clases e interfaces Java, se deberan seguir las siguientes reglas de formato:

Ningn espacio entre el nombre del mtodo y el parntesis "(" que abre su lista de parmetros.

La llave de apertura "{" aparece al final de la misma lnea que la sentencia de declaracin.

La llave de cierre "}" comienza una lnea nueva tabulada para coincidir su sentencia de apertura correspondiente,
excepto cuando es un bloque vaco que la llave de cierre "}" debera aparecer inmediatamente despus de la de
apertura "{".

Los mtodos estn separados entre s por una lnea en blanco.

class Sample extends Object {
int ivar1;
int ivar2;
Sample(int i, int j) {
ivar1 = i;
ivar2 = j;
}
int emptyMethod() {}
?
}

5.5 Sentencias
5.5.1 Sentencias simples
Cada lnea debera contener una sentencia como mucho. Por ejemplo:
argv++;
argc--;
argv++; argc--;

// Correcto
// Correcto
// EVITAR!

5.5.2 Sentencias compuestas

Las sentencias compuestas son sentencias que contienen una lista de sentencias encerradas entre llaves "{" y "}".

Las sentencias internas deberan estar tabuladas un nivel ms que la sentencia compuesta.

La llave de apertura debera estar al final de la lnea que comienza la sentencia compuesta; la llave de cierre debera
estar en una nueva lnea y estar tabulada al nivel del principio de la sentencia compuesta.

Las llaves se usan en todas las sentencias compuestas, includas las sentencias nicas, cuando forman parte de
una estructura de control, como una sentencia if-else o un bucle for.

5.5.3 Sentencias return

Una sentencia return con un valor no debera usar parntesis a menos que, de alguna manera, haga el valor devuelto ms
obvio. Por ejemplo:

return;
return myDisk.size();
return (size > 0 ? size : defaultSize);

5.5.4 Sentencias if, if-else, if-else-if-else

El tipo de sentencias if-else debera tener el siguiente formato:
if (condicin) {
sentencias;
}
if (condicin) {
sentencias;
} else {
sentencias;
}
if (condicin) {
sentencias;
} else if (condicin) {
sentencias;
} else {
sentencias;
}

Las sentencias if siempre llevan llaves {}. Evitar la siguiente forma, propensa a errores:
if (condicin) // EVITAR OMITIR LAS LLAVES! {}
sentencias;

5.5.5 Sentencias for

Una sentencia for debera tener el siguiente formato:
for (inicializacin; condicin; actualizacin) {
sentencias;
}

Una sentencia for vaca (aquella en la que todo el trabajo se hace en las clusulas de inicializacin, condicin y actualizacin)
debera tener el siguiente formato:
for (inicializacin; condicin; actualizacin);
Cuando se use el operador coma en la clusula de inicializacin o actualizacin, evitar la complejidad de utilizar ms de tres
variables. Si se necesita, usar sentencias separadas antes del bucle for (para la clusula de inicializacin) o al final del bucle
(para la clusula de actualizacin).

5.5.6 Sentencias while

Una sentencia while debera tener el siguiente formato:
while (condicin) {
sentencias;
}
Una sentencia while vaca debera tener el siguiente formato:
while (condicin);

5.5.7 Sentencias do-while

Una sentencia do-while debera tener el siguiente formato:
do {
sentencias;
} while (condicin);

5.5.8 Sentencias switch

Una sentencia switch debera tener el siguiente formato:
switch (condicin) {
case ABC:
sentencias;
/* continua con el siguiente */
case DEF:
sentencias;
break;
case XYZ:
sentencias;
break;
default:
sentencias;
break;
}

Cada vez que un caso contina con el siguiente (no incluye una sentencia break), se aade un comentario donde ira la
sentencia break. Esto se muestra en el ejemplo anterior con el comentario /* continua con el siguiente */.
Todas las sentencias switch deberan incluir un caso por defecto. El break en el caso por defecto es redundante, pero
previene un error de continuar con el siguiente si ms adelante se incluye otro caso.

5.5.9 Sentencias try-catch

Una sentencia try-catch debera tener el siguiente formato:

try {
sentencias;
} catch (ExceptionClass e) {
sentencias;
}

Una sentencia try-catch puede venir seguida de una sentencia finally, la cual se ejecuta siempre independientemente de que
el bloque try se halla completado correctamente o no.
try {
sentencias;
} catch (ExceptionClass e) {
sentencias;
} finally {
sentencias;
}

5.6 Espacios en blanco

5.6.1 Lneas en blanco
Las lneas en blanco mejoran la legibilidad resaltando secciones de cdigo que estn lgicamente relacionadas.
En las siguientes circunstancias, siempre se deberan usar dos lneas en blanco:

Entre secciones de un fichero fuente.

Entre definiciones de clases e interfaces.

En las siguientes circunstancias, siempre se debera usar una lnea en blanco:

Entre mtodos.

Entre las variables locales de un mtodo y su primera sentencia.

Antes de un comentario de bloque o de una sola lnea.

Entre las secciones lgicas de un mtodo, para mejorar la legibilidad.

5.6.2 Espacios en blanco

Los espacios en blanco deberan usarse en las siguientes circunstancias:

Una palabra clave seguida por un parntesis debera estar separado por un espacio. Por ejemplo:
while (true) {
?
}
Ntese que entre el nombre de un mtodo y sus parntesis no debe haber espacio en blanco. Esto ayuda a
distinguir entre palabras claves y llamadas a mtodos.

En las listas de argumentos, debera haber un espacio despus de cada coma.

Todos los operadores binarios, excepto el operador punto (.) deberan estar separados de sus operandos por
espacios. Los operadores unarios (incremento ++, decremento --, complemento a 1 -) nunca deberan estar
separados de sus operandos. Por ejemplo:
a += c + d;
a = (a + b) / (c * d);
while (d++ = s++) {
n++;
}
print("size is " + foo + "\n");

Las expresiones de una sentencia for deberan estar separadas por espacios en blanco. Por ejemplo:

for (expr1; expr2; expr3)

Las conversiones de tipo (cast) deberan estar seguidas de un espacio en blanco. Por ejemplo:
myMethod((byte) aNum, (Object) x);
myMethod((int) (cp + 5), ((int) (i + 3)) + 1);

5.7 Convenciones de nombrado

Las convenciones de nombrado hacen los programas ms comprensibles hacindolos ms fciles de leer. Tambin pueden
dar informacin acerca de la funcin del identificador (por ejemplo, si se trata de una constante, un paquete o una clase), que
puede ayudar a entender el cdigo.
Si en los nombres se utilizan abreviaciones o Acrnimos no deben ser usados en maysculas.

5.7.1 Paquetes
El prefijo de un nombre de paquete nico se escribe siempre en letras ASCII minsculas y debera ser uno de los nombres de
dominio de nivel superior (actualmente com, edu, gov, mil, net, org uno de los cdigos de pas de dos letras, como se
especifica en el estndar ISO 3166).
Los siguientes componentes del nombre del paquete varan de acuerdo a las propias convenciones de nombrado internas de
las organizaciones. Dichas convenciones pueden especificar que ciertos componentes de nombre de directorio sean divisin,
departamento, proyecto, mquina o nombres de usuario.
package
package
package
package

com.sun.eng;
com.apple.quicktime.v2;
edu.cmu.cs.bovik.cheese;
es.nom.jpereza;

5.7.2 Clases
Los nombres de clases deberan ser sustantivos, escritos en CamelCase con la primera letra en mayscula. Tratar de
mantener los nombres de clases simples y descriptivos. Usar palabras completas, evitar acrnimos y abreviaturas (a menos
que la abreviatura sea mucho ms usada que la forma larga, como URL o HTML).
class Raster
class ImageSprite

5.7.3 Interfaces
Los nombres de interfaz deberan ser escritos como los nombres de clases.
interface RasterDelegate
interface Storing

5.7.4 Mtodos
Los nombres de mtodos deberan ser verbos, escritos en CamelCase con la primera letra en minscula.
run();
runFast();
getBackground();

5.7.5 Variables
Todos los nombres de variable deberan estar escritos en CamelCase con la primera letra en minscula. No deberan
comenzar con un caracter de subrayado "_" o un signo de dlar "$", aunque ambos estn permitidos.

Los nombres de variables deberan ser cortos aunque significativos.

La eleccin de un nombre de variable debera ser mnemotcnica, esto es, pensada para indicar la intencin de su uso a un
posible observador ocasional. Se deberan evitar los nombres de variables de un solo carcter excepto para variables
temporales "desechables". Algunos nombres comunes para variables temporales son i, j, k, m y n para nmeros enteros; c, d
y e para caracteres.
int i;
char c;
float myWidth;
String streetName;

5.7.6 Constantes
Los nombres de variables declaradas como constantes de clase deberan estar escritos todo en maysculas separando las
palabras con un underscore (caracter de subrayado) "_".
static final int MIN_WIDTH = 4;
static final int MAX_WIDTH = 999;
static final String DEFAULT_PROTOCOL = "http";

5.8 Prcticas de varias

5.8.1 Proporcionar acceso a variables de clase e instancia
No hacer pblica ninguna variable de clase o instancia sin una buena razn. Con frecuencia, las variables de instancia no
necesitan ser accedidas o modificadas explcitamente.

5.8.2 Referenciar variables y mtodos de clase

Evitar usar una instancia de un objeto para acceder a un mtodo o variable de clase (esttica). Usar el nombre de la clase en
su lugar. Por ejemplo:
classMethod();
AClass.classMethod();
anObject.classMethod();

// OK
// OK
// EVITAR!

5.8.3 Generales
Hay una serie de convenciones generales que con el tiempo se han tomado, pues han demostrado un aporte en el
entendimiento al escribir cdigo, a continuacin se listan algunas de ellas:

El prefijo is debera ser usado para variables y mtodos booleanos.

Nombres complementarios deben ser usados para entidades complementarias ej.

get/set, add/remove, create/destroy, start/stop, insert/delete, increment/decrement,
old/new, begin/end, first/last, up/down, min/max, next/previous, old/new, open/close,
show/hide, suspend/resume, etc.

Constantes asociadas deberan usar un prefijo comn ej.

final int COLOR_RED = 1; final int COLOR_GREEN = 2; final int COLOR_BLUE = 3;

Clases de Exepciones deberan usar sufijo Exception. ej.

class AccessException extends Exception { : }

5.8.4 Constantes
Las constantes numricas no deberan codificarse directamente, excepto -1, 0 y 1, que pueden aparecer en un bucle for
como contadores. Por ejemplo:

static final int MAX_SIZE = 25;

for (i = 0; i < MAX_SIZE; i++)

5.8.5 Asignaciones de variables

Evitar asignar a varias variables el mismo valor en una sola sentencia. Es difcil de leer. Ejemplo:
fooBar.fChar = barFoo.lchar = 'c';

// EVITAR!

No usar el operador de asignacin (=) en un lugar donde se pueda confundir fcilmente con el operador de igualdad (==).
Ejemplo:
if (c++ = d++) {
?
}

// EVITAR! (Java lo rechaza)

debera ser escrito as:

if ((c++ = d++) != 0) {
?
}
No usar asignaciones incrustadas en un intento de mejorar el rendimiento en tiempo de ejecucin. Esto es trabajo del
compilador. Ejemplo:
d = (a = b + c) + r;

// EVITAR!

debera ser escrito as:

a = b + c;
d = a + r;

5.8.6 Parntesis
Es, generalmente, una buena idea usar parntesis generosamente en expresiones que tienen operadores mezclados para
evitar problemas de precedencia de operadores. Incluso si la preferencia de operador parece clara, puede no serlo para otros
(no se debera suponer que otros programadores conocen tan bien la precedencia de operadores como usted).
if (a == b && c == d)
if ((a == b) && (c == d))

// EVITAR!
// BIEN

5.8.7 Devolver valores

Tratar de hacer que la estructura del programa coincida con su propsito. Ejemplo:
if (expresinBoolean) {
return true;
} else {
return false;
}
debera ser escrito as:
return expresinBoolean;

Igualmente,
if (condicin) {
return x;
}
return y;
debera ser escrito as:
return (condicin ? x : y);

5.8.8 Expresiones antes de '?' en el operador condicional

Si una expresin con un operador binario aparece antes de ? en el operador ternario ?:, debera ser puesta entre parntesis.
Ejemplo:
(x >= 0) ? x : -x;

5.8.9 Comentarios especiales

Usar XXX en un comentario para indicar algo que funciona pero que no est del todo bien.
Usar FIXME (fix me, corrgeme) para indicar algo que no funciona y debe corregirse.
Usar TODO (to do, hacer) para indicar algo que no est terminado del todo.

5.8.10 Main
Cuando su cdigo considere partes sensibles , considere escribir una main para la clase principal , El main debera proveer
un unidad de testeo simple o una demo. Es recomendable proveer el ejemplos de uso.