Estandares Java SFS

SERVICIO DE MANTENIMIENTO Y
DESARROLLO DE SISTEMAS
(Servicio de Fbrica de Software)
Estndares para el lenguaje

de programacin
JAVA
GMD S.A. - SFS
Versin 1.0
Actualizado a
Diciembre del 2015
DOCUMENTO DE ESTANDARES DE JAVA
HISTORIAL DE LAS REVISIONES

te
m
Versin
Fecha
Autor
Descripcin
Estado
Responsable de
Revisin y/o
Aprobacin
01
0.1
29/12/2015
MA, MC
Versin Final
Revisado
JC
Autores:
MA: Michel Aguilar
MC: Milagros Camaa
Revisor GMD:
JC: Jose Chilet
Rev.: 1.0
Fecha Efectiva: 29/12/2015
Pg. 2 de 31
ndice
1
1.1
2
Introduccin............................................................................................................. 5
Por qu convenciones de cdigo.............................................................................. 5
Organizacin de los ficheros....................................................................................... 5
2.1
Comentarios de comienzo....................................................................................... 5
2.2
Sentencias package e import................................................................................... 6
2.3
Declaraciones de clases e interfaces........................................................................6
Indentacin.............................................................................................................. 8
3.1
Longitud de la lnea................................................................................................ 8
3.2
Rompiendo lneas.................................................................................................. 8
Comentarios........................................................................................................... 10
4.1
Formatos de los comentarios de implementacin......................................................10
4.2
Comentarios de bloque......................................................................................... 10
4.3
Comentarios de una lnea..................................................................................... 11
4.4
Comentarios de remolque..................................................................................... 11
4.5
Comentarios de fin de lnea...................................................................................12
4.6
Comentarios de documentacin.............................................................................13
Declaraciones......................................................................................................... 13
5.1
Cantidad por lnea................................................................................................ 13
5.2
Inicializacin........................................................................................................ 14
5.3
Colocacin.......................................................................................................... 14
5.4
Declaraciones de class e interfaces........................................................................15
Sentencias............................................................................................................. 16
6.1
Sentencias simples.............................................................................................. 16
6.2
Sentencias compuestas........................................................................................ 17
6.3
Sentencias de retorno........................................................................................... 17
6.4
Sentencias if, if-else, if else-if.................................................................................18
6.5
Sentencias for..................................................................................................... 19
6.6
Sentencia while................................................................................................... 20
6.7
Sentencias do-while............................................................................................. 21
6.8
Sentencias switch............................................................................................... 21
6.9
Sentencias try-catch............................................................................................. 22
7
7.1
Espacios en blanco................................................................................................. 23
Lneas en blanco................................................................................................. 23
Rev.: 1.0
Pg. 3 de 31
Espacios en blanco.............................................................................................. 24
7.2
8
Convenciones de nombres....................................................................................... 25
Hbitos de programacin......................................................................................... 27
9.1
Referencias a variables y mtodos de clase.............................................................27
9.2
Constantes......................................................................................................... 27
Asignaciones de variables.................................................................................. 27
9.2.1
10
Hbitos varios..................................................................................................... 28
10.1
Parntesis........................................................................................................... 28
10.2
Valores de retorno................................................................................................ 29
10.3
Expresiones antes de '?' en el operador condicional..................................................29
11
Ejemplos de cdigo.............................................................................................. 30
11.1
Ejemplo de fichero fuente Java..............................................................................30
Ejemplo de fichero fuente Java................................................................................................30
Rev.: 1.0
Pg. 4 de 31
Introduccin
El Servicio de Software Factory establece un estndar de codificacin a fin de que la

programacin se haga de forma ordenada en base a un patrn definido mediante las
notaciones que permitan generar soluciones de software ms legibles y mayor
facilidad para el mantenimiento.
El presente documento contienen las definiciones considerados para la programacin
con Java, el cual busca usar tcnicas de codificacin slidas y realizar buenas
prcticas de programacin con vistas a generar un cdigo de alta calidad que es de
gran importancia para la calidad del software y obtener un buen rendimiento. Adems,
si se aplica de forma continua el estndar de codificacin bien definido, se utilizan
tcnicas de programacin apropiadas, y, posteriormente, se efectan revisiones de
rutinas, caben muchas posibilidades de que un proyecto de software se convierta en
un sistema de software fcil de comprender y de mantener.
1.1
Por qu convenciones de cdigo
Las convenciones de cdigo son importantes para los programadores, por un gran
nmero de razones:
o El 80% del coste del cdigo de un programa va a su
mantenimiento.
o Casi ningn software lo mantiene toda su vida el auto original.
o Las convenciones de cdigo mejoran la lectura del software,
permitiendo entender cdigo nuevo mucho ms rpidamente y ms a
fondo.
o Si distribuyes tu cdigo fuente como un producto, necesitas
asegurarte de que est bien hecho y presentado como cualquier otro
producto.
o Para que funcionen las convenciones, cada persona que escribe software
debe seguir la convencin. Todos.
2
2.1
Organizacin de los ficheros

