lunes, mayo 21, 2001 at 2:00AM sábado, mayo 19, 2001 at 2:00AM viernes, mayo 18, 2001 at 2:00AM martes, mayo 15, 2001 at 2:00AM
Fecha de creación: 15.05.2001
Revisión 1.0 (15.05.2001)
Leo Suarez
leo AT javahispano DOT org
|
¿Ya te has dado un atracón de POO?, ¿Has recopilado toda la documentación necesaria?[1].Pues si es así vamos a ponernos manos a la masa que es lo que nos interesa a todos... sumergirnos en el apasionante mundo de Java ;-). Eso sí, a partir de ahora debemos tener abiertas en el navegador que utilices las especificaciones HTML de la API de Java, o tener uno de esos entornos de desarrollo modernos que te sugiere los métodos de una clase según los escribes.
En este apartado siempre interesa empezar por los típicos programas del estilo Hola Mundo aunque cuando tengas más soltura lo que te recomiendo es que te plantees solucionar algún problema, es decir, programarlo y en los tutoriales (un mazo de ejemplos en el directorio .../java/demo/ y en los tutoriales on-line de Sun) vayas buscando los ejemplos que se asemejen a las clases que quieres realizar. Eso te va a servir de referencia ya que tienes una base de la que partir, te familiarizará con las clases que incorpora la API de Java, sus métodos, etc...
En este artículo nos vamos a centrar en cómo empezar a desarrollar una clase, adquirir un estilo de programación y saber qué son y para qué son las palabras reservadas que casi siempre aparecen en cualquier clase hecha en Java.
Una cosa que siempre cuesta al principio es programar orientado a objetos, esto es, emplear los beneficios de la POO ya que lo que normalmente hacemos es usar los métodos y clases que Java nos ofrece pero con la tendencia de programación estructurada. La principal ventaja de la POO es que cada objeto (clase) hace su cometido y si otra clase necesita algo de ella pues que se lo pida.
Para adoptar este hábito lo más rápido posible, aconsejo utilizar la sentencia package que lo que hace es agrupar las clases bajo un mismo paquete. Esto también nos ayudará a hacer un diseño de la aplicación bastante limpio, pues agruparemos las clases en paquetes según la finalidad que tengan, quedando nuestra aplicación mucho más definida y estructurada si posteriormente queremos hacer modificaciones.
IMPORTANTE: Las clases que pertenecen a un paquete HAY que ponerlas en un directorio del mismo nombre. Por ejemplo, si tenemos las clases A, B, C, D que pertenecen al paquete "misejemplos", entonces, deberán estar alojadas en el directorio "misejemplos" para que el núcleo de Java no nos de un error al compilar la aplicación.
Una última cosa a tener en cuenta es que, aunque no es obligatorio, debemos poner cada clase que creemos en ficheros diferentes y en la primera línea de cada uno poner el paquete al que pertenecen, empaquetar no significa poner todas las clases de una aplicación en un disquete, ni meter todas las clases de un paquete en un fichero, empaquetar es referenciar cada uno de los ficheros (con una única clase) al paquete al que pertenecen por la palabra reservada package.
Con esta sentencia importamos las clases de los paquetes que necesitamos para nuestro código, las de la API de Java y las de creación propia.
Pero, ¿es obligatorio importar las clases? Pues no, pero para que el compilador no te diera el error de que no ha encontrado la clase tal tendrías que poner todo el path de los paquetes de las clases que emplees , por ejemplo, para crear un objeto Frame habría que hacer:
java.awt.Frame frame = new java.awt.Frame();
No te parece un peñazo? ;-), así que usemos import y nos bastará con:
import java.awt.*;Puede parecer que con una clase solo no merece la pena, pero creeme que tu emplearás más de una clase del JDK y que entonces merecerá mucho la pena.
. . .
Frame frame = new Frame();
Algo que es muy habitual encontrar en los fuentes de java que consultamos es que importan el paquete entero (todas sus clases) mediante el comodín *, por ejemplo, import javax.swing.* pero si bien es lo más cómodo te recomiendo que cargues solo las clases que necesitas, por experiencia propia te aseguro que las asimilas antes pues te ves obligado a importarlas.
Esta es una de las propiedades de la POO y hace referencia a la visibilidad que le concedemos a una clase, un método o una variable, es decir, define su accesibilidad. Si te has mirado cualquier tutorial sobre la POO habrás visto que existen diferentes tipos de restricciones pero para que no te hagas un lío a la hora de definir las restricciones de una clase y de sus métodos y atributos ten en cuenta la siguiente distinción:
| Lista 1: Restricciones de visibilidad |
Su propio nombre indica que lo que viene a continuación de ella es la clase que vamos a crear, no tiene más historia así que pasamos a otra cosa.
Aquí aparece otra propiedad de la POO, el concepto de herencia. Mediante esta palabra reservada heredamos los métodos y atributos de la clase madre de la que heredamos. Así si heredamos de la clase Frame heredamos todos sus métodos pero además los de la jerarquía de clases que están por encima de Frame que han ido heredando unas de otras.
Para que entiendas esto, consulta la clase Frame de las especificaciones y verás al principio de la página el árbol de herencias de dicha clase. Detrás de la relación de métodos que tiene esta clase verás todos los métodos a los que puede acceder una clase que herede de Frame.
Por definición, la herencia no es múltiple, es decir, solo se puede extender a única clase pero esta limitación la podemos saltar implementando las interfaces que deseemos de las que proporciona el JDK como se verá en capítulos posteriores.
Por último, decir que las clases heredadas las podemos redefinir a nuestro gusto para que se ajusten a nuestras necesidades o ampliarlas.
Esta palabra está íntimamente relacionada con los conceptos de herencia y de encapsulación. Aunque una subclase incluye todos los miembros de su super-clase, ésta no puede acceder a aquellos miembros de la super-clase que se hayan declarado como private.
Cuando la superclase de la que heredamos guarda sus datos miembro como privados, la clase heredera no los podrá inicializar, es por ello que cuando una subclase necesita referirse a su inmediata superclase utilizamos la palabra reservada super. Su uso puede tener dos objetivos:
| Lista 2: Usos de super |
Esta palabra se emplea dentro de cualquier método para referirse al objeto sobre el que estamos trabajando, es decir, this es siempre una referencia al objeto sobre el cual el método se invocó. Un caso en el que se aprecia bastante bien la utilidad de esta palabra es cuando resolvemos un conflicto de nombres idénticos, pero la realidad es que la mayoría de las veces, su uso es redundante pues nos lo podríamos ahorrar. No obstante, su empleo clarifica aun más el código y mi recomendación es que siempre se utilice.
En el siguiente ejemplo se intenta recoger todo lo aprendido en este artículo, es un ejemplo muy sencillo que calcula volúmenes.
/*
fichero Volumen.java en directorio cap2. Obviamente, lo tenemos que tener
recogido en el classpath pues si no el núcleo de java nos
cantaría el error "java.lang.NoClassDefFound cap2/Volumen".
*/
package cap2;
public class Volumen {
private double x;
private double y;
private double z;
public Volumen(double x, double y, double z) {
//al usar this resolvemos el conflicto de nombres
this.x = x;
this.y = y;
this.z = z;
}
public double calculaVol() {
return this.x * this.y * this.z;
/*
en cambio, su uso aquí es redundante, podríamos haber
hecho simplemente x*y*z
*/
}
}
//fichero Demo.java
import cap2.Volumen;
class Demo extends Volumen {
Demo(double x, double y, double z) {
super(x,y,z); //llamamos al constructor de la clase Volumen
/*
inicializamos las variables de esta clase.Observa, que al ser declaradas
como private las variables en la clase Volumen, ésta
es la única manera de acceder a ellas.
*/
}
private void printVol() {
System.out.println("El volumen total es : " + this.calculaVol());
}
public static void main(String args[]) {
Demo volumen = new Demo(20,30,20);
volumen.printVol();
}
}
[1] Parte 1 del diario de un principiante.,
/articles.article.action?id=6
Leo Suarez
Leo Suarez está actualmente realizando el proyecto de fin de carrera para obtener el título de Ingeniero Superior de Telecomunicaciones por la Universidad de Las Palmas de Gran Canaria.
Cuando no está proyectando o escribiendo para javaHispano aprovecha para disfrutar con la novia y los amigos del estupendo clima de las islas afortunadas.
martes, mayo 15, 2001 at 2:00AM
Esto pretende ser una guía de estilo de programación. Si se considera algún cambio, adición,... será consultado al analista, que será quien decida si se acepta o no el cambio. El analista deberá informar de cualquier cambio a los programadores, además , debe consultar con ellos antes de hacerlo. (Se centraliza el proceso y se evita la anarquía).
Lenguaje : JAVA
Tecnologías : JSP, Servlets, ...
Notación húngara. Recordar: en una variable se añade como prefijo una abreviatura del tipo.
String sUsuario
Array de String asUsuario[10]
ResultSet rsConsulta
HttpServletRequest hsrq
Si la clase es un nombre muy largo, podemos, en casos obvios y puntuales (p.e. que en la página sólo pueda haber una variable de este tipo) usar la abreviatura.
Los nombres de atributos, compuestos o no, tendrán en mayúscula la primera letra de cada palabra que lo forma
HttpServletRequest.
String
Los nombres de métodos serán en minúsculas. Si se les añade un nombre o adjetivo, irá en mayúsculas la primera.
ejecuta();
compraComida();
Siempre que sea posible declararemos las constantes, cuando tengamos que hacer referencia a una URL, cuando usamos un usuario / clave continuamente, etc... Las constantes las declaramos como generales (y no en el método que las referencia). Ejemplo:
En lugar de :
conML=DriverManager.getConnection("jdbc:mysql://raffaella/dietas","alfonso","miclave");
Pondremos:
conML=DriverManager.getConnection(BASE_DATOS,USUARIO,CLAVE);
Y declararemos las constantes, BASE_DATOS, USUARIO, CLAVE como atributos privados del servlet.
Si la palabra es compuesta, en las constantes las separamos con subrayado.
Tipo1 CONSTANTE= valor,
t1Variable1=new Tipo1(),
t1Variable2=new Tipo1(valor),
. . .
Tipo2 CONSTANTE2 = valor2,
CONSTANTEN = valor3,
t2VarDos =new Tipo2(),
t2VarDosDosDos = new Tipo2();
Observar que las variables y constantes van agrupadas por tipo. Otra opción, que puede dar más legibilidad, es declarar PRIMERO las constantes, agrupadas por tipo, y luego las variables, agrupadas también por tipo. Si se hace así, se agruparán en el mismo orden de tipo y se usará el mismo método para todo el proceso. Nunca cambiar el estilo de una página a otra en el mismo proyecto.
Tipo1 CONSTANTE= valor,
CONSTANTE2=valork;
Tipo2 CONSTANTE3 = valor3,
CONSTANTEN = valorn;
. . .
Tipo1 t1Variable1=new Tipo1(),
t1Variable2=new Tipo1(valor);
Tipo2 t2VarDos =new Tipo2(),
t2VarDosDosDos = new Tipo2();
. . .
Es decir, para un proceso dado o agrupamos en orden de
[Tipo , (Constantes y Variables)]
ó en el orden
[(Constantes, Tipo) y (Variables,Tipo)].
Las constantes siempre en mayúsculas.
Se indicará para qué se usa cada variable con un comentario en la línea anterior a dicha declaración. Cualquier comentario que se haga será en línea a parte, nunca a la derecha de la línea de código.
Por supuesto que cada sentencia irá en su propia línea. Cuidado con la programación ofuscada (anidamiento de sentencias), si se presta a confusión o la línea es grande, se divide, aunque ello suponga declarar variables.
Se declaran las variables al nivel que se van a usar, a saber: clase, método y bucle. En el caso de los métodos se declararán al principio, antes de cualquier línea de código. Si es necesario se pueden declarar en otro momento, pero sólo si es necesario. En todo caso dejar una línea entre sentencias de código y declaraciones de variables y declaraciones de constantes.
Tabular siempre que: se abra un paréntesis, después de una sentencia de control de flujo. Los
paréntesis se abren y cierran en la misma columna. Pero en líneas separadas a cualquier línea de código.
Ej:
for (iRecorreVector = 0; iRecorre < 10; iRecorre++)
{ // al mismo nivel que la línea anterior
// Comentario indicando lo que vamos a hacer.
línea 1 // un tabulado más
línea 2
. . .
línea n
}//for
// al mismo nivel que la apertura y con comentario.
Para formularios, servlets,... se usará siempre que sea posible el método post.. Si no es posible, el método get se redirecciona al método post y es en este en el que se implementa la lógica. Y si no es posible (¿?) pues me lo decís para que me ría J
Por defecto se trabajará a nivel de sesión así que todo pasa por aquí.
<%@ page session="true" import = "paquete.clase, paquete.paquete.clase,..." %>
En las jsp declarar todas las variables, iniciándolas, al principio. Antes de cualquier cosa (incluido el html).
<%! Tipo1 CONSTANTE= valor,
t1Variable1=new Tipo1(),
t1Variable2=new Tipo1(valor),
. . .
%>
Sólo se insertará código java en medio del BODY cuando sea extrictamente necesario.
De hecho se hará todo antes de la la marca <HTML>.
No se implementarán clases en la página. Para ello se usarán beans, eso sí, funciones y clases estándars no se implementarán en un bean para encapsular. (P.E. si se accede a una base de datos, no será correcto crear un bean, que acceda , pedirle luego al bean que acceda , recuperar de él lo que sea, ... cuando se puede hacer directamente la consulta).
Si existen trozos de páginas comunes a un proyecto, p.e. un menú , se crea una página .jsp aparte y se inserta la página. Se reduce así el mantenimiento de las páginas.
<@ include file ="menu.html" >
P.e. Podemos tener en una web en la que todas sus páginas tengan un menú común. Haremos entonces una página con el menú (incluso sus javascripts asociados):
<table width="100%" border="1" cellspacing="0" cellpadding="0">
<tr>
<th bordercolor="#FFFFFF"><h4>Main menu:</h4></th>
<th><a href="/CustomerSearch.jsp">Customer Search</a></th>
<th><a href="/CustomerListS">Customers</a></th>
<th><a href="/CustomerForm.jsp">Current Customer</a></th>
<th><a href="/OutletList.jsp">Outlets</a></th>
<th><a href="/PizzaList.jsp">Pizzas</a></th>
</tr>
</table>
... y titularla (como menu.jsp). Luego en las jsp podemos poner el include.
Si se abre un paréntesis, se añadirá un comentario al final.
if (soy_el_mejor)
dímelo
else
{
soy_el_mejor = verdadero;
dimelo;
}//else
Evitar la redundancia. En el ejemplo anterior dimelo TIENE que ir fuera de if .. else..
if ( ¡soy_el_mejor)
soy_el_mejor = verdadero
dimelo
Si hay un bucle, se comentará el motivo del bucle.
while ( no soy_guapo)
{
pedir(presupuesto); //obs. Esto es autocomentado
soy_guapo ßhacer_cirujia;
} //while
while ().
{
//dar vueltas hasta que sea guapo = añadimos esto
pedir(presupuesto);
soy_guapo ßhacer_cirujia;
si (soy_guapo)
break;
} //while
Inicialmente usaremos sesiones. Para añadir un valor que sea necesario recuperar:
application.setAttribute("NombreParaRecuperar", VariableAGuardar);
Ej. application.setAttribute("usuario", sUsuario);
Para recuperarlo
application.getAttribute("NombreParaRecuperar");
Ej: application.getAttribute("usuario");
Nota importante: Estamos trabajando con la especificación 2.3 de servlets
Es importante añadir a la cabecera sólo los datos más importantes para seguir la situación. Es un compromiso del analista/programador decidir si un dato se recupera de un fichero, BDD o se añade en la cabecera. Pero debería ir indicado en el documento de lanálisis
Dos opciones:
<%=session.getAttribute("H") %>
<% out.print(H);%>
Salvo excepciones, prevalecerá siempre la primera. Ej de excepción:
<% out.print( "<input type=\"hidden\" name=\"MLoculto\" value=\""+ sML+"\" >");%>
Aquí que lo decida el programador y, si duda que lo comente.
|