Java - Convenciones para mejor calidad de codigo Parte 1

Nomenclatura:
Clases
El nombre de la clase no debe superar los 20 caracteres de longitud.
class StaffTelecom

Utiliza prefijos comúnmente aceptados:
Abstract, para una clase abstracta que va a ser la base de una nueva jerarquía de herencia.
class AbstractNominas
class NominasSoporte extends AbstractNominas

Utiliza sufijos comúnmente aceptados:
Exception, si se trata de una excepción.
class NominasException extends Exception

Interfaces
Aplica las mismas normas de nomenclatura de las clases, con la siguiente salvedad: el nombre del interface empezará por el prefijo I(Interface), con el fin de distinguir fácilmente clases de interfaces.
interface INominable

Constantes
Utiliza nombres significativos, todo en mayúsculas.
Para nombres compuestos utiliza nombres en mayúsculas separados por el carácter ‘_’.
static final String YES = "yes";
static final int EDAD_LEGAL = 18;
static final String LOGO_EVERIS = "../logo_everis.gif";

Métodos
Evita tener métodos con más de tres parámetros; son más difíciles de mantener.
Puedes reducir el número de parámetros dividiendo el método en varios métodos o utilizando clases auxiliares que engloben varios parámetros.

Utiliza la palabra reservada this para indicar que estás accediendo a un método o variable definido en la misma clase.
Utiliza la palabra reservada super para indicar que estás accediendo a un método o variable definido en una clase antecesora.
Siempre que accedas a una variable o método de clase (static), indícalo con el nombre de la clase.

Agregar versión a los JAVADOCs * @ version %I%, %G%

Favorece la utilización de interfaces en lugar de clases
Un tipo interfaz siempre es más fácil de mantener y reutilizar que un tipo clase.

Si un método tiene un parámetro del tipo interface Collection, signifca que podré invocarlo tanto con un ArrayList o un Vector o cualquier otra clase que implemente el interfaz Collection.

Si un método devuelve un tipo Collection y actualmente estoy devolviendo una instancia de Vector, me resultará bastante sencillo cambiar más adelante la implementación de este método para que devuelva una instancia de un ArrayList.

Estas mismas consideraciones se pueden aplicar a variables locales, de instancia y de clase.
// procesa facturas que vengan en cualquier colección
void procesaFacturas(Collection colFacturas)
{
int iNumFacturas = colFacturas.size();
...
}
...
// he decidido devolver las facturas en un Vector en lugar de un ArrayList //
Collection getFacturas()
{
...
return new Vector(...);
}
void procesa()
{
// puedo invocarlo tanto con un Vector como con un ArrayList
ArrayList arlListaFacturas = ...;
this.procesaFacturas(arlListaFacturas);
...
Vector vecListaFacturas = ...;
this.procesaFacturas(vecListaFacturas);
...
Collection colListaFacturas = getFacturas();
int iNumFacturas = colListaFacturas.size();
}


Utiliza StringBuffer para operar con cadenas
StringBuffer stbTexto = new StringBuffer(100);

stbTexto.append("Don / Dña ");
stbTexto.append(strNombre);
stbTexto.append(" con domicilio en ");
stbTexto.append(strDireccion);

String strTexto = stbTexto.toString();

Conversión de tipos primitivos
Utiliza los métodos de la clase String para convertir tipos primitivos a String en lugar de crear nuevos objetos innecesariamente.
String strPuerto = String.valueOf(iPuerto);

No dupliques literales
Aunque JAVA utilice un pool de literales para evitar duplicados, utiliza constantes String para facilitar el mantenimiento del código.
final static String ERROR_VALIDACION = "Error de validación: ";
...
catch (InvalidParameterException e)
{
logger.log(ERROR_VALIDACION, e.getMessage());
}
catch (IndexOutOfBoundsException e)
{
logger.log(ERROR_VALIDACION, e.getMessage());
}


Excepciones

JAVA tiene tres tipos de excepciones:

Checked Exceptions o excepciones que extienden java.lang.Exception. Son excepciones que JAVA te exige que trates. Por ejemplo si invocas a un método que lanza excepciones de este tipo, JAVA te exige que captures estas excepciones en un bloque try-catch-finally o que las propagues.