Comentarios de comienzo
NOMBRE DEL
RECURSO
DEFINICIN
Rev.: 1.0
Comentario de comienzo
Todos los ficheros fuente deben comenzar con un
comentario en el que se lista el nombre de la clase,
informacin de la versin, fecha, y copyright:
Pg. 5 de 31
/*
* Nombre de la clase
*
* Informacion de la version
*
* Fecha
*
* Copyright
*/
EJEMPLOS
2.2
Sentencias package e import
NOMBRE DEL
RECURSO
DEFINICIN
Sentencias package e import

La primera lnea no-comentario de los ficheros fuente Java es la
sentencia package. Despus de esta, pueden seguir varias
sentencias import. Por ejemplo:
NOTACION
La primera lnea de cdigo JAVA en las clases Java es la

sentencia de declaracin del package al que pertenece dicha
clase, el que indica donde ir el archivo compilado dentro del
proyecto Web.
Los paquetes deben ser nombrados en minsculas.
Las estructuras de los paquetes deben tener una definicin dentro
de las notaciones al igual que las carpetas del proyecto.
Sintaxis:
pe.gob.onp.[wwww].[xxxx].[yyyy]
Donde:
pais.tipo de institucion.nombre de la empresa. es la estructura
bsica que debe tener toda aplicacin de ONP
[wwww][xxxx][yyyy] nombre de paquetes.
package java.awt;
EJEMPLOS
2.3
import java.awt.peer.CanvasPeer;
Declaraciones de clases e interfaces
La siguiente tabla describe las partes de la declaracin de una clase o interface, en

el orden en que deberan aparecer.
Rev.: 1.0
Pg. 6 de 31
Partes de la
declaracin de una
clase o interface
1
Comentario de
documentacin de la
clase o interface
(/**...*/)
Notas
Ver "Comentarios de documentacin" en la pgina

13 para ms informacin sobre lo que debe
aparecer en este comentario.
Sentencia class o
interface
Comentario de
implementacin de la
clase o interface si fuera
necesario (/*...*/)
Este comentario debe contener cualquier

informacin aplicable a toda la clase o interface
que no era apropiada para estar en los
comentarios de documentacin de la clase o
interface.
Variables de clase
(static)
Primero las variables de clase public,

despus las protected, despus las de
nivel de paquete (sin modificador de
acceso) , y despes las private.
Variables de instancia
Primero las public, despus las protected,

despus las de nivel de paquete (sin modificador
de acceso), y despus las private.
Constructores
7
Mtodos
Rev.: 1.0
Estos mtodos se deben agrupar por funcionalidad

ms que por visin o accesibilidad. Por ejemplo, un
mtodo de clase privado puede estar entre dos
mtodos pblicos de instancia. El objetivo es hacer
el cdigo ms legible y comprensible.
Pg. 7 de 31
3
3.1
Indentacin
Longitud de la lnea
Evitar las lneas de ms de 80 caracteres, ya que no son manejadas bien

por muchas terminales y herramientas.
Nota: Ejemplos para uso en la documentacin deben tener una longitud
inferior, generalmente no ms de 70 caracteres.
3.2
Rompiendo lneas
NOMBRE
DEL
RECURSO
Rompiendo lneas
Cuando una expresin no entre en una lnea, romperla de

acuerdo con estos principios:
o Romper despus de una coma.
o Romper antes de un operador.
DEFINICIN
o Preferir roturas de alto nivel (ms a la derecha que el

"padre") que de bajo nivel (ms a la izquierda que el
"padre").
o Alinear la nueva lnea con el comienzo de la expresin
al mismo nivel de la lnea anterior.
o Si las reglas anteriores llevan a cdigo confuso o a
cdigo que se aglutina en el margen derecho,
indentar justo 8 espacios en su lugar.
Ejemplos de cmo romper la llamada a un mtodo:

EJEMPLOS
unMetodo(expresionLarga1, expresionLarga2, expresionLarga3,

expresionLarga4, expresionLarga5);
var = unMetodo1(expresionLarga1,
unMetodo2(expresionLarga2,
expresionLarga3));
Rev.: 1.0
Pg. 8 de 31
Ahora dos ejemplos de ruptura de lneas en expresiones

aritmticas. Se prefiere el primero, ya que el salto de lnea ocurre
fuera de la expresin que encierra los parntesis.
EJEMPLO 2
nombreLargo1 = nombreLargo2 * (nombreLargo3 + nombreLargo4

- nombreLargo5) + 4 * nombreLargo6;//PREFERIDA
nombreLargo1 = nombreLargo2 * (nombreLargo3 + nombreLargo4
- nombreLargo) + 4 * nombreLargo6;
//EVITAR
Ahora dos ejemplos de indentacin de declaraciones de

mtodos. El primero es el caso convencional. El segundo
conducira la segunda y la tercera lnea demasiado hacia la
izquierda con la indentacin convencional, as que en su
lugar se usan 8 espacios de indentacin.
//INDENTACION CONVENCIONAL
unMetodo(int anArg, Object anotherArg, String yetAnotherArg,
Object andStillAnother) {
EJEMPLO 3
...
}
//INDENTACION DE 8 ESPACIOS PARA EVITAR GRANDES INDENTACIONES
private static synchronized metodoDeNombreMuyLargo(int unArg,
Object otroArg, String todaviaOtroArg,
Object unOtroMas) {
...
}
EJEMPLO 4
Saltar de lneas por sentencias if deber seguir generalmente la

