Modulo 3 - Java

Java

Manual del Usuario (Actualizado a: Agosto/2009) Ing. Carlos E. Orozco

[CURSO DESARROLLO WEB CON JAVA (100%)] En este modulo abarcaremos las bases necesarias para hacer nuestra página web dinámica aplicando las nociones básicas de Java y JSP.

Curso Java

Ing. Carlos E. Orozco Página 2 de 37

Tabla de contenido 1. Introducción ................................................................................................................................ 5

1.1 Objetivos del Curso ............................................................................................................. 5

1.2 Manual del Alumno ............................................................................................................. 5

1.3 Ejercicios prácticos .............................................................................................................. 5

1.4 Requisitos para atender este curso ..................................................................................... 5

2. Introducción a Java ...................................................................................................................... 5

2.1 Java ...................................................................................................................................... 5

2.2 Principales características del Java ..................................................................................... 5

3. Primera aplicación ....................................................................................................................... 6

4. Características del lenguaje Java ................................................................................................. 6

4.1 Palabras reservadas............................................................................................................. 6

4.2 Sensibilidad ......................................................................................................................... 7

4.3 Identificadores .................................................................................................................... 7

4.4 Reglas de nombramiento .................................................................................................... 7

4.5 Declaración de variables ..................................................................................................... 7

4.6 Tipos de datos simples (o primitivos) .................................................................................. 8

4.7 Constantes ........................................................................................................................... 9

4.8 Operadores .......................................................................................................................... 9

4.9 Prioridad de operadores ................................................................................................... 10

4.10 Conversiones ..................................................................................................................... 10

4.11 La clase Math ..................................................................................................................... 10

4.12 Comentarios ...................................................................................................................... 11

5. Cadenas de caracteres y fechas ................................................................................................ 11

5.1 String ................................................................................................................................. 11

5.2 Date ................................................................................................................................... 12

5.3 Calendar ............................................................................................................................ 12

6. Arreglos ..................................................................................................................................... 13

6.1 Tipos de arreglos y uso ...................................................................................................... 13

7. Decisiones y bucles .................................................................................................................... 14

7.1 If… else .............................................................................................................................. 14

7.2 Comparación entre objetos............................................................................................... 14

7.3 Condiciones múltiples (AND y OR) .................................................................................... 14

7.4 Switch ................................................................................................................................ 15

7.5 While ................................................................................................................................. 15

7.6 Do… while .......................................................................................................................... 15

Curso Java


7.7 For ..................................................................................................................................... 16

7.8 Break ................................................................................................................................. 16

7.9 Continue ............................................................................................................................ 16

7.10 Operador ternario ............................................................................................................. 16

8. Paquetes, clases y métodos ...................................................................................................... 17

8.1 Paquetes ............................................................................................................................ 17

8.2 Importación de paquetes .................................................................................................. 17

8.3 Clases ................................................................................................................................. 17

8.4 Constructores .................................................................................................................... 18

8.5 Métodos ............................................................................................................................ 18

8.6 Modificadores de acceso ................................................................................................... 19

9. Polimorfismo, Encapsulamiento y Herencia ............................................................................. 19

9.1 Polimorfismo ..................................................................................................................... 19

9.2 Encapsulamiento ............................................................................................................... 19

9.3 Herencia ............................................................................................................................ 20

10. Tratamiento de excepciones ................................................................................................. 20

10.1 Errores de compilación...................................................................................................... 21

10.2 Errores de lógica ................................................................................................................ 21

10.3 Errores de ejecución .......................................................................................................... 21

10.4 throws ............................................................................................................................... 21

10.5 Try ...................................................................................................................................... 21

10.6 catch .................................................................................................................................. 22

10.7 finally ................................................................................................................................. 22

11. Conexión a bases de datos .................................................................................................... 22

Conexión .................................................................................................................................... 23

Ejecución de instrucciones SQL ................................................................................................. 24

12. JSP .......................................................................................................................................... 26

12.1 Eclipse ................................................................................................................................ 26

Creación del servidor................................................................................................................. 26

Creación de un nuevo proyecto web ........................................................................................ 27

Creación de la página de índice ................................................................................................. 29

12.2 Scriptlets ............................................................................................................................ 31

Scriptlets para Declaración de variables ................................................................................... 31

Scriptlets para código ................................................................................................................ 31

12.3 Directivas ........................................................................................................................... 32

Directiva de página .................................................................................................................... 32

Curso Java


Directiva de inclusión ................................................................................................................ 32

Directiva taglib .......................................................................................................................... 33

12.4 Variables de sesión ............................................................................................................ 33

12.5 Los formularios .................................................................................................................. 33

12.6 Servlets .............................................................................................................................. 34

Servet simple ............................................................................................................................. 35

Servlet para mostrar imágenes o archivos binarios .................................................................. 36

Curso Java


1. Introducción

1.1 Objetivos del Curso Con esta parte del curso el estudiante aplicara el lenguaje Java y Java Script para hacer su página web dinámica con la extensión JSP.

1.2 Manual del Alumno Este manual del alumno es una ayuda para el alumno tenga recuerdo del curso. Este manual contiene un resumen de las materias que se van a estudiar durante el curso, pero el alumno deberá tomar notas personales necesarias que sirvan de complemento para este manual.

1.3 Ejercicios prácticos Para captar mejor la teoría, se harán muchos ejercicios con los alumnos, para probar la teoría y verificar la integración de la materia.

También, el alumno podrá copiar sus códigos en un medio de almacenamiento al fin de cada encuentro del curso con el fin de seguir la práctica en su hogar.

1.4 Requisitos para atender este curso Conocimientos básicos de programación y HTML.

2. Introducción a Java

2.1 Java El objetivo es tener un lenguaje de programación que pueda funcionar sobre cualquier equipo, de manera independiente del hardware y del sistema operativo.

Java tiene varias utilidades. Puede servir a desarrollar aplicaciones autónomas (100% Java), applets para el Internet (pequeñas aplicaciones descargadas y ejecutando sobre el cliente), o ser mezclado con otro lenguaje como HTML, Java script, Java Server Pages, etc.

2.2 Principales características del Java La difusión rápida del Java ha sido posible gracias a sus importantes características:

Simple: Aunque el lenguaje orientado objeto (OO) no es fácil ni sencillo, Java es reconocido como más fácil que otros lenguajes como el C++.

Orientado a objetos: La programación orientada objetos modela las cosas del mundo real, o los conceptos, como un objeto. Así el objeto “carro” puede servir a construir carros rojos, como carros azules, a partir del mismo objeto ‘carro’.

Distribuido: Java permite interacciones entre varias computadoras conectadas en redes, para distribuir el trabajo o los recursos.

Interpretado: Java es un lenguaje interpretado, eso significa que necesita un intérprete para poder ser ejecutado. Este intérprete es la maquina virtual de Java (JVM). Java esta compilado en un código binario, que la maquina virtual interpreta. Así el código puede ser compilado de manera independiente del sistema de destino. La maquina virtual de Java es específica al sistema operativo de destino, no al código.

Curso Java


Seguro: El lenguaje Java se utiliza en el Internet en muchos sitios web que necesitan una grande seguridad, como bancos, comercio electrónico,... Java tiene muchas opciones para gestionar la seguridad de ejecución de la aplicación.

También el código Java descargado del Internet y ejecutado el la maquina del cliente, no produce daños en la maquina del cliente.

Multihilo: Java permite ejecutar tareas según varios hilos de ejecución, es decir ejecutar varias tareas en paralelo.

3. Primera aplicación Un programa Java para ser ejecutado requiere de al menos una clase, y que esta clase contenga al menos el método “main”

Veamos un ejemplo:

class Test { public static void main(String[] args) { // metodo principal System.out.println("Estoy en main!"); }// fin de metodo Main } // fin de clase

La clase debe ser registrada con el mismo nombre de lo declarado con la palabra reservada “class”, con la extensión “java”, para el ejemplo “Test.java”. Notar que el inicio y el final de la clase se realizan con los simbolos “,“ y “-” respectivamente.

El método principal, que es llamado cuando se inicia la aplicación Java es el método “main (public static void main(String*+ args))”.

El inicio y el final del método están marcados con “,“ y “-” respectivamente. Este método hace solamente una acción: imprime en la consola el texto “Estoy en el main!”).

Para mas informaciones sobre las clases y métodos, ver el capitulo “Paquetes, clases, y métodos”.

4. Características del lenguaje Java En esta parte conoceremos las generalidades del lenguaje Java tales como tipos de datos, declaración y manejo de variables, operaciones con variables, etc.

4.1 Palabras reservadas Lista de palabras reservadas del Java 1.6.0:

Curso Java


4.2 Sensibilidad Java es sensible a las mayúsculas y las minúsculas. Así ‘try’ es una palabra reservada, pero ‘Try’ no.

4.3 Identificadores Los identificadores son los nombres que se dan para identificar a las clases, paquetes, interfaces, métodos, y variables.

El nombre de un identificador tiene que cumplir con ciertas reglas:

Debe tener un o más caracteres (sin longitud máxima)

No puede contener operadores (+,,>...)

No puede ser igual a una palabra reservado (if, void, ...). Ver la lista de palabra reservadas arriba.

El primer carácter tiene que ser una letra, el carácter ‘$’ o el carácter ‘_’ (subrayado).

Las letras que pueden ser utilizadas son las del alfabeto Unicode, con mayúsculas y minúsculas (¡cuidado que Java hace diferencias entre mayúsculas y minúsculas!).

4.4 Reglas de nombramiento Para tener un código más estándar, existen règlas de nombramiento de los paquetes, clases, métodos, variables, y constantes.

Los nombres de paquetes están normalmente en minúsculas. Ej: paquete test

Los nombres de clases están normalmente en minúsculas, con la primera letra en mayúscula, así como la primera letra de case nombre interno. Ej: clase TestJava

Los nombres de métodos y variables están normalmente en minúsculas, con la primera letra en minúscula, y la primera letra de case nombre interno en mayúscula. Ej: método getNombre, variable edadEmpleado, ...

Los nombres de constantes están normalmente en mayúsculas. Ej: constante PREF_TEL;

Estas reglas, aunque no generan son muy importantes por cuestiones de estandarización, mantenimiento y comprensión del código.

4.5 Declaración de variables Las variables permiten almacenar datos de entrada, de salida, o intermedios.

La sintaxis básica de declaración de variable es:

Curso Java


<tipo de dato> <nombre de variable>; int miNumero;

En la declaración se puede declarar a la vez varias variables de un mismo tipo, separando los nombres de variables con una coma.

<tipo de dato> <nombre de variable 1>,<nombre de variable 2>; int miNumero, tuNúmero;

En la declaración se puede también inicializar la variable, asignándole un valor. El valor se asigna con el signo igual y el valor inicial.

<tipo de dato> <nombre de variable> = <valor inicial>; int miNumero = 1;

Una variable está disponible solamente dentro del bloque de código donde está declarado (delimitado por {}). Los diferentes niveles son clase, método, y bloque dentro de un método.

Una variable declarada al nivel de la clase se inicializa por defecto a cero (enteros y reales), false (bolean), o a nulo (otros tipos). Las variables de clase son disponible de desde cualquier método de la clase.

Una variable declarada en un método debe ser inicializada de manera explicita para poder ser utilizada.

Si una variable de método tiene el mismo nombre que una variable de clase, dentro de este método la variable de método sobre escribe la variable de clase, a menos que se mencione 'this.' Antes del nombre de la variable (para utilizar la variable de clase).

Una variable de método no puede ser sobre escrita por otra. Es decir, los nombres de variable deben ser únicos dentro de un método.

4.6 Tipos de datos simples (o primitivos) Los tipos simples son tipos que no son orientados objetos. Se subdividen entre enteros, reales, carácter, y boléanos.

Enteros: Hay cuarto tipos de enteros: byte, short, int y long. Todos pueden ser positivos o negativos, y tienen una capacidad de 8, 16, 32 o 64 bits.

Cuando se asigna un valor numérico a un long, hay pegarle la letra ‘l’ para indicar a Java que es un long. Por defecto, un valor entero está considerado como un int.

Ejemplos de declaración:

int miNumero = 1; byte testByte = 17; short testShort = 12357; long testLong = 122132135l;

El byte puede contener valores enteras entre 128 y 127.

El short puede contener valores enteras entre 32768 y 32767.

El int puede contener valores enteras entre 2147483648 y 2147483647.

El long puede contener valores enteras entre 9223372036854775808 y 9223372036854775807.

Curso Java


Reales: Los reales contienes valores con coma flotante, que permite almacenar números grandes o muy pequeños con gran precisión. Los reales se dividen entre float y double. Los float tienen precisión “simple” (6 o 7 dígitos máximo) y los doublé tienen precisión “doble”(14 o 15 dígitos). Por defecto, un valor real está considerado como un doble.

Cuando se asigna un valor numérico a un float, hay pegarle la letra “f” para indicar a Java que es un float. A los double, la letra “d”.

Ejemplos de declaración:

float testFloat = 1.771f; double testDouble = 1.221d;

El float puede contener valores decimales entre 3,4E38 y 3,4E38.

El double puede contener valores decimales entre 1,7E308 y 1,7E308.

Carácter: El carácter (char) puede contener solo un carácter. Las cadenas de caracteres serán vistos en otro apartado.

Ejemplo de declaración:

char miChar='A';

Booleans: Los boléanos pueden tomar exclusivamente el valor true o false (verdadero o falso).


boolean miBoolean=true;

4.7 Constantes Las constantes son datos cuyo valor no puede cambiar durante la ejecución del programa.

Las constantes utilizan los mismos tipos que las variables, y se declaran de la misma manera a la “exception” que se pone “final” antes del tipo de dato.

La sintaxis básica de declaración de variable es:

final <tipo de dato> <nombre de variable>; final int MI_CONSTANTE;

4.8 Operadores Principales operadores sobre enteros y reales

Negación (unitario), resta (binario) ++ Incremento Decremento = Asignación == Igualdad != Desigualdad < Menos que <= Menos o igual que >= Mayor o igual que > Mayor que + Suma

Curso Java


* Multiplicación / División % Modulo

Los operadores de incremento (++) y decremento () se pueden utilizar antes o después de la variable, pegado a ella.

Si se utilizan antes, la variable se incrementa o decrementa directamente. Si se utiliza después, la variable se incrementa o decrementa justo después de haber sido utilizada.


int i = 0; System.out.println(++i); // imprime 1 System.out.println(i); // imprime 1 System.out.println(i++);// imprime 1 System.out.println(i); // imprime 2 System.out.println(i++ +" y "+ --i ); // imprime 2 y 2

4.9 Prioridad de operadores Como en la matemática, en Java existen prioridades entre los operadores. Los paréntesis tienen la más grande prioridad, se pueden utilizar para forzar un orden de evaluación, así como para facilitar la lectura del código.

Prioridad de los operadores:

1. ( ) [ ] 2. ! ++ 3. new (tipo) 4. * / % 5. + 6. > >= <= < instance of 7. == != 8. & 9. | 10. && 11. || 12. ?: 13. = *= /= %= += = >>= >>>= <<= &= |=

4.10 Conversiones Para realizar conversiones entre tipos de datos numéricos se realizan indicando el tipo deseado delante de la variable a convertir. Por ejemplo:

float miFloat = 1.999f; int miInt = (int) miFloat;

4.11 La clase Math La clase Math del Java contiene la mayoría de las operaciones matemáticas que se hacen sobre enteros o reales. Para la lista completa de métodos, ver la documentación Java.

Incluye entre otros:

El valor absoluto Math.abs(<exp>) Máximo entre 2 valores Math.max(<exp1>,<exp2>) Número aleatorio Math.random()

Curso Java


Seno Math.sin(<exp>) Log natural Math.log(<exp>) El entero igual o superior Math.ceil(<exp>) El entero igual o inferior Math.floor(<exp>)

4.12 Comentarios Para ubicar un comentario dentro del código se pueden realizar ocupando los caracteres “/*” para abrir el comentario, y los caracteres “*/” para cerrar comentario. Adicionalmente se pueden ocupar los caracteres “//” para comentar la línea.

5. Cadenas de caracteres y fechas

5.1 String El objeto mas utilizado para contener cadenas de caracteres es el tipo objeto String. Este tipo permite guardar una cadena de caracteres sin limitación.

Las cadenas de caracteres se declaran como las variables, y el valor se menciona entre doble cuotas.

Ejemplo:

String miTexto = "Hola Nicaragua!";

Para insertar ciertos caracteres especiales dentro de una cadena de caracteres, hay que mencionarlos detrás de una contra barra (\).

Para mencionar una doble comilla: \" Para mencionar una tabulación: \t Para mencionar una nueva línea: \n Para mencionar un regreso a la línea: \r Para mencionar un carácter Unicode: \uxxxx a donde xxxx es el valor hexadecimal del carácter o \xxx a donde xxx es el valor octal del carácter (0 a 7).

Para concatenar dos cadenas de caracteres, se puede utilizar el método concat o el signo ‘+’.

Ejemplo:

String miTexto = "Hola!"; miTexto += "Una prueba.";

Hay que tener cuidado con las concatenaciones, porque con el objeto String, cada concatenación crea un nuevo objeto, lo que consume memoria. Si Usted necesita hacer muchas concatenaciones, utiliza mejor la clase StringBuilder.

Para convertir una cadena de caracteres (que contiene solo un número) a enteros o reales o contrario, hay que utilizar métodos especiales.

Ejemplos:

int miNumero = Integer.parseInt("1234"); float miFloat = Float.parseFloat("123.566"); String miConvertido = String.valueOf(miFloat);

Existen muchos métodos del objeto String para hacer operaciones sobre cadena de caracteres. Para la lista completa de métodos, ver la documentación Java.

Curso Java


Por ejemplo: length(), charAt(int <indice>),substring (int <inicio>,int <final>), ...

5.2 Date La clase Date del paquetejava.util se utiliza para guardar fechas y horas. Como el paquete java.util no se carga por defecto, hay que importarlo.

La clase Date tiene métodos, entre otras para cambiar la fecha, extraer el día, mes, año... formatear la fecha o convertirla en String. Pero muchos de sus métodos están despreciadas, y se tiene que utilizar la clase Calendar. Para la lista completa de métodos, ver la documentación Java.

Existe también un objeto Date en el paquete java.sql que se utiliza para manejar fechas durante las conexiones a bases de datos.

Ejemplo:

import java.util.Date; public class TestDate{ Date miFecha = new Date();

5.3 Calendar La clase Calendar, y su subclase GregorianCalendar, permite manejar fechar según el calendario Gregoriano.

Con este clase podemos gradar datos de fecha y manejarlas haciendo, entre otros, sumas y diferencias de fechas.

Ejemplo:

import java.util.*; public class TestFecha { public TestFecha() { System.out.println(getCurrDate()); System.out.println(getTestDate()); } public String getCurrDate() { Calendar cal = new GregorianCalendar(); String day = "0" + cal.get(Calendar.DATE); int pos = day.length(); day = day.substring(pos - 2, pos); String month = "0" + (cal.get(Calendar.MONTH) + 1); pos = month.length(); month = month.substring(pos - 2, pos); String year = "" + cal.get(Calendar.YEAR); String currdate = day + "/" + month + "/" + year; return currdate; } public String getTestDate() { Calendar cal = new GregorianCalendar(); cal.set(1996, 11, 1); // cuidado que el mes empieza con 0 y no 1 (0->11) System.out.println(cal.get(Calendar.DATE)); // 1 System.out.println(cal.get(Calendar.MONTH)); // 11 System.out.println(cal.get(Calendar.YEAR)); // 1996 String day = "0" + cal.get(Calendar.DATE); int pos = day.length(); day = day.substring(pos - 2, pos); String month = "0" + (cal.get(Calendar.MONTH) + 1); // +1 para corregir el mes pos = month.length();

Curso Java


month = month.substring(pos - 2, pos); String year = "" + cal.get(Calendar.YEAR); String currdate = day + "/" + month + "/" + year; // 01/12/1996 return currdate; } public static void main(String[] args) { // metodo principal System.out.println(new GregorianCalendar().getTime()); new TestFecha(); }// fin de metodo Main }

6. Arreglos Un arreglo es una colección organizada de datos del mismo tipo.

6.1 Tipos de arreglos y uso Los arreglos son variables que pueden contener datos de tipo simple (char, int, etc.) o bien de tipo objeto (String, Date, etc.) organizándolos de manera unidimensional o bidimensional.

Un arreglo se puede definir de las siguientes maneras:

String paginaList []= {"Formato A4", // arreglo de 4, inicializado con valores "Carta 8.5 x 11", "Prescripcion US", "Prescripcion BE"}; int miArregloInt [] = new int [9]; // arreglo de 9 líneas, inicializado con cero int miArreglo2 [] [] = {{1,2,3},{2,4,6}}; // arreglo de 2 líneas y 3 columnas, inicializado con valores.

Se declaran con “* +” detrás del tipo para una dimensión, y “* ] [ +” para doble dimensión.

Cuando se crea un arreglo, sus elementos están inicializados por defecto a cero para arreglos de enteros y reales, una cadena vacía para char, false para boléanos, y null para los objetos.

Los índices de un arreglo empiezan con 0 y se incrementan por unidad.

Una vez inicializado, el tamaño del arreglo no puede cambiar más.

Ejemplos de utilización:

miArregloInt [0]=5; // asigna el valor 5 al primer miembro del arreglo int miNumero = miArregloInt [0]; // miNumero será igual a 5 System.out.println(miArreglo2[0][0]); // imprime 1 System.out.println(miArreglo2[0][2]); // imprime 3 System.out.println(miArreglo2[1][2]); // imprime 6 System.out.println(miArreglo2[2][3]); // esta línea genera un error java.lang.ArrayIndexOutOfBoundsException

El método public static void main (String [] args) acepta como parámetro de entrada un arreglo de String.

Para pasar los valores en parametro, se mencionan después del nombre de la clase, separados por espacios. Si un valor contiene espacios, hay que ponerla entre doble comillas.

Ejemplo:

… public static void main(String[] args) { // metodo principal

Curso Java


System.out.println(args*0+); // imprime “Uno” System.out.println(args*1+); // imprime “y dos” } … java Test Uno "y dos"

7. Decisiones y bucles

7.1 If… else El if se utiliza para crear esquema de decisiones. Se puede utilizar con el else, pero es facultativo.

El if, que significa “si” permite probar una o varias condiciones. El resultado de cada condición siempre es sí o no. Las condiciones siempre están entre paréntesis.

Después del if viene la instrucción que será realizada en caso que el resultado de la(s) condición(es) sale verdadero.

El else, que se puede traducir por “si no se cumple”, la instrucción que será realizada en caso que el resultado de la(s) condición(es) del if salió falso.

Si hay más que una instrucción que ejecutar tras el if o el else, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y } .

Ejemplo:

int licencia = 0; if (licencia==1) System.out.println("!Yo tengo la licencia!”); else ,System.out.println("!No tengo licencia!”); System.out.println("Pero la voy a comprar pronto...”); }

7.2 Comparación entre objetos Para hacer comparaciones entre dos objetos, es siempre mas seguro utilizar en método equals, porque el uso de ‘==’ hará la comparación basada en los objetos, y no en su contenido.

Ejemplo:

String miTexto = "Hola!"; if (miTexto.equals("Hola!")) System.out.println("OK");

7.3 Condiciones múltiples (AND y OR) Para mencionar condiciones múltiples se utilizan los símbolos | y &.

Para que cumple con una Y otra condiciones, se utiliza el & (significa Y).

Para que cumple con una U otra condiciones, se utiliza el | (significa U).

Para que evalúa solamente las condiciones necesarias (en caso de Y, si la primera no cumple, no evalúa las otra, en caso de U, si la primera cumple, no evalua las otras), se dobla el si no (|| o &&). Para mejor rendimiento se dobla siempre.

Ejemplo:

Curso Java


int licencia = 0; if (licencia > 10 || licencia == 5) System.out.println("!Yo tengo la licencia 5 o > 10!"); else if (licencia < 10 || licencia > 5) System.out.println("!Tengo licencia entre 5 y 10!"); else System.out.println("!Tengo licencia < 5 ");

7.4 Switch El switch se utiliza para crear esquema de decisiones. El switch permite de tener varias alternativas, en contra del if...else que solo tiene dos alternativas.

Primera se declara, entre paréntesis, cual variable se va a evaluar. Solo char, byte, short o int pueden ser evaluados.

Para cada alternativa, se menciona la palabra case con la valor correspondiendo a la valor de la alternativa, y el código que hay que ejecutar. Si no se termina la alternativa con la palabra break, el código de las alternativas siguiente se van a ejecutar también, mismo si el valor de la variable evaluada no corresponde al case.

La palabra default se utiliza para mencionar acciones a realizar en caso que ninguna alternativa salió verdadera. Como para el case, debería terminar con break para que no se ejecutaría otro código siguiendo.

Si hay mas que una instrucción que ejecutar tras el case o el default, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y } .

Ejemplo:

int test=1; switch (test) { case 1 : System.out.println("Igual a 1"); case 10 : System.out.println(" Igual a 10"); break; case 20 : System.out.println(" Igual a 20"); default : System.out.println(" Igual a otro valor"); }

7.5 While El while se utiliza para crear bucles, es decir repetir una acción mientras se cumpla una condición.

La condición que hay que cumplir se menciona detrás de la palabra while, entre paréntesis.

Las acciones que hay que ejecutar se mencionan detrás del while. Si hay más que una instrucción que ejecutar, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y }.

7.6 Do… while El “do ... while” se utiliza similar al while con la diferencia que la condición que hay que cumplir se evalúan posterior a la ejecución del código, estas se mencionan detrás de la palabra while, entre paréntesis, y termina con punto coma “;” .

Las acciones que hay que ejecutar se mencionan detrás del do. Si hay mas que una instrucción que ejecutar, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y } .

La cláusula do se puede mencionar antes de la cláusula while. En este caso, el código de la cláusula do se ejecutara una primera vez antes de verificar la condición del while, y se repetirá hasta que la condición sea falsa.

Curso Java


Ejemplo:

int miNumero = 1; do {System.out.println("El número actual es "+ ++miNumero); } while (miNumero < 5);

7.7 For El for se utiliza para crear bucles un número fijo de veces.

La condición que hay que cumplir se menciona detrás de la palabra for, entre paréntesis, y tiene tres diferente partes, separadas por “;”. Cada parte es opcional, pero el “;” tiene que ser mencionado mismo si la parte está vacía.

La primera parte sirve a declarar una variable (usualmente un int) y/o asignarle un valor original.

La segunda parte contiene la condición de ejecución. Usualmente la variable inicializada > o < que otro int o valor fija.

La tercera parte se utiliza para mencionar el incremento o decremento eventual.

Las acciones que hay que ejecutar se mencionan detrás del for. Si hay mas que una instrucción que ejecutar, hay que utilizar un bloque de instrucciones, conteniendo las instrucciones entre { y } .

Ejemplo:

for (int i = 0; i < 3; i++) { System.out.println(i);}

Existe un for “simplificado” para recorrer arreglos, que funciona así:

String a *+ = ,“uno”,”dos”,”tres”-; for (String s : a) { System.out.println(s);}

7.8 Break La instrucción break permite de salir de una bucle o de abandonar las sentencias de ejecución de un switch.

Ejemplo:

int ii = 5; for (int i = 0; i < 10; i++) { if (i>ii) break; System.out.println(i);}

7.9 Continue La instrucción continue solo se puede usar en bucles, y permite de saltar directamente al bucle siguiente, sin ejecutar el resto del código del bucle corriente.

Ejemplo:

int ii = 5; for (int i = 0; i < 10; i++) { if (i==ii) continue; System.out.println(i); }

7.10 Operador ternario Otro operador condicional es el operador "?:" (o ternario).

Curso Java


Ejemplo: Asignación de un valor predeterminado

// Ejemplo de uso de: el Operador Ternario int edad=5; String tipo = ((edad<=18) ? "Joven” : "Adulto”);

8. Paquetes, clases y métodos

8.1 Paquetes Los paquetes se utilizan para reunir clases que pertenecen a una misma aplicación, o que tienen algunas características juntas.

Un paquete puede contener varios niveles. Por ejemplo, el paquete itc.nica se encontrara bajo la carpeta “itc”, que se encontrara bajo la carpeta “nica”.

La primera instrucción de un archivo de una clase que permanece a un paquete es: package <nombre del paquete>; Para compilar un paquete, hay que estar en la raíz de la aplicación, y compilar con javac nombre_del_paquete/NombreDeLaClase.java

Para llamar a una clase de un paquete hay que estar en la raiz de la aplicación y llamar a: java nombre_del_paquete.NombreDeLaClase

8.2 Importación de paquetes Cuando se requiere un objeto de otro paquete, se necesita poner el nombre entero del paquete delante el nombre del objeto, separado con “.”.

Por ejemplo, para llamar al objeto Mitest del paquete test : test.Mitest

Para no tener que marcar siempre el nombre del paquete delante el objeto, hay que importar el paquete.

Para importar un paquete, hay que mencionar la palabra import y el nombre del paquete mas ‘;’. La importación solo se puede hacer entre la declaración del paquete del código (si pertenece a un paquete) y la declaración de la clase principal del código.

Ejemplo:

package dbaccess; import java.sql.*; public class Readdb {...}

8.3 Clases La clase es la unidad principal del Java. Una clase sirve para definir un objeto, y contiene sus constructores y sus métodos.

Son los constructores y métodos que permitirán inicializar y manejar el objeto.

La clase puede tener variables o constantes que serán accesibles por todos los constructores y métodos de la clase.

Una clase tiene que ser guardada bajo un archivo que tenga el mismo nombre que la clase.

Curso Java


Ejemplo:

class Test { private int miNumero; //variable de clase public Test (){ // constructor miNumero=1; } public void método_1 (){ // metodo miNumero+=10; ... } }

8.4 Constructores El constructor es la parte de la clase que permite inicializar la clase. Por defecto una clase tiene un constructor sin argumento y sin acción.

El constructor se puede definir y sobre definir para ejecutar ciertas acciones y/o para aceptar parámetros (argumentos) al inicializar la clase.

El constructor se define como un método que tiene el mismo nombre que la clase, y que no puede regresar valores ni extender otro método.

Una misma clase puede tener varios constructores.

Ejemplo:

class Test { int miCampo; // variable de clase public Test (int miNumero){ // mi constructor miCampo = miNumero; // variable de clase inicializada } }

8.5 Métodos Un método es una característica de una clase. Un método permite ejecutar acciones sobre el objeto (class).

Son los métodos que hacen todas las acciones de una aplicación, así que contienen la mayoría del código.

Un método tiene, como la clase, derecho de acceso que se pueden modificar, y también se necesita indicar si el método regresa alguna valor o no, y cual es el tipo de valore regresada.

Los métodos pueden aceptar cero, uno, o varios parámetros de entrada, y pueden ser sobre definida, es decir tener un mismo nombre con diferentes números o tipos de parámetros.

El método main (public static void main(String[] args)) es un método especial que esta llamado por la JVM al iniciar una aplicación. El método main puede aceptar cero, uno, o varios parámetros, que son cadenas de caracteres.

Ejemplo:

class Test {

Curso Java


public int calculo (int númeroDado){ // metodo de calculo return númeroDado+5; }// fin de metodo public static void main(String[] args) { // metodo principal Test miTest = new Test(); int resultado = miTest.calculo(12); System.out.println(resultado); }// fin de metodo Main } // fin de clase

8.6 Modificadores de acceso Por defecto, una clase, método, o dato es visible en este paquete.

El método, o dato es visible solo en esta clase.

La clase, método, o dato es visible en todo el universo.

La clase, método, o dato es visible en este paquete y las subclases de esta clase en cualquier paquete.

9. Polimorfismo, Encapsulamiento y Herencia En esta parte examinaremos otras características importantes que dotan a las clases de fortaleza en el ámbito de programación.

9.1 Polimorfismo El polimorfismo es la capacidad que tiene Java de diferenciar métodos que tiene un mismo nombre gracias a sus parámetros, o de inicializar una clase utilizando en constructor correspondiente a los parámetros pasados.

Ejemplo:

public class TestPoli { static int numeroGeneral; public TestPoli() { numeroGeneral=5; } // fin constructor public TestPoli(int inicializaNo) { numeroGeneral=inicializaNo; } // fin constructor public static void main(String[] args) { // metodo principal TestPoli miTest= new TestPoli(Integer.parseInt(args[0])); System.out.println("Constructon con (int). numeroGeneral = "+numeroGeneral); TestPoli miTest2= new TestPoli(); System.out.println("Constructon con (int). numeroGeneral = "+numeroGeneral); }// fin de metodo main } // fin de clase

9.2 Encapsulamiento El encapsulamiento permite de esconder la estructura interna de un objeto, y solo enseñar lo necesario.

El encapsulamiento se hace utilizando modificadores de acceso, paquetes, clases internas, clases abstractas, y/o interfaces.

Curso Java


9.3 Herencia Las clases pueden tener herencia de otra clase, lo que permite de recuperar ciertas características (métodos y datos) de un objeto, y modificar o agregar otras. Los constructores no se heredan y deben ser definidos de nuevo en la clase, pero pueden llamar al constructor de la clase madre con la palabra “super”. Por defecto, el constructor llama al constructor sin argumento de la clase madre, a menos que se llama a otro constructor explícitamente.

Entonces:

Cuando no tengo constructor de la clase hija definido, el constructor sin argumento de la clase madre esta llamado en primer lugar, si existe (si no, error de compilacion).

Cuando un constructor de la clase hija no llama a ningun constructor de la clase madre, el constructor sin argumento de la clase madre esta llamado en primer lugar, si existe.

Cuando llamo de un constructor de la clase hija hacia un constructor otro que el sin argumento de la clase madre, el constructor sin argumento de la clase madre no está llamado.

Así se puede crear subclases que extienden la clase de base.

La herencia se utiliza mucho en Java, y especialmente en el web (servlets) y el GUI (AWT, Swing).

La clase de base puede ser una clase fundadora de Java (Java Foundation Class) o una clase personal.

Ejemplo:

package test; public class TestHerencia { int numeroGeneral; TestHerencia () {numeroGeneral = 5;} public void adjunta_100() {numeroGeneral += 100; } } // fin de clase TestHerencia package test; public class TestHerenciaExt extends TestHerencia{ public TestHerenciaExt () {super();} public void adjunta_50() {numeroGeneral += 50; } public static void main(String[] args) { // metodo principal TestHerenciaExt miTest = new TestHerenciaExt (); System.out.println("Valor inicial de numeroGeneral = " + miTest.numeroGeneral); miTest.adjunta_100(); System.out.println("Valor de numeroGeneral = " + miTest.numeroGeneral); miTest.adjunta_50(); System.out.println("Valor de numeroGeneral = " + miTest.numeroGeneral); } // fin de metodo main }

10. Tratamiento de excepciones Existen tres categorías de errores en Java. Los errores de compilación, los errores de ejecución, y los errores de lógica. A continuación vemos como tratar cada uno de ellos.

Curso Java


10.1 Errores de compilación Los errores de compilación son los errores de sintaxis. Al compilar el código, Java detecta los errores que no respetan la sintaxis del Java, así como errores de conversión de tipos, uso de variables no declaradas, etc...Estos errores no permiten que se cree el archivo .class, el código compilado, porque este código nunca podría funcionar.

10.2 Errores de lógica Los errores de lógica son errores debido a un diseño incorrecto del código. Por ejemplo, un bucle que nunca termina, una falta de ortografía en un texto, una fórmula de cálculo equivocada, etc.

10.3 Errores de ejecución Los errores de ejecución son excepciones que Java no pudo detectar al compilar el código. Por ejemplo, un número dividido por cero, o llamar a una base de datos que no existe, etc...

Existen dos clases de excepciones: la clase Error y la clase Exception.

Las excepciones de la clase Error abarcan fallos graves que el programa no va a poder recuperar y, por tanto, no pueden ser captadas.

Las excepciones de la clase Exception son excepciones que Java puede capturar. Existen varias subclases, como Runtime Exception, IOException, InterruptedException,...

Las excepciones de la clase Excepcion pueden ser atrapadas adentro del código, para tomar acción correctiva y así evitar que el error sea fatal para la aplicación. Para poder atrapar un error, hay que utilizar un bloque try en conjunto con uno o varios bloques catch y/o un bloque finally.

10.4 throws Todos los errores que se pueden originar en un método, excepto los errores del tipo Error y RuntimeException tienen que ser capturadas o declarada en una cláusula throws al declarar el método.

Todos los errores, sin considerar los de tipo RuntimeError tienen que ser capturados en el código, o descartadas utilizando throws.

La cláusula throws permite descartar los errores, es decir no capturarlos. Este es el comportamiento por defecto de Java, pero en caso que Java espere que un error sea atrapado de manera explícita (por ejemplo cuando se usa el SQL), la cláusula throws permite ignorar el error y compilar el código.

Ejemplo:

public Readdb() throws Exception { Class.forName("org.firebirdsql.jdbc.FBDriver"); ... }

10.5 Try El código de ejecución en el cual se podría producir una error de ejecución se pone en un bloque try. Este es el código de ejecución normal, en caso que no suceda errores.

Un bloque try nunca puede salir solo. Siempre tiene que se acompañado de un bloque catch y/o finally, es lo mismo aunque el bloque finally este vacío.

Curso Java


Ejemplo:

try { ..... }

10.6 catch El bloque catch permite atrapar errores que podrían suceder en el bloque previo try.

Un bloque try puede tener varios bloque catch para atrapar varias errores. En este caso, los errores mas especificos tienen que estar mencionados en primer lugar. Los errores generales en último lugar.

Ejemplo:

catch (ArithmeticException e){ ... } catch (Exception e){ ... }

10.7 finally El bloque finally se utiliza para colocar instrucciones que el código tendrá que realizar después del try y el catch. No importa si ocurrió excepción o no, el bloque finally siempre se va a realizar (con excepciones cuando se trabaja con hilos de ejecuciones y daemon).

Ejemplo:

int miResultado = 0; try { miResultado = 12/0; } catch (ArithmeticException e){ System.out.println(e); } catch (Exception e){ System.out.println("Otro error"); } finally { miResultado+=1; System.out.println(miResultado); }

11. Conexión a bases de datos Cuando se desarrolla una aplicación, muchas veces se necesita conectar a una base de datos. Java permite conectarse a las mayorías de las base de datos, por tanto que existe un driver ODBC mejorJDBC.

Un driver ODBC (Open Database Connectivity) permite utilizar un driver “genérico” para conectarse a une base de datos. Así Java se conecta al driver ODBC, y el driver ODBC se conecta a la base de datos. Es el medio más fácil de conectarse a una base de datos, pero es mucho menos eficiente que un driver JDBC.

Curso Java


Un driver ODBC (Java Database Connector) es un driver diseñado para conectarse a una base de datos. Este driveres específico a una base de datos (y a veces a una cierta versión de una base de datos).El driver JDBC se conecta directamente a la base de datos, y como él esta diseñado para esta base de datos, tiene normalmente muchas más opciones, y menos restricciones, que el ODBC.

Conexión Básicamente, hay primero que cargar el driver JDBC, luego hay que conectarse a la base de datos, y si logras eso, puedes ejecutar tus consultas SQL.

Ejemplo:

import java.sql.DriverManager; import java.sql.SQLException; public class TestDb { public static void main(String[] args) { java.sql.Connection con = null; try { try { System.out.println("Buscando el driver JDBC..."); Class.forName( "com.mysql.jdbc.Driver" // "org.postgresql.Driver" // "oracle.jdbc.driver.OracleDriver" // "com.microsoft.sqlserver.jdbc.SQLServerDriver" // "org.firebirdsql.jdbc.FBDriver" ).newInstance(); System.out.println("...Encontró el driver JDBC"); } catch (Exception e) { System.out.println("No pudo encontrar el driver JDBC !!!!"); e.printStackTrace(System.out); return; } try { System.out.println("Connectando a la base de datos..."); con = DriverManager .getConnection("jdbc:mysql://localhost/curso?user=curso&password=123" // "jdbc:postgresql://localhost/curso:5432","postgres","123" // "jdbc:oracle:thin:@192.168.0.10:1521/XE","curso","123" // "jdbc:sqlserver://192.168.0.100:1433/database=curso/user=curso/password=123" // "jdbc:firebirdsql:127.0.0.1:C:/firebird/data/curso.gdb","curso","123" ); System.out.println("...Connectado a la base de datos"); } catch (Exception e) { System.out .println("No pudo conectarse a la base de datos !!!!"); e.printStackTrace(System.out); return; } } finally { System.out.println("Cerrando la conexion a la base de datos."); try { if (con != null) con.close(); } catch (SQLException e) { e.printStackTrace(); } System.out.println("Fin"); }

Curso Java


} }

Ejecución de instrucciones SQL Para poder ejecutar instrucciones SQL en la base de datos, hay que ser conectado a la a base de datos. Una vez conectado, hay que crear la instrucción, ejecutarla, y eventualmente recoger el resultado.

Dependiendo de si la instrucción debería de regresar datos, o no, se va utilizar una lista de resultados (ResultSet) o solamente ejecutar la instrucción.

De Java se pueden también llamar a procedimientos y funciones de la base de datos.

Para evitar problemas con juegos de carácter o caracteres especiales, es mejor utilizar CallableStatement y PreparedStatement.

Ejemplo:

import java.sql.*; public class TestSql { public static void main(String[] args) { Connection con = null; PreparedStatement ps = null; Statement s = null; ResultSet rs = null; try { try { System.out.println("Buscando el driver JDBC..."); Class.forName("com.mysql.jdbc.Driver" // "org.postgresql.Driver" // "oracle.jdbc.driver.OracleDriver" // "com.microsoft.sqlserver.jdbc.SQLServerDriver" // "org.firebirdsql.jdbc.FBDriver" ).newInstance(); System.out.println("...Encontró el driver JDBC"); } catch (Exception e) { System.out.println("No pudo encontrar el driver JDBC !!!!"); e.printStackTrace(System.out); return; } try { System.out.println("Connectando a la base de datos..."); con = DriverManager .getConnection("jdbc:mysql://localhost/curso?user=curso&password=123" // "jdbc:postgresql://localhost/curso:5432","postgres","123" // "jdbc:oracle:thin:@192.168.0.10:1521/XE","curso","123" // "jdbc:sqlserver://192.168.0.100:1433/database=curso/user=curso/password=123" // "jdbc:firebirdsql:127.0.0.1:C:/firebird/data/curso.gdb","curso","123" ); System.out.println("...Connectado a la base de datos"); } catch (Exception e) { System.out .println("No pudo conectarse a la base de datos !!!!"); e.printStackTrace(System.out); return; } try { System.out

Curso Java


.println("Lista de empleados con salario inferior a $30,000"); s = con.createStatement(); rs = s .executeQuery("select concat(first_name,' ',last_name) as full_name from employee where salary < 30000"); // "select first_name||' '||last_name as full_name from employee where salary < 30000"); while (rs.next()) { System.out.println(rs.getString("full_name")); } } catch (java.sql.SQLException e) { System.out.println("Unable to step thru results of query"); showSQLException(e); return; } try { System.out .println("==============================================="); System.out .println("Lista de empleados con salario entre $30,000 y $40,000"); ps = con .prepareStatement("select concat(first_name,' ',last_name) as full_name from employee where salary between ? and ?"); // "select first_name||' '||last_name as full_name from employee where salary between ? and ?"); ps.setInt(1, 30000); ps.setInt(2, 40000); rs = ps.executeQuery(); while (rs.next()) { System.out.println(rs.getString("full_name")); } } catch (java.sql.SQLException e) { System.out.println("Unable to submit a static SQL query."); showSQLException(e); return; } } finally { System.out.println("Cerrando la conexion a la base de datos."); try { if (rs != null) { rs.close(); } } catch (java.sql.SQLException e) { showSQLException(e); } try { if (ps != null) { ps.close(); } } catch (java.sql.SQLException e) { showSQLException(e); } try { if (con != null) { con.close(); } } catch (java.sql.SQLException e) { showSQLException(e); } System.out.println("Fin"); }

Curso Java


} private static void showSQLException(java.sql.SQLException e) { java.sql.SQLException next = e; while (next != null) { System.out.println(next.getMessage()); System.out.println("Error Code: " + next.getErrorCode()); System.out.println("SQL State: " + next.getSQLState()); next = next.getNextException(); } } }

12. JSP El JSP es una extensión del lenguaje de programación Java, utilizado para crear páginas web dinámicas.

El JSP necesita que un servidor web con capacidad JSP sea instalado y funcionando para poder ejecutar las páginas JSP. Para nuestro curso hemos instalado el Apache Tomcat.

El servidor compilar el código JSP y tratarlo en tiempo real, con la información viniendo del cliente web, para regresarle una página web adaptada (html), en tiempo real.

El servidor tiene también capacidad de seguir el camino de un usuario, así cómo de identificarlo.

El JSP se necesita cuando la página web tiene que adaptarse en función del usuario, y cuando se necesita guardar valores de sesión del usuario.

Existen otros lenguaje que permiten eso, como el ASP o el PHP, pero el JSP tiene como ventaja que está basado en el lenguaje Java, y le tiene la herencia de su poder y de su portabilidad. Los servidores JSP existen para varios sistemas operativos, entre otros Windows, Linux, y Unix.

El JSP está también utilizado en paquetes empresariales muy grandes como el servidor de IBM Websphere, o el servidor de aplicación de Oracle.

El JSP es un estándar de programación Internet.

12.1 Eclipse Para diseñar las páginas JSP, vamos a utilizar la herramienta Eclipse Ganymede, en su versión J2EE o Reporting.

Este programa es libre y gratuito, y funcionan bajo Windows como bajos Linux.

Creación del servidor Eclipse integra la posibilidad de manejar una multitud de servidores web diferente desde Eclipse. Eso permita el nuevo despliegue, de manera automática, del sitio después de cada cambia. Y también permite visualizar la consola del servidor en Eclipse, para una depuración más cómoda.

Para crear un servidor, presiona CTRL + N. Escoja 'Servidor' en la lista. Luego escoje el tipo 'Tomcat 6'.

Curso Java


Creación de un nuevo proyecto web

Para crear nuestra primera página JSP, necesitamos crear un nuevo sitio web en Tomcat. Por eso, en Eclipse, creamos un nuevo proyecto de tipo 'Dynamic Web Project', que llamamos “curso”.

Escojamos como “Target Runtime” el servidor que hemos creado en el punto anterior. Como versión de modulo escojamos 2.6, y como configuración “<custom>”. Luego aceptamos los valores por defecto.

Curso Java


Una vez creado, validamos las propiedades del proyecto, y agregamos el proyecto al servidor Tomcat 6.

Para agregar el proyecto al servidor, hacer doble clic sobre el servidor en la pantalla abajo a la derecha, escoja la pestaña “Module” y agrega el proyecto “curso”.

Curso Java


Creación de la página de índice Para poder probar el servidor, vamos a crear nuestra primera página JSP.

Por eso, hacemos un clic derecho sobre la carpeta WebContent del proyecto curso, en Eclipse, y elegimos “new”... “JSP”.

Curso Java


Una vez elegido, mencionamos el nombre de la página, que será index.jsp. Todas las páginas con extensión JSP (.jsp en minuscula) serán traducidas por el servidor en un servlet (código Java) y producirán una página HTML como salida.

Para probar si la página funciona, tenemos que llenarla con algún código JSP y/o HTML. Con un doble clic sobre index.jsp abrimos su contenido. Miramos que ya viene con algún código pre definido:

Vamos a modificar el código de la manera siguiente, y lo guardamos:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <%! String titulo="Mi primera Página JSP"; int nrPagina=1; %> <title><%=titulo%></title> </head> <body bgcolor="#FFFFFF"> <h1><%=titulo%></h1> <hr> <p> Este es mi página en JSP numero <%= nrPagina%>. </body> </html>

En el futuro, no escribiré en el manual los encabezados generados por el entorno, como <%@page...> <!DOCTYPE....> porque no son obligatorio para que funciona bien el código.

Iniciamos el servidor.

Curso Java


Luego miramos el resultado con un navegador web en el domicilio: http://localhost::8080/curso/ o http://localhost:8080/curso/index.jsp

Por defecto, si ninguna página esta especificada en el URL, el servidor busca primero la página index.html, luego index.htm, y luego index.jsp. Esta opción puede ser modificada al nivel del servidor, y/o al nivel del sitio, en el archivo web.xml.

12.2 Scriptlets Los scriptlets son las etiquetas que permiten de delimitar el código JSP, que tiene que ser analizado por el servidor JSP, del código HTML, que tiene que ser enviado al cliente como tal. Así el servidor JSP combina el código HTML con el resultado del código JSP para obtener la página HTML que será regresada al cliente y leída por el navegador del cliente.

El JSP es la parte de la programación que se ejecuta al nivel del servidor, en contra del JavaScript, que se ejecuta al lado del cliente.

Scriptlets para Declaración de variables El scriptlet de declaración de variable sirven para declarar variable que serán accesible de desde cualquier lugar de la página JSP. Son equivalente a variable de clase.

Los scriptlets se utilizan generalmente a dentro de la cabecera, o en el cuerpo de la página HTML, antes de los scriptlets de código.

El scriptlet de declaración está encerrada entre “<%!” y “%>”

Ejemplo:

<%! String titulo="Mi primera Página JSP"; int nrPagina=1; %>

Scriptlets para código Un scriptlet de código está encerrado entre “<%” y “%>”.

Un scriptlet de código puede ser utilizado para escribir el código Java que se ejecutara en la página JSP. Se puede utilizar para declara clases cómo para implementar esquema de decisión a dentro de la página para que sea dinámica.

Los scriptlets se pueden utilizar a dentro de la cabecera, o en el cuerpo de la página HTML.

Si el scriptlet tiene que generar algún código HTML, hay dos posibilidades:

1. El código HTML se genera a dentro el código Java utilizando el método out.print o out.println

2. Se abre un bloque de código Java, se cierra el scriptlet y se pone el código HTML cómo en una página HTML normal (pero se puede utilizar otros scriptlets a dentro de este código).

El scriptlet que genera código HMTL tendrá que estar puesto en el código HTML. Así que de costumbre las páginas JSP contienen varios scriptlets. Primero, en la cabecera, un scriptlet con el código de inicialización de las variables y el código que no genera código HTML, y en el cuerpo, el los lugares deseados, los scriptlets que generaran código HTML para completar el código HTML fijo.

Curso Java


Para agregar comentarios se debe usar dentro del scriptlet el carácter “//” o bien “/*” y “*/” para cerrar.

12.3 Directivas Las directivas de páginas dan informaciones sobre la página al servidor JSP. No generan ninguna información visible para el usuario, pero permite determinar la manera que el servidor va utilizar para tratar el código JSP de la página.

Existen tres tipos de directivas: de página, de inclusión, y taglib. Para adjuntar una directiva, hay que incluirla entre <%@y %>. La instrucción de directiva incluye el tipo de directiva, el parámetro de la directiva, el signo igual, y el valor del parámetro, en este orden.

Directiva de página La directiva de página es la más utilizada. Ella permite de especificar informaciones relativas a la configuración de la página JSP, como el tipo de contenido. Así si el contentType = "text/plain", la página JSP resultando se enseñara como texto normal, y no HTML.

Esta aconsejado de incluir las directivas de página en cima del código, antes de la etiqueta <html>.

Ejemplo:

<%@ page contentType="text/plain" %> <html> <head> <title>Test directiva de página</title> </head> <body bgcolor="white"> La fecha de hoy es <%= new java.util.Date() %> </body> </html>

Directiva de inclusión La directiva de inclusión permite incluir a dentro de la página JSP uno o varios archivos de texto o HTML. Eso permite de incluir un mismo archivo en varias paginas JSP, sin tener que copiarlo.

Los nombres de archivos incluidos pueden tener cualquiera extensión (txt, html, inc, jsp...), pero existe una extensión específica “jspf” (JSP Fragment) que permite la validación del código incluido en varios entornos (Eclipse,...).

El archivo incluido tiene que ser presente y accesible en el sistema de archivos del servidor JSP.

Ejemplo:

<html><head> <title>Test directiva de página</title> </head> <body bgcolor="white"> Aquí mi texto incluido:<br> <%@ include file="epl-v10.html" %> </body> </html>

Curso Java


Directiva taglib La directiva taglib permite de definir etiqu"etas personalizadas, para utilizar acciones personalizadas a dentro del JSP. La sintaxis es la siguiente: <%@ taglib uri="librería_de_etiquetas.tld" prefix="mi_accion" %>

Para poder utilizarlas, necesitamos aprender las acciones personalizadas, que se miran en otro curso (JSP Avanzado).

12.4 Variables de sesión Las variables de sesión son variables que se pueden atribuir a un cliente conectado, y que serán disponible por el tiempo que dura la sesión: La sesión expira cuando se cierra en navegador, o no se navega en el sitio por un cierto tiempo (depende de la configuración del servidor y se puede modificar en el código JSP), o cuando se invalida la sesión explícitamente en el código JSP.

Cada cliente conectado podrá así tener sus propios valores que se quedaran guardadas en la memoria del servidor.

Declaración: se utiliza el método setAttribute(String nombre, Object valor) del objeto session.

Ejemplo:

session.setAttribute("nombre","Juana") ;

Recuperación: se utiliza el método getAttribute(String nombre) del objeto session.

Ejemplo:

String miNombre=(String) session.getAttribute("nombre");

Para invalidar una sesión se puede realizar ocupando el método: session.invalidate ();

12.5 Los formularios Los formularios están creados simplemente en HTML. El JSP se puede utilizar a dentro del formulario para, por ejemplo, asignar valores por defecto o desactivar ciertos campos según la información disponible (variable de sesión, u otro formulario).

Es muy importante que cada campo del formulario tenga un nombre (parámetro NAME del campo).

Para el parámetro METHOD, les aconsejo siempre utilizar POST. El parámetro ACTION puede ser un servlet o una página JSP.

Aquí vamos a utilizar una página JSP.

Cuando el formulario está enviado, la página JSP a la cual se envío puede recuperar el contenido de cada campo utilizando el método getParameter o, si varias valores pueden ser elegidas a la misma vez en el campo getParameterValues, del objeto request.

Los métodos getParameter y getParameterValues acepta un parámetro: el nombre del campo por lo cual deseamos el valor.

Curso Java


Para más facilidad, se pueden guardar los valores en variables. Por defecto, todos los parámetros son de tipo String para getParameter, y String[] para getParameterValues. Si queremos cambiarlos a otro tipo, hay que utilizar los métodos Java apropiados para convertir los tipos.

El objeto request tiene también otros métodos que permiten obtener información sobre la consulta en curso, entre otros:

getLocal(): regresa los parámetros locales del PC del cliente

getRemoteAddr(): regresa el IP del PC del cliente

getRemoteHost(): regresa el nombre del PC del cliente

12.6 Servlets Un servlet es una clase Java que puede ser llamada directamente de desde el navegador web y del cual la salida puede ser leída por el navegador que la llamo.

En realidad, todas las páginas JSP están convertidas en servlet por el servidor, la primera vez que se llama la página, y luego el servidor solo ejecuta el servlet.

El servlet puede servir para generar páginas HTML, pero es un poco fastidioso hacerlo nosotros, por eso existe el JSP.El servlet que vamos a crear servirán para tratar el resultado de un formulario y después enviar el usuario a otra página, o para regresar al navegador archivos binarios usando un flujo, lo que el JSP no puede hacer. Por ejemplo, enviar al navegador una imagen o un archivo PDF que no está presente en el sistema de archivos si no en una base de datos, por ejemplo.

Los servlets, como los JavaBeans y las acciones personalizadas, permiten de encapsular la lógica, para que sea transparente para en diseñador web. Permiten también de crear códigos que son reutilizables, disminuyendo el mantenimiento, el tamaño de la aplicación, y el riesgo de error.

Un servlet es una clase Java que extiende la clase javax.servlet.http.HttpServlet. Esta clase está abstracta y debe ser subclaseada para crear un servlet HTTP capaz de servir para el web. Un servlet debe sobre escribir a lo menos un método de la siguiente:

doGet, si el servlet tiene que maneja consultas HTTP utilizando el método GET.

doPost, si el servlet tiene que maneja consultas HTTP utilizando el método GET POST.

doPut, si el servlet tiene que maneja consultas HTTP utilizando el método PUT

doDelete, si el servlet tiene que maneja consultas HTTP utilizando el método DELETE

init and destroy, para manejar recursos que son guardados por la vida del servlet

getServletInfo, que el servlet utiliza para entregar información sobre el mismo.

En realidad, solo el doGet y doPost son utilizadas, porque los métodos de consulta PUT e DELETE no se utilizan.

Ejemplo:

public class NombreDelServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { ... } } public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException

Curso Java


{ ... } }

Los métodos init y destroy solo se utilizan en caso de que el servlet tiene que guardar recursos durante toda su vida.

Servet simple Un servlet es una clase Java que extiende la clase HttpServlet, y por la cual se sobre define el método doGet o el método doPost. El doPost es un poco más lento que el doGet, pero permite tratar formularios de más de 2000 caracteres lo que el doGet no puede.

Para que el servlet sea accesible en el sitio, el tiene que ser definido en el archivo de configuración del sitio web, que es el archivo web.xml, que se encuentra bajo la carpeta WEBINF.

Ejemplo:

formuServlet.jsp :

<html> <head> <title>Prueba de formulario enviado a un servlet</title> </head> <body bgcolor="#CCDDAA"> <h1>Formulario para Servlet</h1> <hr><p> <form name="formulario" action="servlet/ProcesFormulario" method=POST> <table border=0><tr> <th>Su nombre:</th><td><input type=text name="nombre" size=30></td> </tr><tr> <th></th><td><button type=submit>Enviar</td> </tr></table> </form> </body> </html>

ProcesFormulario.java

package servlet; import javax.servlet.*; import javax.servlet.http.*; import java.io.*; import java.util.*; public class ProcesFormulario extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { } public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { PrintWriter out = response.getWriter(); response.setContentType("text/html"); out.println("<html>"); out.println("<head>"); out.println("<title>Resultado del Servlet</title>"); out.println("</head>");

Curso Java


out.println("<body>"); out.println("<h1>Su nombre es :"+request.getParameter("nombre")+"</h1>"); out.println("<hr>"); out.println("Este página fue generada por un servlet!"); out.println("</body>"); out.println("</html>"); } catch (Exception e) { PrintWriter out = response.getWriter(); response.setContentType("text/html"); out.println("the error is:"+e.toString()); out.flush(); System.out.println("<center><font size=5> Error in inserting the data</font></center>"); System.out.println("the error is:"+e.toString()); System.out.println("Error is:"+e.toString()); } } }

web.xml

<?xml version="1.0" encoding="ISO-8859-1"?> <!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd"> <web-app> <servlet> <servlet-name>ProcesFormulario</servlet-name> <display-name>ProcesFormulario</display-name> <servlet-class>servlet.ProcesFormulario</servlet-class> </servlet> <servlet-mapping> <servlet-name>ProcesFormulario</servlet-name> <url-pattern>/servlet/ProcesFormulario</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>index.jsp</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.html</welcome-file> </welcome-file-list> </web-app>

Servlet para mostrar imágenes o archivos binarios Para poder mostrar imágenes o archivos binarios guardados en una base de datos, hay que utilizar un servlet, y el paquete com.oreilly.servlet. El uso de este paquete es gratuito para uso no comercial. Para uso comercial, refiérase a: http://servlets.com/cos/license.html

Los servlets que permiten traer archivos binarios de desde la base de datos, son contenidos en una clase lamada Retriever en el paquete doc. La librería de servlet llamada “COS” de O’Reilly esta colocada debajo de /WEBINF/lib, así como la del driver de la base de datos.

Ejemplo:

Curso Java


Blob.jsp:

<%@page contentType="text/html" %> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html> <link href="curso.css" rel="stylesheet"> <head> <title>Lectura de BLOB's</title></head> <jsp:useBean id="readDB" scope="page" class="bean.LeerDB" /> <body bgcolor="#FFFFFF"> <h1>Lista de archivos binarios disponibles:</h1> <hr><img src="servlet/DocRetriever?photo_id=1"> <table class="table3"> <th class="th2">Adjunto</th> <th class="th2">Commentario</th> </tr> <% int chk=0; readDB.consulta("select photo_id,photo_filename from photo_gallery"); while (readDB.getNext()) { chk+=1; out.println("<tr>"); out.print("<td class=\"td2\"><a href=\"servlet/DocRetriever?photo_id="+ readDB.getString("photo_id")+"\" target=\"_blank\">"+ readDB.getString("photo_filename")+"</a>"); out.print("</td><td class=\"td3\">"+readDB.getString("photo_filename")+"</td>"); out.print("</tr>"); } if (chk==0) { out.print("<td width=\"25%\"></td><td width=\"45%\">No hay adjuntos.</td>"); out.print("<td align=\"center\"><input type=\"button\" value=\"Manejo de adjuntos\" onClick=\"window.open(href='adjuntos.jsp')\"></td></tr>"); } readDB.cleanup(); %> </table> </body> </html>

Con esto damos por concluido el curos contando ya con las herramientas necesarias para realizar páginas web bien estructuradas, enriquecidas en diseño, mantenibles, eficientes, basadas en Java y habilitadas para conectarse a diferentes bases de datos para transferir información.

Modulo 3 - Java

Documents

Transcript of Modulo 3 - Java