Runtime Exceptions o excepciones que extienden java.lang.RuntimeException. Son excepciones que JAVA no te exige que trates, aunque puedes hacerlo si quieres.

Errors o excepciones que extienden java.lang.Error: Son excepciones que JAVA te recomienda que no captures y que se las dejes a la JVM.

Utiliza el tipo adecuado de excepción para cada caso
Como regla general utiliza excepciones de tipo Checked Exceptions para errores recuperables y excepciones de tipo Runtime Exceptions para indicar errores de programación, “incumplimientos” del contrato. Deja a la JVM que sea ella la trate las excepciones de tipo Errors.

Ejemplo de error recuperable (Checked Exceptions):
void buscaFichero(String strNombre, String[] straDirs)
{
for (int i = 0;i <= straDirs.length; i++)
{
String strPath =
straDirs + File.separatorChar + strNombre;

try
{
InputStream insFichero =
new FileInputStream(strPath);
}
catch (FileNotFoundException e)
{
logger.log
(
"Fichero no encontrado en " + strPath +
". Sigo buscando"
);
...

Ejemplo de “incumplimiento de contrato” (Runtime Exceptions):
String setNombre(String pNombre)
{
if (null == pNombre)
{
throw new InvalidParameterException("nombre nulo");
}
...
}
...
setNombre(null); // incumplimiento de "contrato"

No captures excepciones de tipo Errors como java.lang.VirtualMachineError o java.lang.LinkageError. Deja que se propaguen y que sea la JVM quien los trate.

Utiliza las excepciones para situaciones excepcionales
No lances una excepción si puedes comprobar la condición de error de otra forma
/**
* Method getValorPeriodo.
* @param pPeriodo índice del periodo del que se quieren obtener
* los valores
* @return double valor asociado al periodo. Si no se tienen
* datos de este periodo, se devuelve 0
*/
double getValorPeriodo(int pPeriodo)
{
double dValor = 0;

if ((pPeriodo >= 0) && (pPeriodo < this.daValores.length))
{
dValor = this.daValores[pPeriodo];
}
return dValor;
}

Favorece la reutilización de excepciones estándar
Antes de crear un nuevo tipo de excepción, plantéate si no te sirve alguna de las que tiene el API JAVA. Si es así, utiliza este tipo. Tu código será más fácil de entender y mantener.
String setNombre(String pNombre)
{
if (null == pNombre)
{
throw new InvalidParameterException("nombre nulo");
}
...
}

Lanza excepciones con el nivel de información adecuado
Una excepción es consecuencia de un suceso que hay que analizar en detalle. Si este suceso refleja una situación de error, debes facilitar la información necesaria para entender el error, reproducirlo y corregirlo.
Procura que el mensaje asociado a la excepción sea adecuado al nivel de detalle del método que lo lanza. Si capturas una excepción de bajo nivel, trata de propagarla como una excepción de mayor nivel con información más precisa.
void procesaSMS(LineNumberReader lnrFicheroSMS) throws ProcesoException
{
String strLinea = null;
try
{
strLinea = lnrFicheroSMS.readLine();
while (null != strLinea)
{
int iSMS = Integer.parseInt(strLinea);

strLinea = lnrFicheroSMS.readLine();
...
}
catch (NumberFormatException e)
{
throw new ProcesoException
(
"SMS incorrecto (" + strLinea +
" ) en la línea " +
lnrFicheroSMS.getLineNumber() + ": " +
e.getMessage()
);
}
catch (IOException e)
{
throw new ProcesoException
(
"Error leyendo la línea " +
lnrFicheroSMS.getLineNumber() + ": " +
e.getMessage()
);
}
...

No ignores las excepciones
Un método que te lanza una excepción, está tratando de comunicarte algo. No lo ignores!
try
{
InputStream istFicheroFacturas = new FileInputStream( "" );
...
}
catch(FileNotFoundException e)
{
logger.log("Fichero no encontrado:" + e);
}

Bueno esto es todo por ahora...
proximamente estare con la parte 2 con las recomendaciones sobre Threads, Manejo de ficheros y Logs
Espero hayan disfrutado la lectura tanto como yo...
Saludos

Dejen PM o comenten por dudas y/o sugerencias.