regla de los 8 espacios, ya que la indentacin convencional (4
espacios) hace difcil ver el cuerpo. Por ejemplo:
//NO USAR ESTA INDENTACION
if ((condicion1 && condicion2)
|| (condicion3 && condicion4)
||!(condicion5 && condicion6)) { //MALOS SALTOS
hacerAlgo();
//HACEN ESTA LINEA FACIL DE OLVIDAR
}
Rev.: 1.0
Pg. 9 de 31
//USAR ESTA IDENTACION

if ((condicion1 && condicion2)
|| (condicion3 && condicion4)
||!(condicion5 && condicion6)) {
hacerAlgo();
}
//O USAR ESTA
if ((condicion1 && condicion2) || (condicion3 && condicion4)
||!(condicion5 && condicion6)) {
hacerAlgo();
}
Hay tres formas aceptables de formatear expresiones ternarias:

alpha = (unaLargaExpresionBooleana) ? beta : gamma;
alpha = (unaLargaExpresionBooleana) ? beta

: gamma;
EJEMPLO 5
alpha = (unaLargaExpresionBooleana)
? beta
: gamma;
4
4.1
Comentarios
Formatos de los comentarios de implementacin
Los programas pueden tener cuatro estilos de comentarios de implementacin: de

bloque, de una lnea, de remolque, y de fin de lnea
4.2
Comentarios de bloque
NOMBRE DEL
RECURSO
Rev.: 1.0
Comentarios de bloque
Pg. 10 de 31
DEFINICIN
Los comentarios de bloque se usan para dar descripciones de

ficheros, mtodos, estructuras de datos y algoritmos. Los
comentarios de bloque se podrn usar al comienzo de cada
fichero o antes de cada mtodo. Tambin se pueden usar en otro
lugares, tales como el interior de los mtodos. Los comentarios de
bloque en el interior de una funcin o mtodo deben ser
indentados al mismo nivel que el cdigo que describen.
Un cometario de bloque debe ir precedido por una lnea en
blanco que lo separe del resto del cdigo.
EJEMPLOS
4.3
/*
* Aqui hay un comentario de bloque.
*/
Comentarios de una lnea
NOMBRE DEL
RECURSO
DEFINICIN
Comentarios de una lnea

Pueden aparecer comentarios cortos de una nica lnea al nivel
del cdigo que siguen. Si un comentario no se puede escribir en
una lnea, debe seguir el formato de los comentarios de bloque.
Un comentario de una sola lnea debe ir precedido de una lnea
en blanco.
if (condicion) {
/* Cdigo de la condicion. */
...
EJEMPLOS
}
4.4
Comentarios de remolque
NOMBRE DEL
RECURSO
DEFINICIN
Rev.: 1.0
Comentarios de remolque
Pueden aparecer comentarios muy pequeos en la misma lnea
que describen, pero deben ser movidos lo suficientemente lejos
para separarlos de las sentencias. Si ms de un comentario
corto aparece en el mismo trozo de cdigo, deben ser indentados
Pg. 11 de 31
con la misma profundidad.
Aqu un ejemplo de comentario de remolque:

EJEMPLOS
4.5
if (a == 2) {
return TRUE;
} else {
return isPrime(a);
}
/* caso especial */
/* caso gerenal */
Comentarios de fin de lnea
NOMBRE DEL
RECURSO
DEFINICIN
Comentarios de fin de lnea
El delimitador de comentario // puede convertir en comentario

una lnea completa o una parte de una lnea. No debe ser
usado para hacer comentarios de varias lneas consecutivas;
sin embargo, puede usarse en lneas consecutivas para
comentar secciones de cdigo. Aqu tienes ejemplos de los tres
estilos:
if (foo > 1) {
// Hacer algo.
...
}
else {
return false;
}
// Explicar aqui por que.
EJEMPLOS
//if (bar > 1) {
//
//
// Hacer algo.
//
...
//}
//else {
//
return false;
//}
Rev.: 1.0
Pg. 12 de 31
4.6
Comentarios de documentacin
NOMBRE DEL
RECURSO
DEFINICIN
Comentarios de documentacin
Los comentarios de documentacin describen clases Java,

