los estándares de programación para clases Java y páginas
JSP, porque generalmente se parte programando sin ninguna estructura, y
esto desencadena en que en una Empresa se tienen distintos “estilos” de
programación, lo cual hace más difícil entender el programa realizado
por otra persona.
Los estándares están definidos por Sun en los
siguientes lugares:
http://java.sun.com/docs/codeconv/
http://java.sun.com/developer/technicalArticles/javaserverpages/code_convention/
Nosotros vamos a presentar un resumen de estos
estándares mediante una plantilla base de los 2 módulos básicos de
programación, un clase Java, y un página JSP, estas plantillas pueden
servir a un departamento de Control de Calidad para verificar que los
programas se ciñen al estándar Java, pero la mejor forma de seguir estos
estándares es utilizar un IDE (ambiente de desarrollo) como Eclipse, o
usar verificadores de código automático.
Otra cosa que muestran estas plantillas es la forma
de comentar los fuentes, para que se pueda obtener el JavaDoc
correspondiente (documentación automática de Java).
Plantilla de Codificación Java.
Esta plantilla Java se puede extender a otras
clases como Servlets.
Una clase Java tiene el siguiente orden:
- Comentarios de Inicio
- Definición Package
- Declaraciones de Import
- Declaraciones de la Clase
4.1. Comentario
Documentación de la Clase
4.2. Estamento class
4.3. Atributos o
Variables Estaticas
4.3.1.
public
4.3.2.
protected
4.3.3.
private
4.4.
Atributos
4.4.1.
public
4.4.2.
protected
4.4.3.
private
4.5.
Constructores
4.6.
Metodos
La siguiente plantilla resume los principales
estándares de codificación propuestos por Sun.
/*
*
@(#)Plantilla.java version 1.01 2007/01/01
* Copyright (c) 2007 SOA agenda.
*/
package com.soaagenda.ejemplos;
import com.soaagenda.librerias.*;
//import de librerias y clases a utilizar
/**
* Descripción de la Clase,
ejemplo: Plantilla que muestra
* principales estándares
de codificación.
*
* @version 1.01 01 Ene 2007
* @author
SOA Team
*/
public class Plantilla extends ClasePadre {
/* Comentario de
implementacion, ejemplo: Esta clase no tiene funcionalidades . */
/** atributo1
comentario documentacion atributo
* puede
ser de mas de una linea
*/
public static int
atributo1; //comentario linea: primero las variables estaticas,
//en orden 1.-public,
2.-protected, 3.-private
/** atributo2
comentario documentacion */
public Integer
atributo2; //luego var de instancia, mismo orden 1.-public,
2.-protected, 3.-private
/** atributo3
comentario documentacion */
protected Integer
atributo3;
/**
* Descripción para el
constructor.
*/
public Plantilla() {
// …implementacion …
}
/**
* Descripción de un
metodo.
* @param par1
descripcion primer parametro
* @param par2
descripcion segundo parametro
* @return descripcion
de salida (return) del metodo, en caso que no es void
*/
public
String hacerAlgo(Integer par1, String par2) {
int entero = 0; //una declaración de variable
por linea y al inicio del {bloque}
/* A continuacion
mostraremos ejemplos de la identación y formato de las distintas
sentencias Java*/
if (entero == 0) {
int entero2 =
1; //una declaración de variable por linea y al inicio del {bloque}
} else if (entero == 1) {
entero++; // solo un
estamento por linea
} else {
entero–;
}
for
(int i=0; i < 5; i++){
entero=i;
}
while (entero >
0){
entero–;
}
do {
entero++;
}
while (entero < 10);
switch
(entero) {
case
0:
entero++;
break;
case
2:
entero–;
break;
default:
entero=1;
break;
}
try {
entero=2/entero;
} catch (Exception
e) {
System.out.println(”error
división”);
}
finally {
entero=1;
}
return (”Ok”);
}
}
Buenas Practicas Básicas de Programación Java.
- Acceso a Instancia y Variables de
Clase: Evitar el uso de variable publicas.
- Asignación Variables: Evitar
asignar mas de una variable en un misma sentencia.
- a = b = c +1; //evitar esto!!
- if (c++ == d++) { //evitar
esto!!
- Uso de Constantes: Usar
siempre cantantes para valores fijos.
- if (c == 1) { //evitar esto!!
- if ( c == ESTADO_ACTIVO ) {
//asi si!!
- Uso Paréntesis: Usar explícitamente para definir precedencia, para
mejor entendimiento del programador.
- if ( a = = b && c = =
d || e == f ) { //evitar esto!! - if ( ( (a = = b)
&& (c = = d) ) || (e = = f) ) {
//así si!, no hay forma de entender precedencia.
- Valores de Retorno: Evitar “return” de condiciones simples.
- if (booleanExpression) {
//evitar esto!!
return
true;
}else{
return false;
}
- return booleanExpression;
//esto si!! - if (condition) { //evitar
esto!!
return x;
} else {
return Y;
}
- return ( (condicion)
? x : y); //esto si!!
- Expresiones
condicionales ‘?’: La condición
debería ir siempre entre paréntesis.
- x >=0 ? x : -x; //evitar
esto!! - ( x >=0 ) ? x : -x; //así
si!!
- Clases como parámetros
de entrada: de forma de
reducir la cantidad de parámetros de entrada de un método, de ser
orientado a objetos, y hacer mas estable el método, por ejemplo para un
método “actualizarCliente()” puede que ahora solo necesitemos
actualizar 2 variables “nombre” y “email”, y solo esas pasamos como
parametros, pero si mañana necesitamos una tercera, debemos
cambiar todas las llamadas al método del sistema, por otro lado si
pasamos una clase Cliente, solo se cambia la clase internamente.
- public void actualizaCliente(
String rut, String nombre, String email) //evitar esto!! - public void actualizaCliente(
ClaseCliente cliente) // esto si!! es Orientado Objetos
Plantilla de Codificación JSP.
El orden dentro de una pagina JSP es:
- Comentarios de Inicio
- Directivas JSP
- Directivas Librerías de Tags
- Declaraciones JSP
- HTML y tags JSP
La siguiente plantilla muestra los principales
estándares JSP, esta plantilla se centra en los estándares JSP, y no
incluye estándares HTML.
<%–
- Author:
SOA Team
- Date: 28
Marzo 2007
-
- Derechos Reservados Soa
Agenda.
- @(#)
- Description: Estos son
los “Comentarios de Inicio” de la Plantilla Ejemplo Estandares JSP.
–%>
<%– 2.-Directivas JSP
–%>
<%@ page session=”true”
import=”java.util.*”
errorPage=”../principal/paginaError.jsp”
%>
<%– 3.-Directivas Librerias Tags
–%>
<%@ taglib
uri=”/WEB-INF/jsp/libreriatags.tld” prefix=”tags” %> <%– Aqui van
las librerias de tags –%>
<%– 4.-Declaraciones JSP: instancias
variables, y metodos de la JSP –%>
<%
private
int entero;
public int transformaEntero(float
Numero) {
//implementaciòn
}
%>
<%– 5.-HTML y tags JSP –%>
<html>
<head>
<title>Titulo
de la Pagina que aparece en el Browser</title>
</head>
<body>
<jsp:useBean
id=”cliente” class=”com.SOAagenda.segurosvida.Cliente” /> <%–
declaracion de un javabeans –%>
<h1>
Rut:
<tagsSAgenda:formateaRut
value=”${cliente.getRut()}” /> <%– un tag que usa al beans –%>
</h1>
<hr
/>
<table
border=”1″ cellpadding=”5″>
<%– Un if en JSP y ejemplo identación
–%>
<% if (entero
== 0) { %>
<tr>
<td>Nombre:</td>
<td><%=
cliente.getNombre()%></td> <%– expresion explicita –
%>
</tr>
<%
} %>
<tr>
<td>Apellidos:</td>
<%– expresion Javabeasn muestra –%>
<td><jsp:getProperty
name=”cliente” property=”apellidos”/></td>
</tr>
</table>
<%– incluir otra pagina –%>
<%@ include
file=”../principales/piePagina.jsp” %>
</body>
</html>
Buenas Practicas de Programación JSP.
- Solo Lógica de Presentación:
Una pagina JSP debe evitar tener lógica de negocio, y lo que
“nunca” debería tener es lógica de acceso a base de datos, se debe
tener ojalá solo lógica de presentación, esto es, solo instrucciones de
creacion de JavaBeans, instrucciones para mostrar sus atributos
(getters) y uso de funciones de presentación (como
transformaciones), también puede incluir cualquier estamento
condicional (if, else, while, do while, switch).
· Una pagina jsp debe evitar tener definición de
métodos:
public
int procesarPago() { //esto NO!!
//implementación
}
· Debe evitarse tener llamadas a
método de negocio:
cliente.calculaSaldo();//esto
NO!!
Si puede
tener llamadas a getters de un bean:
cliente.getSaldo();
//esto SI!!.
· Debe evitarse tener grandes porciones de código
Java, que no tengan que ver con lógica de presentación , por ejemplo si
dentro de los tags jsp”<% %>” hay sobre 10 líneas, este código ya
es “sospechoso” de incluir lógica de negocio, lo mas probable es que
dicha lógica deba ir dentro de un Servlet, o clase Java:
<%
//…mas
de 10 líneas entre estos tags JSP , es Sospechoso!!
%>
Que sucede entonces con aquellos metodos que ya no existen en Cliente?, bueno será nuestro trabajo buscar quienes tienen la responsabilidad de resolver esas cuestiones. Lo importante aquí es que Cliente atienda sus responsabilidades directas, aquellas en las que es experto.
Lo primero que se aprecia es la asignación correcta de responsabilidades, hemos asimilados los principios 
Tenemos ahora un modelo mas elegante, mas cohesivo, poco acoplado.
me tomaría mucho tiempo y sería demasiado pesado. La mayoría de las siguientes páginas web están disponibles en español.