interfaces, constructores, mtodos y atributos. Cada comentario
de documentacin se encierra con los delimitadores de
comentarios /**...*/, con un comentario por clase, interface o
miembro (mtodo o atributo). Este comentario debe aparecer
justo antes de la declaracin:
/**
* La clase Ejemplo ofrece ...
*/
public class Ejemplo { ...
EJEMPLOS
Darse cuenta de que las clases e interfaces de alto nivel son est
indentadas, mientras que sus miembros los estn. La primera
lnea de un comentario de documentacin (/**) para clases e
interfaces no est indentada, subsecuentes lneas tienen cada
una un espacio de indentacin (para alinear verticalmente los
asteriscos). Los miembros, incluidos los constructores, tienen
cuatro espacios para la primera lnea y 5 para las siguientes.
NOTA
Si se necesita dar informacin sobre una clase, interface,

variable o mtodo que no es apropiada para la documentacin,
usar un comentario de implementacin de o de una lnea para
comentarlo inmediatamente despus de la declaracin. Por
ejemplo, detalles de implementacin de una clase deben ir en un
comentario de implementacin de bloque siguiendo a la
sentencia class, no en el comentario de documentacin de la
clase.
Los comentarios de documentacin no deben colocarse en
el interior de la definicin de un mtodo o constructor, ya
que Java asocia los comentarios de documentacin con la
primera declaracin despus del comentario.
5
5.1
Declaraciones
Cantidad por lnea
Rev.: 1.0
Pg. 13 de 31
NOMBRE DEL
RECURSO
DEFINICIN
Cantidad por lnea
Se recomienda una declaracin por lnea, ya que facilita los

comentarios.
Se prefiere
int nivel; // nivel de indentacin
int tam;
// tamao de la tabla
EJEMPLOS
Antes que
int level, size; //Evitar
No poner diferentes tipos en la misma lnea. Ejemplo:

int foo,
fooarray[]; //ERROR!
Nota
Los ejemplos anteriores usan un espacio entre el tipo y el
identificador. Una alternativa aceptable es usar tabuladores, por
ejemplo:
int
int
Object
level;
//nivel de
indentacin
size;
//tamao de la tabla
currentEntry; //entrada de la tabla seleccionada
actualmente
5.2 Inicializacin
Intentar inicializar las variables locales donde se declaran. La nica razn para no
inicializar una variable donde se declara es si el valor inicial depende de algunos
clculos que deben ocurrir.
5.3
Colocacin
NOMBRE DEL
RECURSO
Colocacin
DEFINICIN
Poner las declaraciones solo al principio

bloque es cualquier cdigo encerrado por
esperar al primer uso para declararlas;
programadores no preavisados y limitar
Rev.: 1.0
de los bloques (un

llaves "{" y "}".) No
puede confundir a
la portabilidad del
Pg. 14 de 31
cdigo dentro de su mbito de visibilidad.

o La excepcin de la regla son los ndices de bucles for,
que en Java se pueden declarar en la sentencia for :
o Evitar las declaraciones duplicadas tanto en niveles
globales como en locales, porque generan confusin.
//AL COMIENSO DE BLOQUE DECLARAR

void miMetodo() {
int int1 = 0;
// comienzo del bloque del mtodo
if (condicion) {
int int2 = 0; // comienzo del bloque del "if"
...
}
}
//LA EXCEPCION A LA REGLA
for (int i = 0; i < maximoVueltas; i++) { ... }
EJEMPLOS 1
//DECLARACIONES DUPLICADAS
int cuenta; // EVITAR!
...
miMetodo()
{
if (condicion) {
int cuenta = 0;
...
// EVITAR!
}
...
}
5.4
Declaraciones de class e interfaces
NOMBRE DEL
RECURSO
DEFINICIN
Declaraciones de class e interfaces

Al codificar clases e interfaces de Java, se siguen las siguientes
reglas de formato:
o Ningn espacio en blanco entre el nombre de un
Rev.: 1.0
Pg. 15 de 31
mtodo y el parntesis "(" que abre su lista de

parmetros
o La llave de apertura "{" aparece al final de la misma lnea
de la sentencia declaracin
o La llave de cierre "}" empieza una nueva lnea
indentada para ajustarse a su sentencia de apertura
correspondiente, excepto cuando no existen
sentencias entre ambas, que debe aparecer
inmediatamente despus de la de apertura "{"
class Ejemplo extends Object {

int ivar1;
int ivar2;
Ejemplo(int i, int j) {
ivar1 = i;
ivar2 = j;
}
EJEMPLOS
int metodoVacio() {}
...
}
o Los mtodos se separan con una lnea en blanco
6
6.1
Sentencias
Sentencias simples
NOMBRE DEL
RECURSO
Sentencias simples
Cada lnea debe contener como mucho una sentencia.
NOTACION
argv++;
argc--;
argv++; argc--;
// Correcto
// Correcto
// EVITAR!
Forma correcta de declarar:

EJEMPLOS
Rev.: 1.0
numero++;
numero--;
Pg. 16 de 31
6.2
Sentencias compuestas
NOMBRE DEL
RECURSO
Sentencias compuestas
DEFINICIN
Las sentencias compuestas son sentencias que contienen listas

de sentencias encerradas entre llaves "{ sentencias } ".
EJEMPLOS
6.3
Las sentencias encerradas deben indentarse un nivel ms que

la sentencia compuesta.
La llave de apertura se debe poner al final de la lnea que
comienza la sentencia compuesta; la llave de cierre debe
empezar una nueva lnea y ser indentada al mismo nivel que el
principio de la sentencia compuesta.
Las llaves se usan en todas las sentencias, incluso las simples,
cuando forman parte de una estructura de control, como en las
sentencias if-else o for. Esto hace ms sencillo aadir
sentencias sin incluir bugs accidentalmente por olvidar las
llaves.
Sentencias de retorno
NOMBRE DEL
RECURSO
Sentencias de retorno
Una sentencia return con un valor no debe usar parntesis a
menos que hagan el valor de retorno ms obvio de alguna
manera.
EJEMPLOS
return;
return miDiscoDuro.size();
return (tamanyo ? tamanyo : tamanyoPorDefecto);
6.4 Sentencias if, if-else, if else-if

NOMBRE DEL
RECURSO
Rev.: 1.0
Sentencias if, if-else, if else-if
Pg. 17 de 31
La estructura if se denomina estructura de seleccin nica porque

ejecuta un bloque de sentencias solo cuando cumple la condicin
del if. Si la condicin es verdadera se ejecuta el bloque de
sentencias. Si la condicin es falsa, el flujo del programa contina
en la sentencia inmediatamente posterior al if.
DEFINICIN
La estructura if-else se denomina de seleccin doble porque

selecciona entre dos bloques de sentencias mutuamente
excluyentes. Si se cumple la condicin, se ejecuta el bloque de
sentenciado asociado al if. Si la condicin no se cumple, entonces
se ejecuta el bloque de sentencias asociado al else.
La estructura if-else-if se puede aplicar en los mismos casos en que
se utiliza un if-else anidado. Esta estructura permite recibir la forma
abreviada las condiciones de un if-else anidado.
if:
if(condicion) {
sentencias;
}
If-else:
if(condicion) {
sentencia verdadera;
}
else {
sentencia falsa;
}
NOTACION
If-else-if:
if(condicion) {
sentencia;
}else if (condicion) {
sentencia;
}else{
sentencia;
}
Nota: Las sentencias if usan siempre llaves {}. Evitar la siguiente

forma, propensa a errores:
if (condicion) //EVITAR! ESTO OMITE LAS LLAVES {}!
sentencia;
Rev.: 1.0
Pg. 18 de 31
if:
if(calificacion == 10) {
System.out.println(Matrcula de Honor);
}
If-else:
if(numero % 2 == 0) {
System.out.println(El nmero es par);
}
else {
System.out.println(El nmero es impar);
}
EJEMPLOS
If-else-if:
if(calificacion == 10) {
System.out.println(Matrcula de Honor);
} else if (calificacion == 9) {
System.out.println(Sobresaliente);
System.out.println(Notable);
System.out.println(Bien);
System.out.println(Aprobado);
} else {
System.out.println(Suspenso);
}
6.5
Sentencias for
NOMBRE DEL
RECURSO
Sentencias for
DEFINICIN
La estructura de repeticin for repite el bloque de sentencias

mientras la condicin for es verdadera. Un for es un caso
particular de la estructura while. Solo se debe utilizar cuando se
sabe el nmero de veces que se debe repetir el bloque de
sentencias.
Rev.: 1.0
Pg. 19 de 31
Una sentencia for debe tener la siguiente forma:

for (inicializacion; condicion; actualizacion) {
sentencias;
}
Una sentencia for vaca (una en la que todo el trabajo

se hace en las clusulas de inicializacin, condicin, y
actualizacin) debe tener la siguiente forma:
NOTACION
for (inicializacion; condicion; actualizacion);
Al usar el operador coma en la clusula de inicializacin o

actualizacin de una sentencia for, evitar la complejidad de usar
ms de tres variables. Si se necesita, usar sentencias separadas
antes de bucle for (para la clusula de inicializacin) o al final del
bucle (para la clusula de actualizacin).
EJEMPLOS
6.6
for(int i=1; i <=n; i++){

factorial = factorial * i;
}
Sentencia while
NOMBRE DEL
RECURSO
Sentencia while
DEFINICIN
La estructura de repeticin while repite el bloque de sentencias

mientras la condicin del while es verdadera
La condicin del while se escribe obligatoriamente entre
parntesis.
Una sentencia while debe tener la siguiente forma:
NOTACION
while(condicion) {
sentencias;
}
Una sentencia while vaca debe tener la siguiente forma:

while (condicion);
Rev.: 1.0
Pg. 20 de 31
EJEMPLOS
6.7
Sentencias do-while
NOMBRE DEL
RECURSO
DEFINICIN
NOTACION
EJEMPLOS
6.8
while (i<=n) {
factorial = factorial*i;
i++;
}
Sentencias do-while
La estructura de repeticin de do-while ejecuta el doble de
sentencias al menos una vez. Despus comprueba la condicin y
repite el bloque de sentencias mientras la condicin es verdadera.
Una sentencia do-while debe tener la siguiente forma:
do {
sentencias;
} while (condicion);
do {
factorial = factorial*i;
i++;
} while (i<=n);
Sentencias switch
NOMBRE DEL
RECURSO
DEFINICIN
NOTACION
Sentencias switch
La estructura switch es una estructura de seleccin mltiple que
permite seleccionar un bloque de sentencias entre varios casos. En
cierto modo, es parecido a una estructura de if-else anidados. La
diferencia est en que la seleccin del bloque de sentencias
depende de la evaluacin de una expresin que se compra por
igualdad con cada uno de los casos.
La estructura switch consta de una expresin y una serie de
etiquetas case y una opcin default. La sentencia break indica l final
de la ejecucin del switch.
Una sentencia switch debe tener la siguiente forma:
switch (condicion) {
case ABC:
Rev.: 1.0
Pg. 21 de 31
sentencias;
/* este caso se propaga */
case DEF:
sentencias;
break;
case XYZ:
sentencias;
break;
default:
sentencias;
break;
}
Cada sentencia switch debe incluir un caso por defecto. El break en

el caso por defecto es redundante, pero prev que se propague por
error si luego se aade otro caso.
switch (categoriaProfesional) {
case A :
System.out.print(Socio);
break;
case B:
System.out.print(Senior);
break;
EJEMPLOS
case C:
System.out.print(Junior);
break;
default:
System.out.print(!Indefinida!);
break;
}
6.9
Sentencias try-catch
NOMBRE DEL
RECURSO
DEFINICIN
NOTACION
Sentencias try-catch
Las sentencias try-catch se utilizan para atrapar las excepciones
que se producen durante la ejecucin del programa:
FileNotFoundException, IOException o Exception. De esta forma se
atrapan los errores que se producen cuando el fichero de datos no
existe o cuando hay un problema de lectura o escritura en el fichero .
Una sentencia try-catch debe tener la siguiente forma:
try {
sentencias;
} catch (ExceptionClass e) {
Rev.: 1.0
Pg. 22 de 31
sentencias;
}
Una sentencia try-catch puede ir seguida de un

finally, cuya ejecucin se ejecutar independientemente
de que el bloque try se haya completado con xito o no.
try {
sentencias;
} catch (ExceptionClass e) {
sentencias;
} finally {
sentencias;
}
EJEMPLOS
7
7.1
try {
FileOutputStream salida = new
FileOutputStream(nombrefichero);
ObjectOutputStream objsalida = new
ObjectOutputStream(salida);
} catch (FileNotFoundException e) {
System.out.println (El fichero no existe!);
}
Espacios en blanco
Lneas en blanco
NOMBRE DEL
RECURSO
Lneas en blanco
DEFINICIN
Las lneas en blanco mejoran la facilidad de lectura separando

secciones de cdigo que estn lgicamente relacionadas.
NOTACION
EJEMPLOS
Se deben usar siempre dos lneas en blanco en las siguientes

circunstancias:
o Entre las secciones de un fichero fuente
o Entre las definiciones de clases e interfaces
Se debe usar siempre una lnea en blanco en
las siguientes circunstancias:
o Entre mtodos
o Entre las variables locales de un mtodo y su primera
sentencia
Rev.: 1.0
Pg. 23 de 31
o Antes de un comentario de bloque o de un comentario de

una lnea
Entre las distintas secciones lgicas de un mtodo para facilitar la
lectura.
7.2
Espacios en blanco
NOMBRE DEL
RECURSO
Espacios en blanco
Debe aparecer un espacio en blanco despus de cada coma en las

listas de argumentos. Todos los operadores binarios excepto . se
DEFINICIN
deben separar de sus operandos con espacios en blanco. Los

espacios en blanco no deben separar los operadores unarios,
incremento ("++") y decremento ("--") de sus operandos.
Una palabra clave del lenguaje seguida por un parntesis
debe separarse por un espacio.
while (true) {
...
}
a += c + d;
a = (a + b) / (c * d);
EJEMPLOS
while (d++ == s++) {

n++;
}
printSize("el tamao es " + foo + "\n");
Las expresiones en una sentencia for se deben separar con

espacios en blanco.
for (expr1; expr2; expr3)
Los "Cast"s deben ir seguidos de un espacio en blanco.

miMetodo((byte) unNumero, (Object) x);
miMetodo((int) (cp + 5), ((int) (i + 3)) + 1);
Rev.: 1.0
Pg. 24 de 31
8 Convenciones de nombres
Las convenciones de nombres hacen los programas ms entendibles hacindolos
ms fcil de leer. Tambin pueden dar informacin sobre la funcin de un
identificador, por ejemplo, cuando es una constante, un paquete, o una clase, que
puede ser til para entender el cdigo.
Tipos de
identific
adores
Reglas para nombras
El prefijo del nombre de un paquete se

escribe siempre con letras ASCII en
minsculas, y debe ser uno de los nombres
de dominio de alto nivel, actualmente com,
edu, gov, mil, net, org, o uno de los cdigos
ingleses de dos letras que identifican cada
pas como se especifica en el ISO Standard
3166,1981.
Paquetes
Clases
Interfaces
Rev.: 1.0
Los subsecuentes componentes del nombre

del paquete variarn de acuerdo a las
convenciones de nombres internas de cada
organizacin. Dichas convenciones pueden
especificar que algunos nombres de los
directorios correspondan a divisiones,
departamentos, proyectos o mquinas.
Los nombres de las clases deben ser

sustantivos, cuando son compuestos tendrn
la primera letra de cada palabra que lo forma en
maysculas. Intentar mantener los nombres de
las clases simples y descriptivas. Usar palabras
completas, evitar acrnimos y abreviaturas (a
no ser que la abreviatura sea mucho ms
conocida que el nombre completo, como URL o
HTML).
Los nombres de las interfaces siguen la

misma regla que las clases.
Ejemplos
com.sun.eng
com.apple.quicktime.v2
edu.cmu.cs.bovik.cheese
class Cliente;
class ImagenAnimada;
interface
ObjetoPersistente;
interface Almacen;
Pg. 25 de 31
Mtodos
Los mtodos deben ser verbos, cuando son

compuestos tendrn la primera letra en
minscula, y la primera letra de las
siguientes palabras que lo forma en
mayscula.
Excepto las constantes, todas las instancias

y variables de clase o mtodo empezarn
con minscula. Las palabras internas que lo
forman (si son compuestas) empiezan con su
primera letra en maysculas. Los nombres
de variables no deben empezar con los
caracteres subguin "_" o signo del dlar "$",
aunque ambos estn permitidos por el
lenguaje.
Variables
Constantes
9
9.1
Los nombres de las variables deben ser

cortos pero con significado. La eleccin del
nombre de una variable debe ser un
mnemnico, designado para indicar a un
observador casual su funcin. Los nombres
de variables de un solo carcter se deben
evitar, excepto para variables ndices
temporales.
Nombres
comunes
para
variables temporales son i, j, k, m, y n para
enteros; c, d, y e para caracteres.
Los nombres de las variables declaradas como

constantes deben ir totalmente en maysculas
separando las palabras con un subguin ("_").
(Las constantes ANSI se deben evitar, para
facilitar su depuracin.)
ejecutar();
ejecutarRapido();
cogerFondo();
int
i;
char
c;
float
miAnchura;
static final int

ANCHURA_MINIMA =4;
static final int
ANCHURA_MAXIMA =999;
static final int
COGER_LA_CPU = 1;
Hbitos de programacin
Referencias a variables y mtodos de clase
Rev.: 1.0
Pg. 26 de 31
NOMBRE DEL
RECURSO
DEFINICIN
Referencias a variables y mtodos de clase

No hacer ninguna variable de instancia o clase pblica sin una
buena razn. A menudo las variables de instancia no necesitan
ser asignadas/consultadas explcitamente, a menudo esto sucede
como efecto lateral de llamadas a mtodos.
Evitar usar un objeto para acceder a una variable o mtodo de
clase (static). Usar el nombre de la clase en su lugar.
EJEMPLOS
9.2
metodoDeClase();
UnaClase.metodoDeClase();
unObjeto.metodoDeClase();
//OK
//OK
//EVITAR!
Constantes
9.2.1 Asignaciones de variables
NOMBRE DEL
RECURSO
DEFINICIN
Asignaciones de variables
Las constantes numricas (literales) no se deben codificar
directamente, excepto -1, 0, y 1, que pueden aparecer en un
bucle for como contadores.
Evitar asignar el mismo valor a varias variables en la misma
sentencia. Es difcil de leer.
EJEMPLOS
fooBar.fChar = barFoo.lchar = 'c'; // EVITAR!
No usar el operador de asignacin en un lugar donde se pueda

confundir con el de igualdad.
if (c++ = d++) {
...
}
// EVITAR! (Java lo rechaza)
Se debe escribir:
if ((c++ = d++) != 0) {
...
}
No usar asignacin embebidas como un intento de mejorar

Rev.: 1.0
Pg. 27 de 31
el rendimiento en tiempo de ejecucin. Ese es el trabajo del

compilador.
d = (a = b + c) + r;
// EVITAR!
Se debe escribir:
a = b + c;
d = a + r;
10 Hbitos varios
10.1 Parntesis
NOMBRE DEL
RECURSO
DEFINICIN
EJEMPLOS
Parntesis
En general es una buena idea usar parntesis en expresiones que
implican distintos operadores para evitar problemas con el orden de
precedencia de los operadores. Incluso s parece claro el orden de
precedencia de los operadores, podra no ser as para otros, no se
debe asumir que otros programadores conozcan el orden de
precedencia.
if (a == b && c == d)
// EVITAR!
if ((a == b) && (c == d)) // CORRECTO
10.2 Valores de retorno
NOMBRE DEL
RECURSO
Valores de retorno
DEFINICIN
Intentar hacer que la estructura del programa se ajuste a su

intencin.
Rev.: 1.0
Pg. 28 de 31
Ajuste De Identacion
if (expresionBooleana) {
return true;
} else {
return false;
}
En su lugar se debe escribir

EJEMPLOS
return expressionBooleana;
Similarmente,
if (condicion) {
return x;
}
return y;
Se debe escribir:
return (condicion ? x : y);
10.3 Expresiones antes de '?' en el operador condicional
NOMBRE DEL
RECURSO
Expresiones antes de '?' en el operador condicional
DEFINICIN
Si una expresin contiene un operador binario antes de ? en el

operador ternario ?: , se debe colocar entre parntesis. Ejemplo:
EJEMPLOS
(x >= 0) ? x : -x;
11 Ejemplos de cdigo
11.1 Ejemplo de fichero fuente Java
NOMBRE DEL
RECURSO
Rev.: 1.0
Ejemplo de fichero fuente Java

Pg. 29 de 31
DEFINICIN
El siguiente ejemplo muestra como formatear un fichero fuente

Java que contiene una sola clase pblica. Los interfaces se
formatean similarmente.
EJEMPLOS
/*
* @(#)Bla.java
1.82 99/03/18
*
* Copyright (c) 1994-1999 Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
* All rights reserved.
*
* Ms informacin y descripcin del Copyright.
*
*/
package java.bla;
import java.bla.blabla.BlaBla;
/**
* La descripcin de la clase viene aqui.
*
* @version
datos de la versin (numero y fecha)
* @author
Nombre Apellido
*/
public class Bla extends OtraClase {
/*Un comentario de implemantacin de la clase viene aqu.*/
/** El comentario de documentacin de claseVar1 */
public static int claseVar1;
/**
* El comentario de documentacin de classVar2
* ocupa ms de una lnea
*/
private static Object claseVar2;
/** Comentario de documentacin de instanciaVar1 */
public Object instanciaVar1;
protected int instanciaVar2;
private Object[] instanciaVar3;
/**
* ...Comentario de documentacin del constructor Bla...
*/
public Bla() {
// ...aqu viene la implementacin...
/**
* ...Comentario de documentacin del mtodo hacerAlgo...
*/
public void hacerAlgo() {
Rev.: 1.0
Pg. 30 de 31

}
/**
* ...Comentario de documentacin de hacerOtraCosa...
* @param unParametro descripcin
*/
public void hacerOtraCosa(Object unParametro) {
}
Rev.: 1.0
Pg. 31 de 31

Estandares Java SFS

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Estandares Java SFS

Transféré par

Droits d'auteur :

Formats disponibles

SERVICIO DE MANTENIMIENTO Y

Estndares para el lenguaje

DOCUMENTO DE ESTANDARES DE JAVA

HISTORIAL DE LAS REVISIONES

Fecha Efectiva: 29/12/2015

DOCUMENTO DE ESTANDARES DE JAVA

Sentencias package e import................................................................................... 6

Declaraciones de clases e interfaces........................................................................6

Formatos de los comentarios de implementacin......................................................10

Comentarios de una lnea..................................................................................... 11

Comentarios de fin de lnea...................................................................................12

Cantidad por lnea................................................................................................ 13

Declaraciones de class e interfaces........................................................................15

Sentencias if, if-else, if else-if.................................................................................18

Fecha Efectiva: 29/12/2015

DOCUMENTO DE ESTANDARES DE JAVA

Referencias a variables y mtodos de clase.............................................................27

Expresiones antes de '?' en el operador condicional..................................................29

Ejemplo de fichero fuente Java..............................................................................30

Ejemplo de fichero fuente Java................................................................................................30

Fecha Efectiva: 29/12/2015

DOCUMENTO DE ESTANDARES DE JAVA

El Servicio de Software Factory establece un estndar de codificacin a fin de que la

Por qu convenciones de cdigo

Organizacin de los ficheros

DOCUMENTO DE ESTANDARES DE JAVA

Sentencias package e import

Sentencias package e import

La primera lnea de cdigo JAVA en las clases Java es la

Declaraciones de clases e interfaces

La siguiente tabla describe las partes de la declaracin de una clase o interface, en

Fecha Efectiva: 29/12/2015

DOCUMENTO DE ESTANDARES DE JAVA

Ver "Comentarios de documentacin" en la pgina

Este comentario debe contener cualquier

Primero las variables de clase public,

Primero las public, despus las protected,

Estos mtodos se deben agrupar por funcionalidad

Fecha Efectiva: 29/12/2015

DOCUMENTO DE ESTANDARES DE JAVA

Evitar las lneas de ms de 80 caracteres, ya que no son manejadas bien

Cuando una expresin no entre en una lnea, romperla de

o Preferir roturas de alto nivel (ms a la derecha que el

Ejemplos de cmo romper la llamada a un mtodo:

unMetodo(expresionLarga1, expresionLarga2, expresionLarga3,

Fecha Efectiva: 29/12/2015

DOCUMENTO DE ESTANDARES DE JAVA

Ahora dos ejemplos de ruptura de lneas en expresiones

nombreLargo1 = nombreLargo2 * (nombreLargo3 + nombreLargo4

Ahora dos ejemplos de indentacin de declaraciones de

Saltar de lneas por sentencias if deber seguir generalmente la

//HACEN ESTA LINEA FACIL DE OLVIDAR

Fecha Efectiva: 29/12/2015

DOCUMENTO DE ESTANDARES DE JAVA

//USAR ESTA IDENTACION

Hay tres formas aceptables de formatear expresiones ternarias:

alpha = (unaLargaExpresionBooleana) ? beta

Los programas pueden tener cuatro estilos de comentarios de implementacin: de

Fecha Efectiva: 29/12/2015

DOCUMENTO DE ESTANDARES DE JAVA

Los comentarios de bloque se usan para dar descripciones de

Comentarios de una lnea

Comentarios de una lnea

DOCUMENTO DE ESTANDARES DE JAVA