manual java servlets

8/3/2019 Manual Java Servlets

http://slidepdf.com/reader/full/manual-java-servlets 1/99

Diplomado Java Servlets

ÍNDICE

Introducción a Java ..................................................................................................................... 4¿Qué es JAVA? ............................................................................................................................4La Simplicidad de Java ............................................................................................................... 4

Java posee bibliotecas de clases estándares ................................................................................. 5Java es multiplataforma ............................................................................................................... 5El Look-and-Feel ......................................................................................................................... 6C es poco robusto .........................................................................................................................6Java sí es robusto ......................................................................................................................... 7Java es flexible ............................................................................................................................. 7Java administra automáticamente la memoria ............................................................................ 8Programación Orientada a Objetos .............................................................................................. 9Mecanismos básicos de la POO ................................................................................................. 10Resumen ..................................................................................................................................... 11Programando JAVA ................................................................................................................... 13

El compilador y el intérprete de Java ........................................................................................ 13................................................................................................................................................... 13Estructura de un programa básico en java ................................................................................. 13Tu Primera Aplicación de Java en Windows ............................................................................. 14Crear tu Primer Applet ............................................................................................................... 15Variables y Tipos ....................................................................................................................... 16

Tipos primitivos ............................................................................................................. 18Expresiones y operadores .......................................................................................................... 19

Aritmética ...................................................................................................................... 20Operadores unarios sobre expresiones numéricas ......................................................... 22Incremento y decrementos ............................................................................................. 22

Operadores de comparaciones ....................................................................................... 23Operadores entre valores booleanos (operadores lógicos) .............................................24Conversiones: cast ......................................................................................................... 25Precedencia de Operadores ............................................................................................ 25

Declaración de variables ............................................................................................................ 25Arreglos, condicionales y ciclos................................................................................................ 28Arreglos...................................................................................................................................... 28Condicionales ............................................................................................................................. 30Condicionales if ......................................................................................................................... 30Condicionales switch ................................................................................................................. 31Ciclos ......................................................................................................................................... 33

Ciclo for ..................................................................................................................................... 33Ciclo while...do .......................................................................................................................... 34Ciclo do...while .......................................................................................................................... 34Trabajando con objetos .............................................................................................................. 35El cuerpo de una Clase Java .......................................................................................................39Implementar Métodos Java ........................................................................................................ 40Control de acceso los componentes de la Clase .........................................................................43Applets ....................................................................................................................................... 45

Ing. Joel González Estrada 1




Gráficos ...................................................................................................................................... 49Componentes básicos de la intercaz de usuario AWT ............................................................. 52Botones ...................................................................................................................................... 53Etiquetas .................................................................................................................................... 57Listas .......................................................................................................................................... 58

Campo de Texto ......................................................................................................................... 60Áreas de Texto ........................................................................................................................... 62Canvas ........................................................................................................................................ 63Barras de desplazamiento .......................................................................................................... 65Practicas ..................................................................................................................................... 67Servlets ....................................................................................................................................... 76Introducción a los Servlets ......................................................................................................... 76¿Porqué se afirma que los servlets podrán sustituir a los CGI's? .............................................. 77Ventajas de los Servlets ............................................................................................................. 78Ejemplos de aplicación de los servlets .......................................................................................79Arquitectura del paquete Servlets .............................................................................................. 80Un Servlet Sencillo .................................................................................................................... 82Interactuar con los Clientes ........................................................................................................ 83Peticiones y Respuestas ............................................................................................................. 84Manejo de peticiones GET y POST ........................................................................................... 85Inicializar un Servlet .................................................................................................................. 87Destruir un Servlet .................................................................................................................... 89Acceso a bases de datos mediante servlets y jdbc ..................................................................... 90Ejemplo 1: Acceso a una base de datos Microsoft ................................................................... 91Ejecución de la aplicación ......................................................................................................... 92Código del Servlet ServletOpinion2. java ................................................................................. 93Pagina Web .............................................................................................................................. 97Practicas ..................................................................................................................................... 97






1. Introducción a Java

Al final del capitulo el alumno será capaz de...

Comprender con exactitud que es JavaVentajas ante otros lenguajes de programaciónSus características de JavaManejo de los conceptos de la Programación Orientada

a Objetos (POO)Familiarizarse con la filosofía de POO.

Comprueba tu avance y marca con una √ los objetivos alcanzados.





Introducción a Java

¿Qué es JAVA?

Java es solo es otro lenguaje de programación con el que se pueden

escribir programas que corran en Internet. Java es más parecido alenguajes de programación como C, C++, Visual Basic o Pascal que alenguajes de descripción como HTML o lenguajes para escribir guionescomo JavaScript.

Java es un lenguaje de programación orientado a objetos desarrollado por Sun Microsystems. Fundamentado en C++, el lenguaje Java sediseño para ser pequeño, sencillo y portátil a través de las plataformas ysistemas operativos.

Java se menciona frecuentemente en el contexto del WWW, donde los

Navegadores, reclaman ser “autorizados por Java” esto significa que elnavegador puede en cuestión bajar y ejecutar programas en Java.

Java se escribió como un lenguaje de programación de propósitogeneral con el que se pueden abordar los mismos tipos de tarea oresolver el mismo tipo de problemas que con otros lenguajes de programación como C o C++.

La Simplicidad de Java

Java ha sido diseñado de modo de eliminar las complejidades de otroslenguajes como C y C++.Si bien Java posee una sintaxis similar a C, con el objeto de facilitar lamigración de C hacia a Java, Java es semánticamente muy distinto a C:

• Java no posee aritmética de punteros: La aritmética de punteros es elorigen de muchos errores de programación que no se manifiestandurante la depuración y que una vez que el usuario los detecta sondifíciles de resolver.

• No se necesita hacer delete: Determinar el momento en que se debeliberar el espacio ocupado por un objeto es un problema difícil de

resolver correctamente. Esto también es el origen a errores difíciles dedetectar y solucionar.• No hay herencia múltiple: En C++ esta característica da origen a

muchas situaciones de borde en donde es difícil predecir cuál será elresultado. Por esta razón en Java se opta por herencia simple que esmucho más simple de aprender y dominar.





Java posee bibliotecas de clases estándares

Toda implementación de Java debe tener las siguientes bibliotecas declases:• Manejo de archivos

• Comunicación de datos• Acceso a la red Internet• Acceso a bases de datos• Interfaces gráficas

La interfaz de programación de estas clases es estándar, es decir entodas ellas las operaciones se invocan con el mismo nombre y losmismos argumentos.

Java es multiplataforma

La independencia de plataforma es una de las ventas significativas quetiene Java sobre otros lenguajes de programación. Esto significa que un programa puede ejecutarse en cualquier sistema operativo. Los programas pueden ejecutarse en cualquier sistema que tenga instaladouna maquina virtual.Si esta escribiendo software para el WWW, la posibilidad de correr elmismo programa en sistemas diferentes es crucial para el éxito del programa.

Los programas en Java pueden ejecutarse en cualquiera de las siguientes

plataformas, sin necesidad de hacer cambios:• Windows/95 y /NT• Power/Mac• Unix (Solaris, Silicon Graphics, ...)

La compatibilidad es total:A nivel de fuentes: El lenguaje es exactamente el mismo en todas las plataformas.A nivel de bibliotecas: En todas las plataformas están presentes lasmismas bibliotecas estándares.

A nivel del código compilado: el código intermedio que genera elcompilador es el mismo para todas las plataformas. Lo que cambia es elintérprete del código intermedio.





El Look-and-Feel

Lo único que varia de acuerdo a la plataforma es el look-and-feel . Un programa en Windows/95 tendrá el aspecto característico de esta plataforma (en cuanto a la forma de los botones, barras de

deslizamiento, menús, etc.). El mismo programa en Unix tendrá elaspecto característico de Motif. Y en Power/Mac se verá como un programa para Macintosh.

Sin embargo el código que escriben los programadores no tiene quetener presente las características de ninguna de estas plataformas. Es laimplementación de la interfaz gráfica estándar de Java la que se encargade desplegar las ventanas con el look-and-feel de la plataforma local.

C es poco robusto

Se dice que el lenguaje C es un lenguaje poco robusto porque a menudoun error de programación se traduce en un mensaje críptico del estilosegmentation fault. Este tipo de mensajes se origina en 4 erroresclásicos:• Se accesa un elemento de un arreglo con un índice fuera derango.Ejemplo: a[-3]=5;• Se usa un puntero como si referenciara a una estructura de tipoA, cuando en realidad en esa área de memoria hay una estructura de tipoB, incompatible con A. En C esto ocurre debido al uso de casts.

Ejemplo: *(int*)pdistance• Se usa un puntero a una estructura cuyo espacio ya se liberó.Luego volveremos a hablar de este punto.Ejemplo: free(p); *p= 1;• Al usar aritmética de punteros se comete un error.Ejemplo: *(p+i*sizeof(*p))Todos estos errores conducen a que tarde o temprano se use un punteroque direcciona un área de memoria no asignada por el sistemaoperativo. Esto es lo que detiene la ejecución con el mensajesegmentation fault.

Lo más desagradable de este tipo de errores es que es muy difícildeterminar en qué línea del código está la verdadera fuente del error.Podría ser en cualquier parte del programa. Encontrar la línea puedellevar varios días y hasta semanas, incluso en el caso de programadoresexpertos.





Java sí es robusto

En Java no se pueden cometer los 4 errores mencionados:• Java siempre chequea los índices al accesar un arreglo.• Java realiza chequeo de tipos durante la compilación (al igual que C).

En una asignación entre punteros el compilador verifica que los tipossean compatibles.Además, Java realiza chequeo de tipos durante la ejecución (cosa que Cy C++ no hacen). Cuando un programa usa un cast para accesar unobjeto como si fuese de un tipo específico, se verifica durante laejecución que el objeto en cuestión sea compatible con el cast que se leaplica. Si el objeto no es compatible, entonces se levanta una excepciónque informa al programador la línea exacta en donde está la fuente delerror.

• Java posee un recolector de basuras que administra automáticamentela memoria. Es el recolector el que determina cuando se puede liberar

el espacio ocupado por un objeto. El programador no puede liberar explícitamente el espacio ocupado por un objeto.• Java no posee aritmética de punteros, porque es una propiedad que no

se necesita para programar aplicaciones. En C sólo se necesita laaritmética de punteros para programa malloc/free o para programar elnúcleo del sistema operativo.

Por lo tanto Java no es un lenguaje para hacer sistemas operativos oadministradores de memoria, pero sí es un excelente lenguaje para programar aplicaciones.

Java es flexible

Pascal también es un lenguaje robusto, pero logra su robustez prohibiendo tener punteros a objetos de tipo desconocido.Lamentablemente esta prohibición es demasiado rígida. Aunque son pocos los casos en que se necesita tener punteros a objetos de tipodesconocido, las contorsiones que están obligados a realizar los programadores cuando necesitan estos punteros dan origen a programasilegibles.Lisp por su parte es un lenguaje flexible y robusto. Todas las variables

son punteros a objetos de cualquier tipo (un arreglo, un elemento delista, etc.). El tipo del objeto se encuentra almacenado en el mismoobjeto. Durante la ejecución, en cada operación se chequea que el tipodel objeto manipulado sea del tipo apropiado. Esto da flexibilidad a los programadores sin sacrificar la robustez. Lamentablemente, esto haceque los programas en Lisp sean poco legibles debido a que al estudiar su código es difícil determinar cuál es el tipo del objeto que referenciauna variable.





Java combina flexibilidad, robustez y legibilidad gracias a una mezclade chequeo de tipos durante la compilación y durante la ejecución. EnJava se pueden tener punteros a objetos de un tipo específico y tambiénse pueden tener punteros a objetos de cualquier tipo. Estos punteros se pueden convertir a punteros de un tipo específico aplicando un cast , en

cuyo caso se chequea en tiempo de ejecución de que el objeto sea de untipo compatible.El programador usa entonces punteros de tipo específico en la mayoríade los casos con el fin de ganar legibilidad y en unos pocos casos usa punteros a tipos desconocidos cuando necesita tener flexibilidad. Por lotanto Java combina la robustez de Pascal con la flexibilidad de Lisp, sinque lo programas pierdan legibilidad en ningún caso.

Java administra automáticamente la memoria

En Java los programadores no necesitan preocuparse de liberar un trozode memoria cuando ya no lo necesitan. Es el recolector de basuras elque determina cuando se puede liberar la memoria ocupada por unobjeto.

Un recolector de basuras es un gran aporte a la productividad. Se haestudiado en casos concretos que los programadores han dedicado un40% del tiempo de desarrollo a determinar en qué momento se puedeliberar un trozo de memoria.

Además este porcentaje de tiempo aumenta a medida que aumenta la

complejidad del software en desarrollo. Es relativamente sencillo liberar correctamente la memoria en un programa de 1000 líneas. Sin embargo,es difícil hacerlo en un programa de 10000 líneas. Y se puede postular que es imposible liberar correctamente la memoria en un programa de100000 líneas.

Para entender mejor esta afirmación, supongamos que hicimos un programa de 1000 líneas hace un par de meses y ahora necesitamoshacer algunas modificaciones. Ahora hemos olvidado gran parte de losdetalles de la lógica de este programa y ya no es sencillo determinar siun puntero referencia un objeto que todavía existe, o si ya fue liberado.

Peor aún, suponga que el programa fue hecho por otra persona y evalúecuan probable es cometer errores de memoria al tratar de modificar ese programa.Ahora volvamos al caso de un programa de 100000 líneas. Este tipo de programas los desarrolla un grupo de programadores que pueden tomar años en terminarlo. Cada programador desarrolla un módulo queeventualmente utiliza objetos de otros módulos desarrollados por otros programadores. ¿Quién libera la memoria de estos objetos? ¿Cómo se





ponen de acuerdo los programadores sobre cuándo y quién libera unobjeto compartido? ¿Como probar el programa completo ante lasinfinitas condiciones de borde que pueden existir en un programa de100000 líneas?

Es inevitable que la fase de prueba dejará pasar errores en el manejo dememoria que sólo serán detectados más tarde por el usuario final.Probablemente se incorporan otros errores en la fase de mantención.Se puede concluir:

• Todo programa de 100000 líneas que libera explícitamente lamemoria tiene errores latentes.

• Sin un recolector de basuras no hay verdadera modularidad.• Un recolector de basuras resuelve todos los problemas de manejo de

memoria en forma trivial.

La pregunta es: ¿Cuál es el impacto de un recolector de basura en el

desempeño de un programa?

El sobrecosto de la recolección de basuras no es superior al 100%. Esdecir si se tiene un programa que libera explícitamente la memoria yque toma tiempo X, el mismo programa modificado de modo que utiliceun recolector de basuras para liberar la memoria tomará un tiempo nosuperior a 2X.

Este sobrecosto no es importante si se considera el periódico incrementoen la velocidad de los procesadores. El impacto que un recolector de basura en el tiempo de desarrollo y en la confiabilidad del software

resultante es muchos más importante que la pérdida en eficiencia.

Programación Orientada a Objetos

La programación orientada a objetos (POO) se distingue por pensar enlos problemas y sus soluciones a través de la implementación de objetosy sus comportamientos. Las características fundamentales de laProgramación Orientada a objetos son: abstracción, encapsulamiento,herencia y polimorfismo.

Abstracción.Por medio de la abstracción se consigue no detenerse en los detallesconcretos de implementación en cada momento, sino generalizar ycentrarse en los aspectos que permiten tener una visión del problema.

Encapsulamiento.Permite ver un objeto como una caja negra en la que se ha introducidode alguna manera tosa la información relacionada con dicho objeto.





Esto permite manipular los objetos como unidades básicas, permaneciendo ocultar su estructura interna.

Herencia.Permite el acceso automático a la información contenida en otras clases.

De esta forma, la reutilización de código está garantizada. Con laherencia todas las clases están clasificadas en una jerarquía estricta.

Polimorfismo.Esta característica permite implementar a una variedad de métodos(todos con el mismo nombre), utilizando el mismo medio de acceso.

Constructores y destructores.Un constructor es un procedimiento especial de una clase que esllamada automáticamente siempre que crea un objeto de esa clase. Sufunción es iniciar esa clase.Un destructor es un procedimiento especial de una clase que es llamadoautomáticamente siempre que se destruye una de esta clase. Su funciónes realizar cualquier tarea final en el momento de destruir cualquier objeto.

Mecanismos básicos de la POO

Los mecanismos (términos) )básicos son: objetos, mensajes, métodos yclases.

ObjetosUn programa orientado a objetos se compone únicamente de objetos, esdecir, un objeto es una entidad que tiene atributos particulares(propiedades), y una forma de operar sobre de ellos es como losmétodos (el comportamiento).

Por ejemplo. Una ventana de Windows es un objeto. El color de fondo,la anchura, la altura, etc. son propiedades. Las rutinas que permitenmaximizar, minimizar, etc. son los métodos.

Métodos

Un método se implementa en una clase de objetos y determina comotiene que actuar el objeto cuando recibe el mensaje vinculado con esemétodo.

La estructura mas interna del objeto se oculta a los usuarios que lovayan a utilizar, manteniendo como única conexión con el exterior, losmensajes.





ClaseUna clase es una platilla genérica para un conjunto de objetos concaracterísticas similares.

Resumen Java es un lenguaje que ha sido diseñado para producir software:

• Confiable: Minimiza los errores que se escapan a la fase de prueba.• Multiplataforma: Los mismos binarios funcionan correctamente en

Windows/95 y /NT, Unix/Motif y Power/Mac.• Seguro: Applets recuperados por medio de la red no pueden causar

daño a los usuarios.• Orientado a objetos: Beneficioso tanto para el proveedor de

bibliotecas de clases como para el programador de aplicaciones.• Robusto: Los errores se detectan en el momento de producirse, lo que

facilita la depuración.






2. Programando Java


Crear aplicaciones y Applets en Java, compilación yejecución.Comprender y utilizar los fundamentos de Java:

variables y tipo de datos, expresiones y operadores.Construcción y manejo de clases, objetos y métodosUtilizar las estructuras: arreglos, condicionales y ciclos.Crear Applets y entender los principios de sufuncionamiento.Utilizar las primitivas de gráficos de Java y uso deimágenesUso de los componentes de la interfaz de Usuario.






Programando JAVA

El compilador y el intérprete de Java

El ambiente de desarrollo tiene dos partes: Un compilador y un

intérprete.

El compilador Java toma el programa fuente y, en vez de generar código de maquina para archivos fuentes, genera un código de bytes.Los códigos de bytes son instrucciones muy similares al código demaquina solo que no son específicos para un procesador en particular.

Se corre un programa llamado interprete de código de bytes tomandoel archivo en formato de código de bytes y lo ejecuta.. A este interpretese le conoce como maquina virtual de Java o interprete de tiempo deejecución Java.

Compilación de programa JAVA

Estructura de un programa básico en java

Al desarrollar una aplicación en java la sintaxis básica es:

import <paquete>; puclic class <nombre_clase> [throws <exception>]{

public static void main(String arg[]) [throws <exception>]{

<instrucciones>}

}


Código de bytes de Java(Independencia de

plataforma)

Compilador Java

Código Java

Interprete deJava

(Pentium)

Interprete deJava

(Power PC)

Interprete deJava

(Unix)




Tu Primera Aplicación de Java en Windows

Tu primer programa, HolaMundo, simplemente mostrará el saludo"Hello world!". Para crear este programa, deberás.

Para escribir tu primer programa, necesitarás.1. El ambiente de desarrollo estándar de la Plataforma Java 2.2. Un Editor de texto. En este ejemplo, usaremos el Bloc de notas.

Crear un fichero fuente Java. Un fichero fuente contiene texto, escritoen el lenguaje de programación Java, que tu y otros programadores pueden entender. Se puede usar cualquier editor de texto para crear yeditar ficheros fuente. Guarde el archivo HolaMundo.java en la carpetadonde esta instalado JDK dentro del directorio BIN (Ejemplo:c:\jdk1.2.2\bin).

/* Programa: Mensaje de Hola Mundo.

Profesor: Lic. Fernando Román Vega.*/

class HolaMundo {

public static void main (String args[]) { System.out.println("Hello Mundo!");

}

}

NOTA: Al momento de asignar nombre al archivo se debe seguir una reglamuy importante:La línea en el código es el nombre de nuestra clase “class HolaMundo { “ por

lo tanto el archivo se nombrara HolaMundo.java

Compilar el fichero fuente en un fichero de bytecodes. El compilador de Java, javac, toma nuestro fichero fuente y lo traduce en instruccionesque la Máquina Virtual Java (Java VM) puede entender. El compilar pone estas instrucciones en un fichero de bytecodes.Desde la línea de comando del MS-DOS realice lo que se muestra en lasiguiente ventana.

Microsoft Windows 2000 [Versión 5.00.2195]

(C) Copyright 1985-1999 Microsoft Corp.

C:\>cd jdk1.2.2

C:\jdk1.2.2>cd bin

C:\jdk1.2.2\bin>javac HolaMundo.java

Con ello se genera un archivo HolaMundo.class cuando al compilar nose genera algún error.





Ejecutar le programa contenido en el fichero de bytecodes. Lamáquina virtual Java está implementada por un intérprete Java, java.Este intérprete toma nuestro fichero de bytecodes y lleva a cabo lasinstrucciones traduciéndolas a instrucciones que nuestro ordenador pudeentender.

C:\jdk1.2.2\bin>java HolaMundo

Hello Mundo!

C:\jdk1.2.2\bin>

Crear tu Primer Applet

Ahora crearás un applet Java, llamado HelloWorld, que tambiénmuestra el salido "Hello world!". Sin embargo, al contrario queHolaMundo, el applet se ejecuta sobre un navegador compatible conJava, como HotJava, Netscape Navigator, o Microsoft Internet Explorer.Para crear este applet, debes realizar los mismos pasos básicos queantes: crear un archivo fuente Java; compilarlo y ejecutar el programa.

Crear un Archivo Fuente Java.

1. Abrir NotePad y teclea el siguiente código en un nuevo documento.Graba este código como HelloWorld.java.

/* Programa Esta clase es una implementación de un applet que simplemente despliega el mensaje

Hola mundo.

Profesor: Fernando Román Vega

*/ import java.applet.*;

import java.awt.*;

public class HelloWorld extends Applet {

public void paint(Graphics g) {

g.drawString("Hello world!", 50, 25); }

}





2. También necesitas un Archivo HTML que acompañe a al applet.Teclea el siguiente código en nuevo documento del NotePad. Grabaeste código como holamundo.html.

<html><head><title>mostrar applet hola mundo</title></head>

<body bgcolor="#ffffff" text="#000000" link="#ff0000" vlink="#800000" alink="#ff00ff" background="?">

Este es mi primer applet.<br>

<applet code="helloworld.class" width=180 height=35></applet></body></html>

3. Compilar el Código Fuente. En el prompt de MS-DOS: javacHelloWorld.java El compilador debería generar el fichero de bytecodes Java, HelloWorld.class.

4. Ejecutar el Programa. Abrir el archivo holamundo.html Aunque puedes ver tu applet usando un navegado, podrías encontrar mássencillo probarlos usando la aplicación appletviewer que viene con la plataforma Java . Para ver el applet HelloWorld usando elappletviewer, teclea esto en la línea de comandos.

Appletviewer holamundo.html

Variables y Tipos

Una variable en Java es un identificador que representa una palabra de

memoria que contiene información. El tipo de información almacenadoen una variable sólo puede ser del tipo con que se declaró esa variable.

Una variable se declara usando la misma sintaxis de C. Por ejemplo lasiguiente tabla indica una declaración, el nombre de la variableintroducida y el tipo de información que almacena la variable:

Declaración identificador tipo





int i; i Entero

String s; s referencia a string

int a[ ]; a referencia a arreglo de enteros

int[ ] b; b referencia a arreglo de enteros

public static void main()String arg[]) {

...

int M edad;

String titulo;Boolean EsMayor;

...

}

Se puede encadenar varios de nombres de variables, que sean delmismo tipo, en una sola línea:

int x,y,z;String nombre, apellido;

Los nombres de las variables pueden comenzar por una letra un guión bajo o un signo de pesos ($) y después del primer carácter puede llevar cualquier letra, numero o símbolo

Java posee dos grandes categorías de tipos para las variables:

Tipos Primitivos referencias a Objetos

int, short, byte, long Strings

char, boolean Arreglos

float, double otros objetos

Las variables de tipos primitivos almacenan directamente un valor quesiempre pertenece al rango de ese tipo. Por ejemplo una variable intalmacena un valor entero como 1, 2, 0, -1, etc.

Esto significa que al asignar una variable entera a otra variable entera,se copia el valor de la primera en el espacio que ocupa la segundavariable.

Las variables de tipo referencia a objetos en cambio almacenandirecciones y no valores directamente. Una referencia a un objeto es ladirección de un área en memoria destinada a representar ese objeto. Elárea de memoria se solicita con el operador new.





Al asignar una variable de tipo referencia a objeto a otra variable seasigna la dirección y no el objeto referenciado por esa dirección. Estosignifica que ambas variables quedan refenciando el mismo objeto.La diferencia entre ambas asignaciones se observa en la siguiente

figura:

Esto tiene implicancias mayores ya que si se modifica el objetoreferenciado por r, entonces también se modifica el objeto referenciado por s, puesto que son el mismo objeto.

En Java una variable no puede almacenar directamente un objeto,

como ocurre en C y C++.

Por lo tanto cuando se dice en Java que una variable es un string, lo quese quiere decir en realidad es que la variable es una referencia a unstring.

Tipos primitivos

En la siguiente tabla se indica para cada tipo primitivo el número de bitsque se emplea en su representación y el rango de valores que se puedealmacenar en las variables de estos tipos.

Tipo Bits Rango Ejemplos

int 32 -2**31 .. 2**31-1 0, 1, 5, -120, ...short 16 -2**15 .. 2**15-1 0, 1, 5, -120, ...

byte 8 -2**7 .. 2**7-1 0, 1, 5, -120, ...

long 64 -2**63 .. 2**63-1 0, 1, 5, -120, ...

boolean 1 n/a false, true





char 16 n/a 'a', 'A', '0', '*', ...

float 32 IEEE 1.2

double 64 IEEE 1.2

Se dice que un tipo A es de mayor rango que un tipo B si A es unsuperconjunto de B. Esto quiere decir que las variables de tipo Bsiempre se pueden asignar a variables de tipo A (eventualmente con pérdida de significancia).

Por ejemplo int es de mayor rango que short, que a su vez es de mayor rango que byte. Float y double son de mayor rango que int. Double esde mayor rango que float.Esto se puede resumir en:

double > float > long > int > short > byte

Expresiones y operadores

En Java cada expresión tiene un tipo que se determina durante lacompilación, es decir es independiente del valor durante la ejecución.

Una expresión puede ser:• Una constante: 1, 1.0, true, etc.

El tipo de esta expresión es el tipo de la constante. En el ejemplo lostipos son int, double y boolean respectivamente.

• Una variable: i, s, aEl tipo de esta expresión es el tipo con que se declaró aquella variable.En el ejemplo los tipos son entero, referencia a string y referencia aarreglo.

• El resultado de una operación: i+1, a[1], etc.

El tipo se determina en función de los tipos de las expresiones que seindican como argumentos de la operación.

Java tiene prácticamente los mismos operadores de C y C++. Cada

operador acepta una, dos o tres expresiones de diversos tipos. A vecesun operador no está definido para argumentos de ciertos tipos. Por ejemplo la resta entre strings no esta definida. Pero la suma de stringsesta definida como la concatenación. A continuación veremos losoperadores más frecuentes en Java. El operador es un símbolo especialque por lo común se utiliza con expresiones.





AritméticaJava tiene 5 operadores para la aritmética básica como se muestra en latabla siguiente.

Símbolo Operación Ejemplo

+ Suma 3 + 4

- Resta 5 – 7

* Multiplicación 5 * 5

/ División 14 / 7

% Resto 20 % 7

Ejemplo

:

El siguiente código realiza operaciones aritméticas.

class Aritmetica { public static void main (String args[]) {

short x = 6;int y = 4;float a = 12.5f;float b = 7f;

System.out.println("x es " + x + ", y es " + y);System.out.println("x + y = " + (x + y));System.out.println("x - y = " + (x - y));System.out.println("x / y = " + (x / y));System.out.println("x % y = " + (x % y));System.out.println("a es " + a + ", b es " + b);System.out.println("a / b = " + (a / b));

}}

Operadores de asignaciónPuedes utilizar el operador de asignación =, para asignar un valor a otro.Además del operador de asignación básico, Java proporciona variosoperadores de asignación que permiten realizar operaciones aritméticas,lógicas o de bits y una operación de asignación al mismo tiempo.Específicamente, supón que quieres añadir un número a una variable yasignar el resultado dentro de la misma variable, como esto:i = i + 2;





Puedes ordenar esta sentencia utilizando el operador +=.i += 2;Las dos líneas de código anteriores son equivalentes.Esta tabla lista los operadores de asignación y sus equivalentes.

Operador Uso Equivale a+= op1 += op2 op1 = op1 + op2

-= op1 -= op2 op1 = op1 - op2

*= op1 *= op2 op1 = op1 * op2

/= op1 /= op2 op1 = op1 / op2

%= op1 %= op2 op1 = op1 % op2

&= op1 &= op2 op1 = op1 & op2

|= op1 |= op2 op1 = op1 | op2

^= op1 ̂= op2 op1 = op1 ̂ op2

<<= op1 <<= op2 op1 = op1 << op2>>= op1 >>= op2 op1 = op1 &gt> op2

>>>=op1 >>>=op2

op1 = op1 >>>op2

Los operandos y el resultado de estos operadores pueden ser:

Dominio Rango

int*int int

long*long long

float*float float

double*double double

• Al operar con byte y short, estos se convierten implícitamente aint.

• Cuando los tipos de los operandos no coinciden, el operando demenor rango se convierte implícitamente al tipo de mayor rango.El resultado de la operación es del tipo de mayor rango.

Ejemplos:

int a=1, b=2;int c= a + b;

short s= 1;int d= s + c; // s se convierte a int





float f= 1.0 + a; // a se convierte a float

Operadores unarios sobre expresiones numéricas

El resultado de estas operaciones es siempre del mismo tipo deloperando.Si el operando es byte o short entonces se convierte a int, se realiza laoperación y el resultado es un int.

Incremento y decrementosLos operadore ++ y – se utilizan para aumentar o disminuir el valor deuna variable. Por ejemplo el valor de var++ incrementa en 1, var— decrementa el valor de var en 1 (A diferencia de C y C++, java permiteque var sea de punto flotante)

Símbolo Operación Argumento

++ var preincremento int | short | byte | long-- var predecremento int | short | byte | long

var ++ postincremento int | short | byte | long

var -- postdecremento int | short | byte | long

El resultado de estas operaciones es siempre del mismo tipo deloperando.Ejemplos:

int a=1, b=2;

int c= +a;int d= -(c+1);

b= a++; // b= 1, a=2a= --b; // a=b= 0

(a+1)++; // error a+1 no es una variablefloat f= a;

Ing. Joel González Estrada

Símbolo Operación Argumento

+ exp nada int | long | float | double

- exp cambio de signo int | long | float | double

22




f++; // error f no es entero

Operadores de comparacionesJava tiene varias expresiones para evaluar la igualdad y la magnitud.

Todas estas expresiones devuelven un valor booleano (true o false).

Símbolo Operación

> mayor

< menor

>= mayor igual

<= menor igual

== igual

!= distinto

Frecuentemente los operadores relacionales se utilizan con otro juegode operadores, los operadores condicionales, para construir expresionesde decisión más complejas. Uno de estos operadores es && que realizala operación Y booleana . Por ejemplo puedes utilizar dos operadoresrelacionales diferentes junto con && para determinar si ambasrelaciones son ciertas. La siguiente línea de código utiliza esta técnica para determinar si un indice de un array está entre dos límites- esto es, para determinar si el indice es mayor que 0 o menor que

NUM_ENTRIES (que se ha definido previamente como un valor constante):

0 < index && index &lt NUM_ENTRIES

Observa que en algunas situaciones, el segundo operando de unoperador relacional no será evaluado. Consideremos esta sentencia:

((count > NUM_ENTRIES) && (System.in.read() != -1))

Si count es menor que NUM_ENTRIES, la parte izquierda del operandode && evalúa a false. El operador && sólo devuelve true si los dosoperandos son verdaderos. Por eso, en esta situación se puede

determinar el valor de && sin evaluar el operador de la derecha. En uncaso como este, Java no evalúa el operando de la derecha. Así no sellamará a System.in.read() y no se leerá un carácter de la entradaestandard.Aquí tienes tres operadores condicionales.

Operador Uso Devuelve true si

&& op1 && op2 op1 y op2 son verdaderos





|| op1 || op2 uno de los dos es verdadero

! ! op op es falso

Los operandos y el resultado de estos operadores pueden ser:

Dominio Rango

int*int boolean

long*long boolean

float*float boolean

double*double boolean

Operadores entre valores booleanos (operadores lógicos)

Operación Significado

exp && exp y-lógico

exp || exp o-lógico

! exp negación

Los operandos y el resultado de estos operadores son siempre

booleanos.Los operadores && y || evalúan la expresión del lado derecho sólo si esnecesario.Ejemplos:

int a=1, b=2;

boolean v= ! a<=b && a==5 || b!=4;boolean w= ((! a<=b) && a==5) || b!=4;

boolean w2= a<=b && a; // error a no es boolean

Aritmética de CadenasUna expresión especial en java es el uso del operador suma (+)paracrear y conectar cadenas.

nombre = “Fernando”nombre = nombre + “ Roman Vega”





Conversiones: cast• Java realiza conversiones implícitas de menor a mayor rango.• Eventualmente hay pérdida de significacia al convertir enteros a

punto flotante.•

Todas las conversiones de mayor a menor rango deben ser explícitas por medio del operador de cast: (tipo)expresión

Ejemplos:

int i= 1;short s= 2;int j= i+s;

s= a; // error short < ints= (short)a; // Ok

i= 1.0; // error int < doublei= (int)1.0; // Ok

f= 1.0; // error float < doublef= (float)1.0; // Ok f= 1.0f; // Ok

boolean v=(boolean)a; // error no existe conversión

Precedencia de OperadoresLa procedencia de operadores determina el orden en el cual se evalúanlas expresiones, esta procedencia, en algunos casos, puede determinar elresultado general de la expresión.

Declaración de variables

Declarar Variables Java

Ing. Joel González Estrada

Operador

. () []unarios: - + (cast)

* / %+ -

< > <= >= == !=

!||

&&

25




Como mínimo, una declaración de variable miembro tiene doscomponentes: el tipo de dato y el nombre de la variable.

tipo nombreVariable;

Una declaración mínima de variable miembro es como la declaración de

variables que se escribe en cualquier otro lugar de un programa Java,como las variables locales o los parámetros de los métodos. El siguientecódigo declara una variable miembro entera llamada unEntero dentro dela clase ClaseEnteros.

class ClaseEnteros {int unEntero;. . .// define los métodos aquí. . .

}

Observa que la declaración de variables miembro aparece dentro de laimplementación del cuerpo de la clase pero no dentro de un método.Este posicionamiento dentro del cuerpo de la clase determina que unavariable es una variable miembro.

Al igual que otras variables en Java, las variables miembro deben tener un tipo. Un tipo de variable determina los valores que pueden ser asignados a las variables y las operaciones que se pueden realizar conellas.

No se puede declarar más de una variable con el mismo nombre en lamisma clase. Por ejemplo, el siguiente código es legal.

class ClaseEnteros {int unEntero;int unEntero() { // un método con el mismo nombre

que una variable. . .

}}

Junto con el nombre y el tipo, se pueden especificar varios atributos para las variables miembro cuando se las declara: incluyendo si losobjetos pueden acceder a la variable, si la variable es una variable declase o una variable de ejemplar, y si la variable es una constante. Unadeclaración de variable se podría parecer a esto.[especificadordeAcceso] [static] [final] [transient] [volatile] tiponombredeVaraible Una declaración de variable miembro define los siguientes aspectos dela variable.





• especificadordeAcceso define si otras clases tienen acceso a lavariable. Se puede controlar el acceso a los métodos utilizando losmismos especificadores, por eso Controlar el Acceso a Variables Miembro de una Clase cubre cómo se puede controlar el acceso alas variables miembro o los métodos.

•

static indica que la variable es una variable miembro de la clase enoposición a una variable miembro del ejemplar. Se puede utilizar static para declarar métodos de clase. Miembros de Clase y de Ejemplar explica la declaración de variables de clase y de ejemplar y escribir métodos de ejemplar o de clase.

• final indica que la variable es una constante• transient la variable no es una parte persistente del estado del objeto• volatile significa que la variable es modificada de forma asíncrona.

Declarar ConstantesPara crear una variable miembro constante en Java se debe utilizar la

palabra clave final en su declaración de variable. La siguientedeclaración define una constante llamada AVOGADRO cuyo valor esel número de Avogadro (6.023 x 10^23) y no puede ser cambiado.

class Avo {final double AVOGADRO = 6.023e23;

}

Por convención, los nombres de los valores constantes se escribencompletamente en mayúsculas. Si un programa intenta cambiar una variable, el compilador muestra un mensaje de error .

Declarar Variables TransitoriasPor defecto, las variables miembro son una parte persistente del estadode un objeto, Las variables que forman parte persistente del estado delobjeto deben guardarse cuando el objeto se archiva. Se puede utilizar la palabra clave transient para indicar a la máquina virtual Java que lavariable indicada no es una parte persistente del objeto.

Al igual que otros modificadores de variables en el sistema Java, se puede utilizar transient en una clase o declaración de variable deejemplar como esta.

class TransientExample {

transient int hobo;. . .}

Este ejemplo declara una variable entera llamada hobo que no es una parte persistente del estado de la claseTransientExample.

Declarar Variables Volátiles


http://d/Java%20en%20castellano/accesscontrol.htm


http://d/Java%20en%20castellano/classvars.htm









Si una clase contiene una variable miembro que es modificada de formaasíncrona, mediante la ejecución de threads concurrentes, se puedeutilizar la palabra clave volatile de Java para notificar esto al sistemaJava. La siguiente declaración de variable es un ejemplo de comodeclarar que una variable va a ser modificada de forma asíncrona por

threads concurrentes.class VolatileExample {volatile int contador;. . .

}

Arreglos, condicionales y ciclos.

Muchas de las cosas interesantes de Java y en cualquier otro lenguaje de programación aparecen cuando tienen arreglos para almacenar valores y

estructuras de control de flujo (ciclos y condicionales) para ejecutar diferentes partes de un programa con base en pruebas.

Arreglos.

Los arreglos es una colección de elementos. En cada posición en elarreglo puede contener un objeto o un valor privitivo. En Java losarreglos son objetos y pueden ser tratados como cualquier otro objetodel lenguaje.

Declarar variables de tipo arreglo.Primeramente se debe de declarar una variable para guardar el arreglo.A continuación se presenta variables de tipo arreglo validos.String nombres[];int edades[]float estaturas[]

Un método alternativo de declaración es colocar los corchetes despuésdel tipo, no después de la variable.String[] nombres;int[] edades;

float[] estaturas;

Arreglos de objetosEl segundo paso es crear un arreglo de objetos tipo y asignarlo a esavariable. Hay dos formas de hacerlo.• Utilizar new

String[] names;





names = new String[10]; // crea un arreglo de objeto tipo cadenade 10 posiciones.

• Iniciar de manera directa el contenido del arreglo. Los elementosal ser inicializados se encierran entre llaves ({}).

float estaturas = {1.56, 1.54, 1.64, 1,76}

Acceder a los elementos del arregloUna vez que tenga el arreglo con valores inicializados para obtener elvalor almacenado de un arreglo utilice la expresión:nombre_arreglo[subindice]

estaturas[2];estaturas[0];

el subíndice inicia desde la posición 0.Cambiar los valores de un arregloPara asignar a una posición del arreglo en particular, ponga unainstrucción de asignación después de la expresión de acceso al arreglo.

estaturas[0]=1.78;nombres[3]=”Fernando Roman”

En la siguiente aplicación se ejemplifica como crear, inicializar ,

modificar y examinar partes de un arreglo.class ArrayTest {

String[] firstNames = { "Dennis", "Grace", "Bjarne", "James" };String[] lastNames = new String[firstNames.length];

void printNames() {int i = 0;System.out.println(firstNames[i] + " " + lastNames[i]);i++;System.out.println(firstNames[i] + " " + lastNames[i]);

i++;System.out.println(firstNames[i] + " " + lastNames[i]);i++;System.out.println(firstNames[i] + " " + lastNames[i]);

}

public static void main (String args[]) {ArrayTest a = new ArrayTest();





a.printNames();System.out.println("----------");a.lastNames[0] = "Ritchie";a.lastNames[1] = "Hopper";a.lastNames[2] = "Stroustrup";a.lastNames[3] = "Gosling";

a.printNames(); }

}

Condicionales

Los bloques de instrucciones es un grupo de instrucciones agrupadasentre llaves ({}). El bloque crea un nuevo espacio donde puede utilizar

y crear variables locales dentro del bloque las cuales dejaran de existir cuando se termine de ejecutar ese bloque.

void bloque {int x=0;{ //inicio del bloque

int y = 50;Sistem.out,print(“dentro del bloque: x= ”+x+” y= ”+y);

} // fin del bloque}

Condicionales if

Este tipo de condición se utiliza cuando se desea ejecutar diferentes partes del código con base en una simple prueba.

if <condición> {<instrucciones...>

}

la palabra reservada else ejecuta una instrucción alternativa si lacondición es false.

If <condiciòn> {<instrucciones...>

}else {

<instrucciones...>}





Ejercicio: se muestra un ejemplo sencillo de una forma de aplicacióncompleta. La case Peeper contiene un método llamado peepMe(), elcual verifica si el valor es par. Si lo es imprime Peep! En pantalla.

class Peeper {

void peepMe(int val) {System.out.println("Value is "

+ val + ". ");if (val % 2 == 0)

System.out.println("Peep!");}

public static void main (String args[]) {Peeper p = new Peeper();

p.peepMe(1); p.peepMe(2);

p.peepMe(54); p.peepMe(77); p.peepMe(1346);

}}

El operador condicionalEl operador condicional es una expresión, lo cual significa que regresaun valor. Este operador es mas util para condicionales muy cortas osencillas y tiene la siguiente sintaxis.

prueba ? resultado_verdadero : resultado_falso

prueba es una condición booleana, si el resultado es verdadero realizalas instrucciones que se encuentren entre el signo de interrogación (?)y los dos puntos (:). De lo contrario si el resultado de prueba es falsosolo se ejecutan las instrucciones después de los dos puntos (:).

Ejemplo:Boolean = valor;Valor = ‘a’ < ‘z’ ? a : z

Condicionales switch

Muchos de los lenguajes tienen una versión corta de los if anidadosmás fácil de leer y le permiten agrupar las condiciones y las acciones.En java se utiliza las instrucción switch y comporta como en C.





Una limitación significativa es esta instrucción en Java es que las pruebas y los valores solo pueden ser tipos primitivos, no pueden ser tipos primitivos mas grandes (long, float), cadenas u otros objetosdentro de un switch; tampoco puede probar otra relaciones la deigualdad. Los if anidados pueden funcionar para cualquier tipo de

prueba en cualquier tipo de datos.switch (test) {

case valor1: <instrucciones...>;break;



.......default resultado_defaul;

} Las instrucción switch, test es comparada con cada uno de los valoresdel caso (case: valor:) en orden, si se encuentra alguna coincidencialas instrucciones se ejecutan solo las de ese caso. A continuación se presenta una aplicación en la cual se pasa un valor entero al métodoconvertNum() y este lo interpreta como en letra, para ser mostrado enletra el numero.

class NumberReader {

String convertNum(int val) {

switch (val) {case 0: return "zero ";case 1: return "one ";case 2: return "two ";case 3: return "three ";case 4: return "four ";case 5: return "five ";case 6: return "six ";case 7: return "seven ";case 8: return "eight ";case 9: return "nine ";

default: return " ";}

}

public static void main (String args[]) { NumberReader n = new NumberReader();

String num = n.convertNum(4) + n.convertNum(1) +n.convertNum(5);





System.out.println("415 converts to " + num);}

}

Ciclos

Ciclo for

El ciclo repite un bloque de instrucciones o una instrucción, hasta queuna condición se cumpla. Los ciclos for frecuentemente se utilizan parainteracciones sencillas donde se repite las instrucciones un ciertonumero de veces y después se detiene.

Sintaxis:for (inicialización; condición; incremento) {

<instrucciones...>

}

inicialización: Se inicia una variable que determinara el inicio del ciclo.incremento: incrementar la variable de inicialización que ayudara hacer el numero de veces de repetición.

Tomando el ejemplo del arreglos se modifica para desplegar losnombres completos por medio del ciclo for.

class NamesLoop {

String[] firstNames = { "Dennis", "Grace", "Bjarne", "James" };String[] lastNames = new String[firstNames.length];

void printNames() {for (int i = 0; i < firstNames.length; i++)

System.out.println(firstNames[i] + " " + lastNames[i]);} public static void main (String args[]) {

ArrayTest a = new ArrayTest();a.printNames();System.out.println("----------");a.lastNames[0] = "Ritchie";

a.lastNames[1] = "Hopper";a.lastNames[2] = "Stroustrup";a.lastNames[3] = "Gosling";a.printNames();

}}





Ciclo while...do

Este tipo de ciclo se repite un bloque de instrucciones, mientras algunacondición sea verdadera. Su sintaxis es.

while (condición) {<instrucciones...>}

si la condiciones verdadera el ciclo while se ejecuta y después prueba lacondición de nuevo para verificar si es verdadera y volver a ejecutarse,repitiéndola hasta que sea falsa. Igual como en el ciclo for también puede emplear instrucciones individuales en lugar de bloques.

Ejemplo: Copiar los elementos de un arreglo de enteros a un arreglo devalores de punto flotante, convirtiendo cada elemento mediante castinga punto flotante. El ciclo terminara inmediatamente si alguno de loselementos del primer arreglo es 0.

class CopyArrayWhile { public static void main (String args[]) {

int[] array1 = { 5, 7, 3, 6, 0, 3, 2, 1 };float[] array2 = new float[array1.length];

System.out.print("array1: [ ");for (int i = 0; i < array1.length; i++) {

System.out.print(array1[i] + " ");}

System.out.println("]");System.out.print("array2: [ ");

int count = 0;while ( count < array1.length && array1[count] != 0) {

array2[count] = (float) array1[count];System.out.print(array2[count++] + " ");

}System.out.println("]");

}}

Ciclo do...while

El ciclo do es como el ciclo while, excepto que do ejecuta unainstrucción(es) hasta que la condición sea falsa. La principal diferenciaente ambos consiste en que while prueba la condición antes de entrar.Los ciclos do entrar por lo menos una vez antes de probar la condición.Su sintaxis es.





do {<instrucciones...>

} while (condición)

Para ejemplificar el funcionamiento de este se siglo, el código imprimelos valores del 1 al 10.

class DoTest{public static void main (String args[]) {

int x = 1;

do {System.out.println("Looping, round " + x);x++;

} while (x <= 10);}

}

Trabajando con objetosCrear Objetos en JavaEn Java, se crea un objeto mediante la creación de un objeto de unaclase o, en otras palabras, ejemplarizando una clase. Aprenderás cómocrear una clase más adelante en Crear Clases.

Hasta entonces, los ejemplos contenidos aquí crean objetos a apartir declases que ya existen en el entorno Java. Frecuentemente, se verá lacreación de un objeto Java con un sentencia como esta.

Date hoy = new Date();

Esta sentencia crea un objeto Date (Date es una clase del paquete java,util). Esta sentencia realmente realiza tres acciones: declaración,ejemplificación e inicialización.

Date hoy es una declaración de variable que sólo le dice al compilador que el nombre hoy se va a utilizar para referirse a un objeto cuyo tipo es


http://d/Java%20en%20castellano/declaclase.htm

http://d/Java%20en%20castellano/declaclase.htm




Date, el operador new ejemplariza la clase Date (creando un nuevoobjeto Date), y Date() inicializa el objeto.

Declarar un ObjetoYa que la declaración de un objeto es una parte innecesaria de la

creación de un objeto, las declaraciones aparecen frecuentemente en lamisma línea que la creación del objeto. Como cualquier otra declaraciónde variable, las declaraciones de objetos pueden aparecer solitariascomo esta.

Date hoy;

De la misma forma, declarar una variable para contener un objeto esexactamente igual que declarar una variable que va a contener un tipo primitivo.

Las declaraciones notifican al compilador que se va a utilizar nombre para referirse a una variable cuyo tipo es tipo. Las declaraciones nocrean nuevos objetos. Date hoy no crea un objeto Date, sólo crea unnombre de variable para contener un objeto Date. Para ejemplarizar laclase Date, o cualquier otra clase, se utiliza el operador new.

Ejemplarizar una ClaseEl operador new ejemplariza una clase mediante la asignación dememoria para el objeto nuevo de ese tipo. new necesita un sóloargumento: una llamada al método constructor. Los métodosconstructores son métodos especiales proporcionados por cada claseJava que son responsables de la inicialización de los nuevos objetos deese tipo. El operador new crea el objeto, el constructor lo inicializa.

Aquí tienes un ejemplo del uso del operador new para crear un objetoRectangle (Rectangle es una clase del paquete java.awt).new Rectangle(0, 0, 100, 200);

En el ejemplo, Rectangle(0, 0, 100, 200) es una llamada al constructor de la clase Rectangle. El operador new devuelve una referencia alobjeto recién creado. Esta referencia puede ser asignada a una variabledel tipo apropiado.

Rectangle rect = new Rectangle(0, 0, 100, 200);

Inicializar un ObjetoComo se menciono anteriormente, las clases proporcionan métodosconstructores para inicializar los nuevos objetos de ese tipo. Una clase podría proporcionar múltiples constructores para realizar diferentestipos de inicialización en los nuevos objetos.

Cuando veas la implementación de una clase, reconocerás losconstructores porque tienen el mismo nombre que la clase y no tienen





tipo de retorno. Recuerda la creación del objeto Date en el seccióninicial. El constructor utilizado no tenía ningún argumento. Date()

Un constructor que no tiene ningún argumento, como el mostradoarriba, es conocido como constructor por defecto. Al igual que Date, la

mayoría de las clases tienen al menos un constructor, el constructor por defecto. Si una clase tiene varios constructores, todos ellos tienen elmismo nombre pero se deben diferenciar en el número o el tipo de susargumentos. Cada constructor inicializa el nuevo objeto de una formadiferente. Junto al constructor por defecto, la clase Date proporcionaotro constructor que inicializa el nuevo objeto con un nuevo año, mes ydía.

Date cumpleaños = new Date(1963, 8, 30);

El compilador puede diferenciar los constructores a través del tipo y delnúmero de sus argumentos.

Usar Objetos JavaUna vez que se ha creado un objeto, probablemente querrás hacer algocon él. Supón, por ejemplo, que después de crear un nuevo rectángulo,quieres moverlo a una posición diferente (es decir, el rectángulo es unobjeto en un programa de dibujo y el usuario quiere moverlo a otra posición de la página).

La clase Rectangle proporciona dos formas equivalentes de mover elrectángulo.

1. Manipular directamente las variables x e y del objeto.2. Llamar el método move().

La opción 2 se considera "más orientada a objetos" y más segura porquese manipulan las variables del objeto indirectamente a través de unacapa protectora de métodos, en vez de manejarlas directamente.Manipular directamente las variables de un objeto se considera propenso a errores; se podría colocar el objeto en un estado deinconsistencia.

Referencia a variables de un objetoPrimero, enfoquemos cómo inspeccionar y modificar la posición delrectángulo mediante la manipulación directa de las variables x e y. Lasiguiente sección mostrará como mover el rectángulo llamando almétodo move().

Para acceder a las variables de un objeto, sólo se tiene que añadir elnombre de la variable al del objeto referenciado introduciendo un puntoen el medio ('.').

objetoReferenciado.variable





Supón que tienes un rectángulo llamado rect en tu programa. puedesacceder a las variables x e y con rect.x y rect.y, respectivamente. Ahoraque ya tienes un nombre para las variables de rect, puedes utilizar esenombre en sentencias y expresiones Java como si fueran nombres devariables "normales". Así, para mover el rectángulo a una nueva

posición podrías escribir.rect.x = 15; // cambia la posición xrect.y = 37; // cambia la posición y

La clase Rectangle tiene otras dos variables--width y height--que sonaccesibles para objetos fuera de Rectangle. Se puede utilizar la mismanotación con ellas: rect.width y rect.height. Entonces se puede calcular el área del rectángulo utilizando esta sentencia.

area = rect.height * rect.width;

Cuando se accede a una variable a través de un objeto, se está refiriendoa las variables de un objeto particular. Si cubo fuera también unrectángulo con una altura y anchura diferentes de rect, esta instrucción.

area = cubo.height * cubo.width;

calcula el área de un rectángulo llamado cubo y dará un resultadodiferente que la instrucción anterior (que calculaba el área de unrectángulo llamado rect). Observa que la primera parte del nombre deuna variable de un objeto (el objetoReferenciado enobjetoReferenciado.variable) debe ser una referencia a un objeto. Comose puede utilizar un nombre de variable aquí, también se puede utilizar en cualquier expresión que devuelva una referencia a un objeto.Recuerda que el operador new devuelve una referencia a un objeto. Por eso, se puede utilizar el valor devuelto por new para acceder a lasvariables del nuevo objeto.

height = new Rectangle().height;

Llamar a Métodos de un ObjetoLlamar a un método de un objeto es similar a obtener una variable delobjeto. Para llamar a un método del objeto, simplemente se añade alnombre del objeto referenciado el nombre del método, separados por un punto ('.'), y se proporcionan los argumentos del método entre paréntesis. Si el método no necesita argumentos, se utilizan los paréntesis vacíos.

objetoReferenciado.nombreMétodo(listaArgumentos);o

objetoReferenciado.nombreMétodo();

Veamos que significa esto en términos de movimiento del rectángulo.Para mover rect a una nueva posición utilizando el método move()escribe esto.

rect.move(15, 37);





Esta sentencia Java llama al método move() de rect con dos parámetrosenteros, 15 y 37. Esta sentencia tiene el efecto de mover el objeto rectigual que se hizo en las sentencias anteriores en las que se moficabandirectamente los valores x e y del objeto.

rect.x = 15;rect.y = 37;

Si se quiere mover un rectángulo diferente, uno llamado cubo, la nueva posición se podría escribir.

cubo.move(244, 47);

Como se ha visto en estos ejemplos, las llamadas a métodos se hacendirectamente a un objeto específico; el objeto especificado en la llamadaal método es el que responde a la instrucción.Las llamadas a métodos también se conocen como mensajes.Como en la vida real, los mensajes se deben dirigir a un receptor particular.

El cuerpo de una Clase Java

Anteriormente se vio una descripción general de la implementación deuna clase. El cuerpo de una clase toma la siguiente estructura.

DeclaraciondeClase {

CuerpodeClase

}

El cuerpo de la clase compone la implementación de la propia clase ycontiene dos secciones diferentes: la declaración de variables y la demétodos. Una variable miembro de la clase representa un estado de laclase y sus métodos implementan el comportamiento de la clase. Dentrodel cuerpo de la clase se definen todas las variables miembro y losmétodos soportados por la clase.

Típicamente, primero se declaran las variables miembro de la clase yluego se proporcionan las declaraciones e implementaciones de losmétodos, aunque este orden no es necesario.

DeclaracióndeClase {

DeclaracionesdeVariablesMiembros

DeclaracionesdeMétodos

}

Aquí tienes una pequeña clase que declara tres variables miembro y unmétodo.

class Ticket {





Float precio;

String destino;

Date fechaSalida;

void firma(Float forPrecio, String

forDestino, Date forFecha) {

precio = forPrecio;

destino = forDestino;fechaSalida = forFecha;

}

}

Además de las variables miembro y los métodos que se declaranexplícitamente dentro del cuerpo de la clase, una clase puede heredar algo de su superclase. Por ejemplo, todas las clases del entorno Java sonuna descendencia (directa o indirecta) de la clase Object. La claseObject define el estado básico y el comportamiento que todos losobjetos deben tener como habilidad para comparar unos objetos con

otros, para convertir una cadena, para esperar una condición variable, para notificar a otros objetos que una condición variable ha cambiado,etc... Así, como descendentes de esta clase, todos los objetos delentorno Java heredan sus comportamientos de la clase Object.

Implementar Métodos Java

Similarmente a la implementación de una clase, la implementación deun método consiste en dos partes, la declaración y el cuerpo del método.

declaracióndeMétodo {cuerpodeMétodo

}

La Declaración de MétodoUna declaración de método proporciona mucha información sobre elmétodo al compilador, al sistema en tiempo de ejecución y a otras

clases y objetos.

Los únicos elementos necesarios para una declaración de método son elnombre y el tipo de retorno del método. Por ejemplo, el códigosiguiente declara un método llamado estaVacio() en la clase Pila quedevuelve un valor booleano (true o false).

class Pila {. . .





boolean estaVacio() {. . .

}}

Devolver un Valor desde un MétodoJava necesita que un método declare el tipo de dato del valor quedevuelve. Si un método no devuelve ningún valor, debe ser declarado para devolver void (nulo). Los métodos pueden devolver tipos de datos primitivos o tipos de datos de referencia. El método estaVacio() de laclase Pila devuelve un tipo de dato primitivo, un valor booleano.

class Pila {static final int PILA_VACIA = -1;Object[] stackelements;int topelement = PILA_VACIA;. . .boolean estaVacio() {

if (topelement == PILA_VACIA)return true;

elsereturn false;

}}

Sin embargo, el método pop de la clase PILA devuelve un tipo de datode referencia: un objeto.

class Pila {static final int PILA_VACIA = -1;Object[] stackelements;int topelement = PILA_VACIA;. . .Object pop() {

if (topelement == PILA_VACIA)return null;

else {return stackelements[topelement--];

}}

}

Los métodos utilizan el operador return para devolver un valor. Todométodo que no sea declarado como void debe contener una sentenciareturn.

El tipo de dato del valor devuelto por la sentencia return debecorresponder con el tipo de dato que el método tiene que devolver; no





se puede devolver un objeto desde un método que fue declarado paradevolver un entero.

Cuando se devuelva un objeto, el tipo de dato del objeto devuelto debeser una subclase o la clase exacta indicada. Cuando se devuelva un tipo

interface, el objeto retornado debe implementar el interfaceespecificado.

Un Nombre de MétodoUn nombre de método puede ser cualquier indentificador legal en Java.Existen tres casos especiales a tener en cuenta con los nombres demétodos.

1. Java soporta la sobrecarga de métodos, por eso varios métodos pueden compartir el mismo nombre. Por ejemplo, supon que se haescrito una clase que puede proporcionar varios tipos de datos(cadenas, enteros, etc...) en un área de dibujo. Se podría escribir unmétodo que supiera como tratar a cada tipo de dato. En otroslenguajes, se tendría que pensar un nombre distinto para cada uno delos métodos. dibujaCadena(), dibujaEntero, etc... En Java, se puedeutilizar el mismo nombre para todos los métodos pasándole un tipode parámetro diferente a cada uno de los métodos. Entonces en laclase de dibujo, se podrán declarar tres métodos llamados draw() yque cada uno aceptara un tipo de parámetro diferente.

class DibujodeDatos {void draw(String s) {

. . .}void draw(int i) {

. . .}void draw(float f) {

. . .}

} Nota: La información que hay dentro de los paréntesis de ladeclaración son los argumentos del método. Los argumentos secubren en la siguiente página: Pasar Información a un Método. Los métodos son diferenciados por el compilador basándose en elnúmero y tipo de sus argumentos. Así draw(String s)y draw(int i)son métodos distintos y únicos. No se puede declarar un método conla misma firma: draw(String s)y draw(String t) son idénticos y daránun error del compilador.Habrás observado que los métodos sobrecargados deben devolver elmismo tipo de dato, por eso void draw(String s) e int draw(String t)


http://d/Java%20en%20castellano/argumetodos.htm

http://d/Java%20en%20castellano/argumetodos.htm




declarados en la misma clase producirán un error en tiempo decompilación.2. Todo método cuyo nombre sea igual que el de su clase es unconstructor y tiene una tarea especial que realizar. Los constructoresse utilizan para inicializar un objeto nuevo del tipo de la clase. Los

constructores sólo pueden ser llamados con el operador new. Paraaprender cómo escribir un constructor, puedes ver Escribir un Método Constructor .3. Una clase puede sobrescribir un método de sus superclases. Elmétodo que sobrescribe debe tener el mismo, nombre, tipo deretorno y lista de parámetros que el método al que ha sobrescrito.Sobrescribir Métodos te enseñará como sobrescribir los métodos deuna superclase

Control de acceso los componentes de la Clase

Uno de los benéficos de las clases es que pueden proteger sus variablesy métodos miembros frente al acceso de otros objetos. En Java se pueden utilizar los especificadores de acceso para proteger tanto lasvariables como los métodos de la clase cuando se declaran. El lenguajeJava soporta cuatro niveles de acceso para las variables y métodosmiembros: private, protected, public, y, todavía no especificado, accesode paquete.

La siguiente tabla le muestra los niveles de acceso permitidos por cadaespecificador.

Especificador clase subclase paquete mundo private X

protected X X X

public X X X X

package X XLa primera columna indica si la propia clase tiene acceso al miembrodefinido por el especificador de acceso. La segunda columna indica silas subclases de la clase (sin importar dentro de que paquete seencuentren estas) tienen acceso a los miembros. La tercera columnaindica si las clases del mismo paquete que la clase (sin importar su

parentesco) tienen acceso a los miembros. La cuarta columna indica sitodas las clases tienen acceso a los miembros.

PrivateEl nivel de acceso más restringido es private. Un miembro privado esaccesible sólo para la clase en la que está definido. Se utiliza este acceso para declarar miembros que sólo deben ser utilizados por la clase. Estoincluye las variables que contienen información que si se accede a ella


http://d/Java%20en%20castellano/constructors.htm


http://d/Java%20en%20castellano/override.htm



http://d/Java%20en%20castellano/override.htm




desde el exterior podría colocar al objeto en un estado de inconsistencia,o los métodos que llamados desde el exterior pueden poner en peligro elestado del objeto o del programa donde se está ejecutando. Losmiembros privados son como secretos, nunca deben contársele a nadie.Para declarar un miembro privado se utiliza la palabra clave private en

su declaración. La clase siguiente contiene una variable miembro y unmétodo privados.class Alpha {

private int soyPrivado;private void metodoPrivado() {

System.out.println("metodoPrivado");}

}Los objetos del tipo Alpha pueden inspeccionar y modificar la variablesoyPrivado y pueden invocar el método metodoPrivado(), pero losobjetos de otros tipos no pueden acceder. Por ejemplo, la clase Betadefinida aquí.

class Beta {void metodoAccesor() {

Alpha a = new Alpha();a.soyPrivado = 10; // ilegala.metodoPrivado(); // ilegal

}}

No puede acceder a la variable soyPrivado ni al métodometodoPrivado() de un objeto del tipo Alpha porque Beta no es del tipoAlpha.

ProtectedEl siguiente especificador de nivel de acceso es 'protected' que permite ala propia clase, las subclases (con la excepción a la que nos referimosanteriormente), y todas las clases dentro del mismo paquete queaccedan a los miembros. Este nivel de acceso se utiliza cuando esapropiado para una subclase de la clase tener acceso a los miembros, pero no las clases no relacionadas. Los miembros protegidos son comosecretos familiares - no importa que toda la familia lo sepa, inclusoalgunos amigos allegados pero no se quiere que los extraños lo sepan.Para declarar un miembro protegido, se utiliza la palabra clave protected.

PublicEl especificador de acceso más sencillo es 'public'. Todas las clases, entodos los paquetes tienen acceso a los miembros públicos de la clase.Los miembros públicos se declaran sólo si su acceso no produce





resultados indeseados si un extraño los utiliza. Aquí no hay secretosfamiliares; no importa que lo sepa todo el mundo.Para declarar un miembro público se utiliza la palabra clave public. Por ejemplo,

package Griego;class Alpha {public int soyPublico;public void metodoPublico() {

System.out.println("metodoPublico");}

}Rescribamos nuestra clase Beta una vez más y la ponemos en un paquete diferente que la clase Alpha y nos aseguramos que no estánrelacionadas (no es una subclase) de Alpha.

import Griego.*; package Romano;class Beta {

void metodoAccesor() {Alpha a = new Alpha();a.soyPublico = 10; // legala.metodoPublico(); // legal

}}Como se puede ver en el ejemplo anterior, Beta puede inspeccionar ymodificar legalmente la variable soyPublico en la clase Alpha y puedellamar legalmente al método metodoPublico().

Applets

Un applet es una pequeña aplicación accesible en un servidor Internet,que se transporta por la red, se instala automáticamente y se ejecuta insitu como parte de un documento web (definición de Patrick Naughton).Dado que Java es multiplataforma y los applets son soportados por ambos navegadores, su uso se ha popularizado bastante.

Para crear un applet , debe de crear una subclase de la clase Applet. Estaclase parte del paquete java.applet, proporciona el comportamiento queel applet necesita para funcionar dentro de un navegador compatible.

Aunque su applet puede tener tantas clases adicionales como seannecesarias, la clase del applet es la que dispara su ejecución. La claseapplet inicial tendrá una firma como la siguiente:

public class mi_clase entands java.applet.Applet {





....}

Ciclo de vida de un applet

Como hemos visto, un applet se ejecuta en una página web y eseentorno en el que está va a determinar el ciclo de vida del mismo. Laclase Applet dispone de varios métodos sin código dentro a los quellama en diversas fases de su ciclo de vida (al crearse el applet, alredibujarse, al destruirse...). Si deseamos que nuestro applet haga cosasespeciales en esos momentos deberemos sobreescribir esos métodos.Son éstos:

void init()Este método se llama al crearse el applet y sólo se ejecuta esa vez. Sesuele utilizar para inicializar variables globales.

void start()Se llama cuando hay que activar el applet. Esto sucede cuando el appletse ve en la pantalla. Se suele utilizar para comenzar las actividades deapplet, ya que en general éste debe estar visible en la pantalla para poder realizar su función.

void stop()Es el inverso del anterior. Es llamado cuando el applet deja de estar visible. Se suele utilizar para interrumpir las actividades activadas enstart().

void destroy()Método llamado al destruirse el applet. Normalmente no se suelesobreescribir, ya que la destrucción del applet conlleva la destrucción detodo lo que se ha creado en él. Puede ser útil para mostrar una ventanade confirmación que pregunte al usuario si de verdad debe cargárselo.

void repaint()Este método no debería ser sobrecargado y es llamado cuando senecesita redibujar el applet. Podemos llamarlo nosotros desde nuestrocódigo. Llama a update(Graphics).

void update(Graphics)Llamado por repaint() cuando se necesita actualizar el applet. Suimplementación borra el rectángulo y llama a paint() para volver a pintarlo.

void paint(Graphics)





Método en el que se dibuja el applet y el cual deberemos sobreescribir para poder dibujar lo que nosotros deseemos..

void print(Graphics)Equivalente a paint() pero es llamado cuando se va a imprimir el

contenido del applet.El siguiente ejemplo conviene observarlo desde un navegador e ir viendo los distintos mensajes que nos muestra el applet, paracomprender cuando son llamados los métodos, antes de ejecutar elapplet se tiene que crear un archivo HTML con la siguienteetiqueta:<APPLET CODE="CicloDeVida.class" WIDTH="100"HEIGHT="400"></APPLET>

import java.applet.Applet;import java.awt.Graphics;

public class CicloDeVida extends Applet {String mensajes;public void init() {mensajes = "Inicializando. ";

}public void start() {escribirMensaje("Método start. ");

}public void stop() {escribirMensaje("Método stop. ");

}public void destroy() {escribirMensaje("Destruyendo Applet. ");

}void escribirMensaje(String nuevoMensaje) {mensajes += nuevoMensaje;repaint();

}public void paint(Graphics g) {g.drawString(mensajes, 5, 15);

}}

Paso de parámetrosCon las aplicaciones java, puede pasar parámetros su rutina main()utilizando argumentos en la línea de comando, después puede analizar esos argumentos dentro del cuerpo de su clase y la aplicación actuara deacuerdo con los argumentos que se le dieron.





Sin embargo los applets no tiene línea de comando esto para que sea posible enviar argumentos a los applets se realiza esto, entre<APPLET> y </APPLET> podremos colocar etiquetas PARAM quenos permitirán pasar parámetros al applet. Tienen dos atributos:

NAME Nombre del parámetro.

VALUE Valor del parámetro.Los parámetros enviados el applet podrá obtener esos valores por mediodel método getParameter(String), como se muestra en el siguienteejemplo:

<APPLET CODE="MostrarMensaje.class" WIDTH="200"HEIGHT="70"><PARAM NAME="Mensaje" VALUE="Mi mensaje pio">

</APPLET>

import java.applet.Applet;

import java.awt.*;

public class MostrarMensaje extends Applet {String mensaje;public void init() {mensaje = getParameter("Mensaje");

}public void paint(Graphics g) {g.drawString(mensaje,20,20);

}}

Hay que destacar que Java no distingue entre mayúsculas y minúsculasen cuanto al nombre de los parámetros.

En muchos casos, el usuario puede que no incluya parámetros queconsideramos necesarios o que escriba mal el nombre de un parámetro.En ese caso, la llamada a getParameter() nos devolverá null. Debemostener cuidado con esto, ya que nos pueden saltar excepciones por estaclase de cosas. Así pues, el código correcto de init() será:

public void init() {mensaje = getParameter("Mensaje");

if (mensaje==null)mensaje = "Mensaje por defecto";}

De este modo, si nos equivocamos en la etiqueta PARAM, nos mostraráun mensaje y no lanzará ninguna excepción.





Gráficos

La clase GraphicsCon las capacidad gráficas básicas que vienen con las bibliotecas de la

clases java, proporciona un conjunto de gráficos sencillos integrado para dibujar ciertas figuras geométricas.

Métodos de dibujoMientras no se especifique, consideraremos que todos los parámetrosson enteros:drawString(String texto,x,y) Escribe un texto a partir de lascoordenadas (x,y).

drawLine(x1,y1,x2,y2) Dibuja una línea entre las coordenadas (x1,y1)y (x2,y2).

drawRect(x,y,ancho,alto)fillRect(x,y,ancho,alto)clearRect(x,y,ancho.alto)Son tres métodos encargados de dibujar, rellenar y limpiar,respectivamente, un rectángulo cuya esquina superior izquierda está enlas coordenadas (x,y) y tienen el ancho y alto especificados.

drawRoundRect(x,y,ancho,alto,anchoArco,altoArco)fillRoundRect(x,y,ancho,alto,anchoArco,altoArco)Equivalentes a los anteriores, pero con las esquinas redondeadas. La

forma y tamaño de dichas esquinas viene dada por los dos últimos parámetros.

draw3DRect(x,y,ancho,alto,boolean elevado)fill3DRect(x,y,ancho,alto,boolean elevado)Equivalentes a los primeros, pero dibujan un borde para dar la sensaciónde que está elevado o hundido (dependiendo del valor del último parámetro).

drawOval(x,y,ancho,alto)fillOval(x,y,ancho,alto)

Dibujan una elipse con esquina izquierda superior en (x,y) y el ancho yalto especificados. Si son iguales dibujará un círculo.

drawArc(x,y,ancho,alto,anguloInicio,anguloArco)fillArc(x,y,ancho,alto,anguloInicio,anguloArco)Dibuja una arco cuyo primer vértice está en (x,y) y el segundo en(x+ancho,y+alto). La forma del mismo vendrá dado por los dos últimos parámetros.





drawPolygon(int[] coordenadasX,int[] coordenadasY,numCoordenadas)fillPolygon(int[] coordenadasX,int[] coordenadasY,numCoordenadas)Dibuja un polígono cerrado del número de puntos especificado en elúltimo parámetro.

copyArea(xOrigen,yOrigen,ancho,alto,xDest,yDest)Copia el área cuya esquina superior izquierda está en (xOrigen,yOrigen)y de ancho y alto especificados a la zona que comienza en (xDest,yDest).

Un ejemplo sencillo de un applet que utiliza algunos métodos paradibujar uan figura rudimentaria, es este caso es una lampara con unasombra de motas.

import java.awt.*; public class Lamp extends java.applet.Applet {

public void paint(Graphics g) {

// the lamp platformg.fillRect(0,250,290,290);

// the base of the lampg.drawLine(125,250,125,160);g.drawLine(175,250,175,160);

// the lamp shade, top and bottom edgesg.drawArc(85,157,130,50,-65,312);g.drawArc(85,87,130,50,62,58);

// lamp shade, sides

g.drawLine(85,177,119,89);g.drawLine(215,177,181,89);

// dots on the shadeg.fillArc(78,120,40,40,63,-174);g.fillOval(120,96,40,40);g.fillArc(173,100,40,40,110,180);}

}





Recuperar y utilizar de imágenesAún cuando podemos hacer cosas con figuras, no estaría de más poder hacer cosas con imágenes, que son bastante más espectaculares. Parahacerlo deberemos utilizaremos el siguiente método:drawImage( Image img,int x,int y,ImageObserver observador )

Image es un objeto que representa a la imagen. Normalmente crearemosun objeto Image por medio del método de Applet getImage():Image img = getImage(URL base, String fichero)

Asigna la imagen contenida en la URL donde se encuentre el ficheroque contiene la imagen que queremos presentar y el nombre de esefichero.

Normalmente obtendremos esa dirección a partir de la página dondeesté la página HTML o nuestro applet. Para averiguarlo disponemos dedos métodos en la clase Applet:

URL getDocumentBase(). Devuelve la URL donde está la páginaHTML (excluyendo el nombre del fichero).URL getCodeBase(). Devuelve la URL donde está el applet(excluyendo el nombre del fichero).

Si deseamos obtener una URL distinta deberemos importar esa clase(java.net.URL) y crear uno pasándole una cadena como parámetro alconstructor conteniendo la URL. Normalmente, se realiza el getImage()en el método init() del applet, ya que en el momento en que ejecutemoseste método comenzará la carga de imágenes desde Internet y esoconviene hacerlo cuanto antes. Para mostrar la imagen se utiliza el

método paint(), al igual que hemos hecho para pintar cosas. Por ejemplo, suponiendo que tengamos un fichero llamado home.jpg:

import java.awt.Graphics;import java.awt.Image;

public class LadyBug extends java.applet.Applet {Image bugimg;public void init() {





bugimg = getImage(getCodeBase(),"images/ladybug.gif");

}

public void paint(Graphics g) {int iwidth = bugimg.getWidth(this);

int iheight = bugimg.getHeight(this);int xpos = 10;

// 25 %g.drawImage(bugimg, xpos, 10,

iwidth / 4, iheight / 4, this);

// 50 %xpos += (iwidth / 4) + 10;g.drawImage(bugimg, xpos , 10,

iwidth / 2, iheight / 2, this);

// 100%xpos += (iwidth / 2) + 10;g.drawImage(bugimg, xpos, 10, this);

// 150% x, 25% yg.drawImage(bugimg, 10, iheight + 30,

(int)(iwidth * 1.5), iheight / 4, this);}

}

Muestra la salida del applet.

Componentes básicos de la intercaz de usuario AWT





Una de las cosas bien hechas sobre los applets es que debido a que yason contenedores AWT, puede comenzar a añadir otros componentesAWT inmediatamente.

Para cualquiera de los componentes que se verán, el procedimiento para

crear el componente es: primero lo crea, luego lo añade al applet o panel. Para agregar el componente utilice el método add(). puclic void init() {

Button b = new Button(“OK”);add(b);

}

Botones

Veremos ejemplos de cómo se añaden botones a un panel para lainteracción del usuario con la aplicación, pero antes vamos a ver la

creación de botones como objetos. Se pueden crear objetos Button conel operador new:Button boton;boton = new Button( "Botón");

La cadena utilizada en la creación del botón aparecerá en el botóncuando se visualice en pantalla. Esta cadena también se devolverá parautilizarla como identificación del botón cuando ocurra un evento.

Eventos Button

Cada vez que el usuario pulsa un botón, se produce un evento, de la

misma forma que se produce un evento cuando se aprieta el botón delratón. Los eventos de pulsación de un botón se pueden capturar sobrecargando el método action(): public boolean action( Event evt,Object obj ) {

if( evt.target instanceof Button )System.out.println( (String)obj );

elseSystem.out.println( "Evento No-Button" );

}

La distinción entre todos los botones existentes se puede hacer

utilizando el objeto destino pasado por el objeto Event y comparándolocon los objetos botón que hemos dispuesto en nuestro interface:import java.awt.*;import java.applet.Applet; public class Botones extends Applet {

Button b1,b2,b3;

public void init() {b1 = new Button( "Botón B1" );


http://www.ulpgc.es/otros/tutoriales/java/Cap4/clasev.html

http://www.ulpgc.es/otros/tutoriales/java/Cap4/clasev.html




b2 = new Button( "Botón B2" );b3 = new Button( "Botón B3" );

this.add( b1 );this.add( b2 );this.add( b3 );

}

public boolean action( Event evt,Object obj ) {if( evt.target.equals( b1 ) )

System.out.println( "Se ha pulsado el boton B1" );if( evt.target.equals( b2 ) )

System.out.println( "Se ha pulsado el boton B2" );if( evt.target.equals( b3 ) )

System.out.println( "Se ha pulsado el boton B3" );

return true;}

}

En el applet anterior, observamos que se imprime el texto asociado al botón que hayamos pulsado. Botones de Pulsación

Los botones presentados en el applet son los botones de pulsaciónestándar; no obstante, para variar la representación en pantalla y paraconseguir una interfaz más limpia, AWT ofrece a los programadoresotros tipos de botones.

Botones de Lista

Los botones de selección en una lista (Choice) permiten el rápidoacceso a una lista de elementos. Por ejemplo, podríamos implementar una selección de colores y mantenerla en un botón Choice:import java.awt.*;import java.applet.Applet;

public class BotonSeleccion extends Applet {Choice Selector;

public void init() {Selector = new Choice();

Selector.addItem( "Rojo" );Selector.addItem( "Verde" );Selector.addItem( "Azul" );

add( Selector );}

public boolean action( Event evt,Object obj ) {if( evt.target instanceof Choice )





{String color = (String)obj;

System.out.println( "El color elegido es el " + color );}

return true;}

}

En este ejemplo, la cadena proporcionada al método addItem() serádevuelta en el argumento Object de un evento Choice, por ello en elmanejador del botón de selección, comprobamos en primer lugar que setrate efectivamente de un evento generado en un botón de tipo Choice.

Botones de MarcaciónLos botones de comprobación (Checkbox) se utilizan frecuentementecomo botones de estado. Proporcionan información del tipo Sí o No

(true o false). El estado del botón se devuelve en el argumento Objectde los eventos Checkbox; el argumento es de tipo booleano: verdadero

(true) si la caja se ha seleccionado y falso (false) en otro caso.

Tanto el nombre como el estado se devuelven en el argumento delevento, aunque se pueden obtener a través de los métodos getLabel() y getState() del objeto Checkbox.import java.awt.*;import java.applet.Applet;

public class BotonComprobacion extends Applet {Checkbox Relleno;

public void init() {

Relleno = new Checkbox( "Relleno");add( Relleno );}

public boolean action( Event evt,Object obj ) {if( evt.target instanceof Checkbox )

System.out.println( "CheckBox: " + evt.arg.toString() );





return true;}

}El sencillo ejemplo anterior, muestra los cambios que se producen en el

estado del botón cuando la caja está o no seleccionada.

Botones de SelecciónLos botones de comprobación se pueden agrupar para formar unainterfaz de botón de radio (CheckboxGroup), que son agrupaciones de botones Checkbox en las que siempre hay un único botón activo.

import java.awt.*;import java.applet.Applet;

public class BotonRadio extends Applet {CheckboxGroup Radio;

public void init() {Radio = new CheckboxGroup();

add( new Checkbox( "Primero",Radio,true) );add( new Checkbox( "Segundo",Radio,false) );add( new Checkbox( "Tercero",Radio,false) );}

}

En el ejemplo anterior, BotonRadio.java, observamos que siempre hayun botón activo entre los que conforman el interfaz de comprobaciónque se ha implementado.

Botones AutocontenidosLa naturaleza orientada a objetos de Java nos da la posibilidad de crear botones completamente autocontenidos. En este tipo de botón, seconstruye el manejador de eventos dentro de la propia clase extendidade botón. Se pueden añadir estos botones a la aplicación, sin tener que preocuparse de los eventos que pudieran generar.

En el ejemplo siguiente, creamos el botón que muestra la figura, un botón que genera el texto "Boton Aceptar" por la salida estándar:import java.awt.*;import java.applet.Applet;


http://www.ulpgc.es/otros/tutoriales/java/Cap4/boton.html#BotonMarca

http://www.ulpgc.es/otros/tutoriales/java/Fuentes/Cap4/BotonRadio.java

http://www.ulpgc.es/otros/tutoriales/java/Cap4/boton.html#BotonMarca

http://www.ulpgc.es/otros/tutoriales/java/Fuentes/Cap4/BotonRadio.java




class BotonAceptar extends Button {

public BotonAceptar() {setLabel( "Aceptar" );

}public boolean action( Event evt,Object obj ) {

System.out.println( "Boton Aceptar" );return true;}

}

public class BotonAuto extends Applet {BotonAceptar boton;

public void init() {boton = new BotonAceptar();add( boton );}

}Es de hacer notar que no hay un método action() en la clase appletBotonAuto, la clase BotonAceptar manejará sus eventos. Si se hubiesencolocado otros objetos en el applet, se podría haber usado un métodoaction() para tratar los eventos de esos objetos.

Etiquetas

Las etiquetas ( Label ) proporcionan una forma de colocar texto estáticoen un panel, para mostrar información que no varía, normalmente, alusuario. El applet presenta dos textos en pantalla, tal como aparece en lafigura siguiente:






public class Etiqueta extends Applet {

public void init() {Label etiq1 = new Label( "Hola Java!" );Label etiq2 = new Label( "Otra Etiqueta" );

setLayout( new FlowLayout( FlowLayout.CENTER,10,10) );add( etiq1 );add( etiq2 );}

}

Listas

Las listas ( List ) aparecen en los interfaces de usuario para facilitar a losoperadores la manipulación de muchos elementos. Se crean utilizandométodos similares a los de los botones Choice. La lista es visible todo eltiempo, utilizándose una barra de desplazamiento para visualizar los

elementos que no caben en el área que aparece en la pantalla.El ejemplo siguiente, crea una lista que muestra cuatro líneas a la vez yno permite selección múltiple.


public class Lista extends Applet {



http://www.ulpgc.es/otros/tutoriales/java/Cap4/boton.html#BotonLista

http://www.ulpgc.es/otros/tutoriales/java/Cap4/boton.html#BotonLista




List l = new List( 4,false );

l.addItem( "Mercurio" );l.addItem( "Venus" );l.addItem( "Tierra" );

l.addItem( "Marte" );l.addItem( "Jupiter" );l.addItem( "Saturno" );l.addItem( "Neptuno" );l.addItem( "Urano" );l.addItem( "Pluton" );add( l );}

public boolean action( Event evt,Object obj ) {if( evt.target instanceof List )

System.out.println( "Entrada de la Lista: " + obj );

return true;}

}

Para acceder a los elementos seleccionados se utilizan los métodos getSelectedItem() o getSelectedItems(). Para listas de selección simple,cualquier selección con doble-click en la lista disparará el métodoaction() de la misma forma que con los eventos de selección en menús.

En el applet siguiente, se permite al usuario seleccionar varioselementos de los que constituyen la lista. En la figura se muestra laapariencia de una selección múltiple en este applet.


public class ListaMult extends Applet {List lm = new List( 6,true );





public void init() {Button boton = new Button( "Aceptar" );

lm.addItem( "Mercurio" );lm.addItem( "Venus" );

lm.addItem( "Tierra" );lm.addItem( "Marte" );lm.addItem( "Jupiter" );lm.addItem( "Saturno" );lm.addItem( "Neptuno" );lm.addItem( "Urano" );lm.addItem( "Pluton" );add( lm );add( boton );}

public boolean action( Event evt,Object obj ) {if( evt.target instanceof Button )

{if( "Aceptar".equals( obj ) )

{String seleccion[];

seleccion = lm.getSelectedItems();for( int i=0; i < seleccion.length; i++ )

System.out.println( seleccion[i] );}

}

return true;}

}

En este caso de la selección múltiple en una lista, utilizamos un eventoexterno para disparar las acciones asociadas a la lista. En el ejemplo,hemos incluido un botón para generar el evento que hace que el appletrecoja los elementos que hay seleccionados en la lista.

Campo de Texto

Para la entrada directa de datos se suelen utilizar los campos de texto,que aparecen en pantalla como pequeñas cajas que permiten al usuariola entrada por teclado.





Los campos de texto (TextField ) se pueden crear vacíos, vacíos con unalongitud determinada, rellenos con texto predefinido y rellenos contexto predefinido y una longitud determinada. El applet siguiente,genera cuatro campos de texto con cada una de las característicasanteriores. La imagen muestra los distintos tipos de campos.


public class CampoTexto extends Applet {TextField tf1,tf2,tf3,tf4;

public void init() {// Campo de texto vacíotf1 = new TextField();// Campo de texto vacío con 20 columnastf2 = new TextField( 20 );// Texto predefinidotf3 = new TextField( "Hola" );// Texto predefinido en 30 columnastf4 = new TextField( "Hola",30 );add( tf1 );add( tf2 );add( tf3 );add( tf4 );}

public boolean action( Event evt,Object obj ) {if( evt.target instanceof TextField )

{if( evt.target.equals( tf1 ) )

System.out.println( "Campo de Texto 1: " +evt.arg.toString() );

if( evt.target.equals( tf1 ) )System.out.println( "Campo de Texto 2: " +

evt.arg.toString() );if( evt.target.equals( tf1 ) )





System.out.println( "Campo de Texto 3: " +evt.arg.toString() );

if( evt.target.equals( tf1 ) )System.out.println( "Campo de Texto 4: " +

evt.arg.toString() );

}return true;}

}

Cuando el usuario teclea un retorno de carro en un campo de texto, segenera un evento TextField, que al igual que con los otros Componentesdel AWT podemos capturar con el método action(), tal como sedemuestra en el ejemplo.

Áreas de TextoJava, a través del AWT, permite incorporar texto multilínea dentro dezonas de texto (TextArea). Los objetos TextArea se utilizan paraelementos de texto que ocupan más de una línea, como puede ser la presentación tanto de texto editable como de sólo lectura.

Para crear una área de texto se pueden utilizar cuatro formas análogas alas que se han descrito en la creación de Campos de Texto. Peroademás, para las áreas de texto hay que especificar el número decolumnas.

Se puede permitir que el usuario edite el texto con el método setEditable() de la misma forma que se hacía en el TextField. En lafigura aparece la representación del applet que presenta dos áreas detexto, una vacía y editable y otra con un texto predefinido y no editable.

import java.awt.*;import java.applet.Applet; public class AreaTexto extends Applet {

TextArea t1,t2;public void init() {

Button boton = new Button( "Aceptar" );t1 = new TextArea();t2 = new TextArea( "Tutorial de Java",5,40 );t2.setEditable( false );add( t1 );add( t2 );add( boton );}


http://www.ulpgc.es/otros/tutoriales/java/Cap4/ctexto.html

http://www.ulpgc.es/otros/tutoriales/java/Cap4/ctexto.html




public boolean action( Event evt,Object obj ) {if( evt.target instanceof Button )

{if( "Aceptar".equals( obj ) )

{String texto = t1.getText();

System.out.println( texto );}

}

return true;}

}

Para acceder al texto actual de una zona de texto se utiliza el método getText(), tal como muestra el código anterior. Las áreas de texto nogeneran eventos por sí solas, por lo que hay que utilizar eventosexternos, para saber cuando tenemos que acceder a la informacióncontenida en el TextArea. En este caso hemos utilizado un botón quegenerará un evento al pulsarlo que hará que se recoja el texto que hayaescrito en el área de texto que constituye el applet.

Canvas

Si tenemos un applet que trabaja con imágenes directamente, ya sea unapplet gráfico o de dibujo, los lienzos o zonas de dibujo (Canvas)resultan muy útiles.

Los Canvas son un Componente básico que captura eventos deexposición (expose), de ratón y demás eventos relacionados. La clase base Canvas no responde a estos eventos, pero se puede extender esaclase base creando subclases en las que controlemos esos eventos.

Al permitir saltarse el manejo normal de eventos, y junto con losmétodos de representación gráfica, los calvas simplifican la producción

de applets que necesitan una única funcionalidad para distintas áreas.Por ejemplo, el applet Lienzo.java, contiene un manejador de eventosque controla el evento mouseDown en el canvas. Si el evento no segenera en el canvas, se le pasa al applet que lo tratará como un eventode ratón normal.



http://www.ulpgc.es/otros/tutoriales/java/Fuentes/Cap4/Lienzo.java

http://www.ulpgc.es/otros/tutoriales/java/Fuentes/Cap4/Lienzo.java




public class Lienzo extends Applet {Button boton;


setLayout( new BorderLayout( 15,15 ) );boton = new Button( "Test" );MiCanvas canv = new MiCanvas( 100,100 );

add( "Center",canv );add( "South",boton );}

public boolean action( Event evt,Object obj ) {System.out.println( "Evento: " + obj );return true;}

public boolean mouseDown( Event evt,int x, int y ) {System.out.println( "Raton: ("+x+","+y+")" );return true;}

}

class MiCanvas extends Canvas {private int ancho;private int alto;

public MiCanvas( int anc,int alt ) {ancho = anc;alto = alt;

reshape( 0,0,anc,alt );}

public void paint( Graphics g ) {g.setColor( Color.blue );g.fillRect( 0,0,ancho,alto );}

public boolean mouseDown( Event evt,int x, int y ) {if( x < ancho && y < alto )

{System.out.println( "Raton en Canvas: ("+x+","+y+")" );return true;}

return false;





}}

Barras de desplazamientoEn determinados applets que necesiten realizar el ajuste de valoreslineales en pantalla, resulta útil el uso de barras de desplazamiento(Scrollbar ). Las barras de desplazamiento proporcionan una forma detrabajar con rangos de valores o de áreas como el Componente TextArea, que proporciona dos barras de desplazamientoautomáticamente.Si queremos implementar un selector de color, como en el appletSlider.java, podemos utilizar una barra de desplazamiento para cada unode los colores primarios.


public class Slider extends Applet {Scrollbar rojo,verde,azul;

public void init() {rojo = new Scrollbar( Scrollbar.VERTICAL,0,1,0,255 );verde = new Scrollbar( Scrollbar.VERTICAL,0,1,0,255 );azul = new Scrollbar( Scrollbar.VERTICAL,0,1,0,255 );

add( rojo );add( verde );add( azul );}

}Este tipo de interfaz proporciona al usuario un punto de referenciavisual de un rango y al mismo tiempo la forma de cambiar los valores.Por ello, las barras de desplazamiento son Componentes un poco máscomplejos que los demás, reflejándose esta complejidad en susconstructores. Al crearlos hay que indicar su orientación, su valor

inicial, los valores mínimo y máximo que puede alcanzar y el porcentajede rango que estará visible.También podríamos utilizar una barra de desplazamiento para un rangode valores de color, tal como se muestra en el ejemplo.


http://www.ulpgc.es/otros/tutoriales/java/Cap4/atexto.html


http://www.ulpgc.es/otros/tutoriales/java/Fuentes/Cap4/Slider.java



http://www.ulpgc.es/otros/tutoriales/java/Fuentes/Cap4/Slider.java





public class Ranger extends Applet {

Scrollbar rango;public void init() {

rango = new Scrollbar( Scrollbar.HORIZONTAL,0,64,0,255 );

add( rango );}

}

Como se puede ver, el ancho de la barra es mayor, en relación alScrollbar. En este caso, maxValue representa el valor máximo para el

lado izquierdo de la barra. Si se quieren representar 64 coloressimultáneamente, es decir [0-63] a [192-255], maxValue debería ser 192.Igual que otros Componentes, las barras de desplazamiento generaneventos; pero al contrario que en el resto, se tiene que utilizar el métodohandleEvent() directamente, en lugar del método action(). El destino delevento será un objeto de la clase Scrollbar, a partir de éste se obtiene la posición de la barra de desplazamiento.Como se habrá podido observar en los applets anteriores, las barras dedesplazamiento no disponen de un display o zona donde se muestrendirectamente los valores asociados a los desplazamientos. Al contrario,si se desea eso, es necesario añadir explícitamente una caja de texto, talcomo se muestra en el ejemplo.


public class RangoRojo extends Applet {Scrollbar rango;TextField valor;Label etiqueta;

public void init() {rango = new Scrollbar( Scrollbar.HORIZONTAL,0,1,0,255 );valor = new TextField( "0",5 );





etiqueta = new Label( "Rojo (0-255)" );

setLayout( new GridLayout( 1,3 ) );valor.setEditable( false );

add( etiqueta );add( rango );add( valor );}

public boolean handleEvent( Event evt ) {if( evt.target instanceof Scrollbar )

{valor.setText(

Integer.toString( ((Scrollbar)evt.target).getValue() ) );return true;}

return super.handleEvent( evt );}

}

Ese era el código del applet que construye la ventana de la figura yactualiza el campo de texto asociado. No implementa ninguna otraacción o evento.

PracticasPractica 1 Tipo de variablesEn esta práctica se ilustran los diferentes tipos básicos de datos que semanejan en el lenguaje Java y que son int, char, short, float, boolean,double. Además de estos se pueden utilizar algunos objetos.Las estructuras de control para el control del flujo del programa son if,switch, while, do-while, for.Copie el programa variable.java que sigue, observe el resultado y hagaalgunas modificaciones.class variable

{ public static void main(String args[])throws java.io.IOException

{// TIPOS DE VARIABLESlong lx = 0, ly = 0, lz = 0; // 64 bits -9,233,372,036,854,775,808int x = 0, y=0, z=0; // 32 bits -2,147,483,648.. +2,147,483,647short sx, sy, sz; // 16 bits -32768 .. +32767





byte bx, by, bz; // 8 bits -128 .. +127

float radio, area, fz; // 32 bits IEEE 754double dox, doy, doz; // 64 bits IEEE 754

int cuenta ;StringBuffer cadena = new StringBuffer(50) ;char ch ;

Float f; // OBJETO FLOAT, ES DIFERENTE DEL TIPO float

System.out.println("VARIABLES Y OPERADORES EN JAVA");

// ENTERASx = 50;z = 1000;z *= x; // EQUIVALE A: z = z * x;

// CASTING=DISFRAZ SI SE ASIGNA UN (tipo) CAMBIA SUTIPO LA VARIABLE

sz = 5;for(sx = 1; sx < 10; sx++ )

sz = (short)(sz * (short)10);

sx = 50; // enteras cortassz = 1000;sz *= sx; // sz = sz * sx;

sz = (short)50000;z = 50000;

// DESPLEGADO DE VARIABLES \n INDICA SALTO DERENGLON

System.out.println("50,000 con short: " + sz+ "\n50,000 con int: " + z + "\n");

// CALCULO DEL µREA DE UN CIRCULOradio = (float)5.0;area = (float)3.1416 * (radio * radio);System.out.println("El rea de un circulo de radio: "

+ radio + " es: " + area) ;

// MANEJO DE BITSbx = 0x7; // 00000111bx <<= 4; // 01110000bx += (byte)15; // 01111111System.out.println("\nValor maximo positivo de un byte: " + bx);





x = 1; // 1x <<= 2; // 100System.out.println("\n1 con 2 corrimientos (100): " + x);x <<= 1; // 1000

System.out.println("\n1 con 3 corrimientos (1000): " + x);// OPERACIONES ARITMÉTICASx = 23;y = x % 4;z = x / 4;System.out.println("\n23 % 4= " + y + "\n23 / 4= " + z + "\n");

// OPERACIONES Lógicasx = 0x7; // 111y = 0x3; // 011z = x & y;System.out.println("\nx: " + x + " & y: " + y + " = z: " + z);

// LECTURA DEL TECLADOSystem.out.println("DIGITA UNA CADENA: ");cuenta = 0;while( (ch = (char)System.in.read()) != '\n' ){

cadena.append(ch);cuenta++;

}System.out.println("\nDigitaste una cadena de "

+ cuenta + " caracteres: " + cadena);

// INICIALIZA LA VARIABLE QUE CONTIENE LO QUEESCRIBAS

cadena = new StringBuffer(10);

System.out.println("\n\nESCRIBE UN NUMERO ENTRE 0 Y10: ");

cuenta = 0;while( (ch = (char)System.in.read()) != '\n' ){

cadena.append(ch);cuenta++;

}

f = (Float)Float.valueOf(cadena.toString());fz = f.floatValue();System.out.print("\nEl n£mero es: " + fz);





if( fz > 5 )System.out.println(" es mayor que 5");

elseSystem.out.println(" es menor que 5");

x = (int)fz;switch(x){case 2:

System.out.println("el numero es dos");break;

case 4:System.out.println("el numero es cuatro");break;

case 6:System.out.println("el numero es seis");break;

case 8:System.out.println("el numero es ocho");break;

case 10:System.out.println("el numero es diez");break;

default:System.out.println("el numero es impar o fuera de 1-10");break;

}

System.out.print("Presiona una tecla "); // NO SALTARENGLON

System.in.read();

// ITERACION USANDO WHILEcuenta = 0;while( cuenta < 20 ){

System.out.print(cuenta + " ");cuenta++; // EQUIVALE A: cuenta = cuenta + 1;

}System.out.println("");

// ITERACIÓN USANDO FOR for( cuenta = 0; cuenta < 20; cuenta++ )

System.out.print(cuenta + " ");System.out.print("\n");

// ITERACIÓN USANDO DO-WHILE





cuenta = 0;do{

System.out.print(cuenta + " ");cuenta++; // cuenta = cuenta + 1;

} while( cuenta < 20);System.out.println("\n...es todo");

}}

Practica 2 Applet RelojAplicando la conversión de coordenadas polares a rectangulares yobteniendo los datos del reloj de la máquina local se puede construir unreloj analógico, motivo de esta práctica.Para controlar el click del reloj se utiliza un hilo de ejecución conocidocomo Thread, el cual se arranca en el método start y se pausa 999milésimas de segundo equivalente a un segundo en el método run.

En esta práctica queremos que combines este programa con el quedespliega árboles para que un sol que aparece por la derecha se muevaen forma curva y al tiempo que cruza de derecha a izquierda un árbol enel centro va creciendo y el día cambia de color azul claro hasta elanaranjado y luego azul marino al final del día.

El código fuente de reloj.java se muestra a continuación:

import java.awt.Graphics;import java.awt.Font;import java.util.Date;import java.lang.Math;import java.awt.Color;

public class reloj extends java.applet.Applet implements Runnable{Font tipo = new Font("Impact" ,Font.BOLD ,20);// TIEMPO DEL RELOJ INTERNO DE LA MÁQUINADate tiempo;double segundo, minuto, hora;

// HEBRA DE EjecuciónThread hilo ;

// VARIABLES DEL RELOJdouble FACTOR = (180 / 3.141592 );





// LONGITUD DE CADA MANECILLAdouble radios=50.0, radiom=40.0 ,radioh=30.0;

// ARCO DE CADA MANECILLA RESPECTO A CERO = 12:00double arco_hora,arco_minuto, arco_seg;double incremento, incremento_hora;

// COORDENADAS FINALES DE CADA MANECILLAdouble x_seg, y_seg, x_minuto, y_minuto, x_hora,y_hora;

// CENTRO DEL RELOJdouble x_centro = 100 ,y_centro = 100;

public void run(){

while(true){

tiempo = new Date();

repaint();try{

Thread.sleep(999);}catch(InterruptedException e){ }

}}public void init(Graphics g){}

public void start(){if( hilo == null ){

hilo = new Thread(this);hilo.start();

}}public void stop(){

if( hilo != null ){

hilo.stop();hilo = null;}

}public void paint(Graphics g){StringBuffer desplega = new StringBuffer(30);

// PARTE INTERNA DEL RELOJ





g.setColor(Color.white);g.fillOval( (int)(x_centro - radios), (int)(y_centro - radios),

(int)(radios * 2), (int)(radios * 2));

// CONTORNO DEL RELOJ EN FUNCIÓN DEL SEGUNDEROg.setColor(Color.blue);

g.drawOval((int)(x_centro - radios), (int)(y_centro - radios),(int)(radios * 2), (int)(radios * 2));

// TOMA EL TIEMPO ACTUAL: HORAS MINUTOS SEGUNDOShora = tiempo.getHours();minuto = tiempo.getMinutes();segundo = tiempo.getSeconds();

// FORMATEA LA HORA QUE SE DESPLIEGAg.setFont(tipo);desplega.append((int)(hora % 12));desplega.append(":");

if( minuto > 9 )desplega.append((int)minuto);else

desplega.append("0").append((int)minuto);desplega.append(":");if( segundo > 9 )

desplega.append((int)segundo);else

desplega.append("0").append((int)segundo);desplega.append(" ");if( hora > 12.0 )

desplega.append(" PM");

elsedesplega.append(" AM");g.drawString(" " + desplega.toString() ,35 ,20);

// POSICIONA EL SEGUNDEROincremento = 360.0 / 60.0; // ANGULO POR SEGUNDO

arco_seg = 90.0 + (segundo * incremento); // A PARTIR DE 0SEGUNDOS

arco_seg = arco_seg > 360.0 ? (arco_seg - 360.0) : arco_seg;

// CONVIERTE DE COORDENADAS POLARES ARECTANGULARES

x_seg = radios * Math.cos( arco_seg / FACTOR );y_seg = radios * Math.sin( arco_seg / FACTOR );

// POSICIONA EL MINUTEROarco_minuto = 90.0 +

(minuto * incremento + segundo * incremento / 60.0);arco_minuto = arco_minuto > 360.0 ?

(arco_minuto - 360.0) : arco_minuto;x_minuto = radiom * Math.cos( arco_minuto / FACTOR );





y_minuto = radiom * Math.sin( arco_minuto / FACTOR );

// POSICIONA LAS HORASincremento_hora = 360.0 / 12.0;arco_hora = 90.0 +

(hora * incremento_hora + minuto * incremento_hora / 60.0

+ segundo * incremento_hora / 3600.0);arco_hora = arco_hora > 360.0 ? (arco_hora - 360.0) : arco_hora;x_hora = radioh * Math.cos( arco_hora / FACTOR );y_hora = radioh * Math.sin( arco_hora / FACTOR );

// MANECILLA SEGUNDEROg.setColor(Color.black);g.drawLine((int)x_centro, (int)y_centro,

(int)(x_centro - x_seg), (int)(y_centro - y_seg));

// MANECILLA MINUTEROg.setColor(Color.red);

g.drawLine((int)x_centro, (int)y_centro,(int)(x_centro - x_minuto) ,(int)(y_centro - y_minuto));

// MANECILLA HORASg.setColor(Color.blue);g.drawLine((int)x_centro, (int)y_centro,

(int)(x_centro - x_hora) ,(int)(y_centro - y_hora));}

}






3. Servlets


Comprender la tecnología de los Servlets y diferenciaentre los CGI´sCaracterísticas, estructura y arquitectura de los ServletsManejo de los métodos del la clase HttpServletConfiguración del entorno de Java Web Server Accesos a base de datos por el Web






Servlets

Introducción a los Servlets

Cuando se habla de aplicaciones para Web comúnmente escuchamoshablar de JAVA, y con ello sus aplicaciones mas conocidas, losApplets, que son programas que se pueden cargar a través de una red yque se ejecutan de igual forma en cualquier plataforma, todo ellogracias a las potentes características de JAVA. Hasta hace poco, JAVAse utilizaba básicamente para dotar a las páginas WEB de una mayor interactividad mediante los Applets, y por tanto solo actuaba sobre ellado cliente. Pero el lado servidor también puede beneficiarse de todaslas ventajas que ofrece JAVA, gracias a los Servlets.

Los Servlets se diferencian de los Applets básicamente en que se

ejecutan en el servidor y en que no presentan ningún tipo de interfazgráfica puesto que se encargan de hacer el trabajo oculto, un aspectointeresante por lo que muchos programadores que hasta ahora utilizabanCGI’s, están utilizando Servlets. De hecho, los CGI's eran el únicomedio de proporcionar interacción entre el cliente y el servidor. Unejemplo muy común de uso de los CGI's son los típicos formularios queel usuario llena con sus datos que posteriormente pasan a formar partede una base de datos.

Los servlets son programas que funcionan como los CGI’sconvencionales atendiendo peticiones de un cliente teniendo al servidor

como el encargado, pero escritos en Java y con la ventaja de explotar todas las bondades de java. Por ejemplo, un servlet puede ser responsable de tomar los datos de un formulario HTML y enviarlos auna base de datos para actualización de la misma.

La API Servlet, usada para escribir servlets, no incluye nada acerca decómo son cargados los servlets, ni el ambiente en el cual corren losservlets, ni el protocolo usado para transmitir los datos del usuario. Esto permite a los servlets poder ser usados por diferentes servidores Web.

Los Servlets son un sustituto eficaz de los CGI’s: proveen la forma de

generar documentos dinámicos que son fáciles de escribir y ejecutar.También evitan el problema de desarrollar la programación según la plataforma utilizada. Los servlets son desarrollados con su propia API,una extensión estándar de Java.





¿Porqué se afirma que los servlets podrán sustituir a los CGI's?

Al comparar a los CGI’s con los servlets también nos preguntamosquién es mejor si Perl o Java. Ambos son excelentes herramientas dedesarrollo y su respuesta estará dada en función de lo que se desee

realizar.

Perl usa el concepto de módulos para agregar nuevas capacidades, por ejemplo el módulo DBI (Database Independent) que permite a losscripts de Perl acceder a las bases de datos (ODBC, Oracle, Sybase,Ingres, e Informix). Los módulos CGI incluyen funciones de ayuda parael desarrollo de CGI, incluyen rutinas para ser utilizadas dentro de los programas.

Java utiliza paquetes en lugar de módulos. El paquete API de servlets provee de muchas de las herramientas con las que cuentan los módulos

de Perl. Para el acceso a base de datos puede usarse los respectivosdrivers de conexión.

Algunas de las razones por las que se dice que los CGI's pueden ser sustituidos por servlets son :Se programan utilizando un API estandarizada JAVA, y por tanto se benefician de todas las ventajas de este potente lenguaje.Se pueden cargar indiferentemente y de forma transparente tanto desdeun disco local como desde una dirección remota, de forma totalmentetransparente.

Los Servlets pueden comunicarse entre sí, y por tanto, es posible unareasignación dinámica de la carga de proceso entre diversas máquinas.Es decir, un servlet podría pasarle trabajo a otro servlet residente en otramáquina.

Se pueden reutilizar CGI's ya hechos, incrustándolos en Servlets.Es posible utilizarlos en servidores tan populares como el Apache, elFastTrack ó el Internet Information Server.

Los Servlets son la mejor opción a partir de ahora para desarrollar aplicaciones para servidores WEB. Trabajan de forma transparente con

las filosofías GET y POST de los formularios HTML, y también, seentienden perfectamente con los Applets, pero también se puedenentender con clientes programados en cualquier otro lenguaje.





Ventajas de los Servlets

DesempeñoLos servlets son más rápidos que los CGI debido a que utilizan threads

en lugar de procesos.

Una de las quejas más comunes de los CGI/Perl es el desperdicio de losrecursos del sistema. En un ambiente típico CGI, cada petición crea unnuevo proceso el cual carga el interprete de Perl.

El interprete de Perl carga el script CGI, lo compila, y lo ejecuta.Además, si la aplicación se comunica con la BD, una nueva conexiónserá necesaria para ser hecha por cada CGI.

Los Servlets inician un nuevo thread, hilo, (mas que un nuevo proceso)con cada petición. Cada servlet es cargado una vez y usado más y más.

Nota que a diferencia de los CGI, los servlets requieren que se cuentecon una Máquina Virtual de Java (JVM) corriendo sobre el servidor todo el tiempo. Para sitios ocupados, ésta permite a los servlets usar mucho menos los recursos del sistema e incrementar el desempeño.

PortabilidadLos servlets son tan portables como cualquier otra aplicación de Java.

Muchos sitios están buscando una solución de portabilidad. Tal vezdesearían para su desarrollo usar Linux o Windows NT mientras suservidor de producción corra bajo Solaris. Ellos pueden querer vender

su aplicación Web para muchos clientes como para plataformas sea posible. Hay versiones de Perl para muchas variantes de Unix como para Windows 95 y NT. Mientras que Perl para Unix no es ciento por ciento compatible con el Perl para NT, los CGIs escritos en Perl puedenser escritos para trabajar sobre ambos. El llevar CGIs a Windows NT noes difícil de hacer, pero nunca funcionarán sin realizar al menos unamodificación. Por otro lado, los CGI pueden contener comandos deUnix que no trabajarán sobre Windows NT.

La portabilidad con los servlets de Java es mas simple. Java fuediseñado para ser portable a través de todas las plataformas,

permitiendo que las aplicaciones sean movidas fácilmente de un sistemaoperativo a otro.

SeguridadLa seguridad puede ser un problema cuando se desarrollan CGIs. Elárea de mas preocupación es el proceso de estrada del usuario. Este podría ser desde formas o desde datos dentro de un URL. Muchos CGIsescritos en Perl son vulnerables a ataques donde la finalidad del usuario





es trucar el CGI ejecutando algún comando sobre el servidor. LosServlets no están en riesgo de correr comando de shell no planeados.Los lenguajes compilados como Java (o C) proveen mejor seguridadque los lenguajes que interpretan scripts.

Los Servlets son archivos de clases compilados mientras que unCGI/Perl es manipulado en su forma de código fuente. Dependiendoquien tenga acceso al servidor Web, se puede elegir entre instalar o noel código fuente.

DesarrolloEl desarrollo con Perl es simple. Lo único que se necesita es un editor ymucha documentación de Perl.. Mientras que a muchos desarrolladoresles agrada este ambiente, hay una creciente proliferación deherramientas IDE (Integrated Development Environment) paradesarrollo. En ese campo, Java por encima de Perl. Hay IDEsdisponibles desde Sun, Microsoft, Symantec y muchas otras, proporcionando simples entornos GUI. Las IDEs pueden proveer útilesherramientas fáciles de aprender para nuevos desarrolladores.

Compartiendo el trabajo entre los desarrolladores es además es másfácil con Java, o puede asignarse en paquetes individuales. Cuando setrabaja con una aplicación CGI/Perl donde dos o mas desarrolladoresestuvieron trabajando simultáneamente, la aplicación normalmente esmanejada de un desarrollador a otro. El desarrollo de aplicaciones Javaes mucho mejor para proyectos largos.

Ejemplos de aplicación de los servlets

Algunas de las aplicaciones de servlets incluyen:Procesamiento de datos enviados con HTTPS a partir de una formaHTML, incluyendo la orden de compra o datos de una tarjeta de crédito.Un servlet como este podría ser parte de una orden de entrada al sistemade procesamiento de datos, haciendo la respectiva actualización en la base de datos, y quizá hasta un sistema de pago en línea.

Interacción múltiple entre personas. Un servlet puede manipular

múltiples peticiones al mismo tiempo; podrían sincronizar dichassolicitudes de sistemas que dan soporte, por ejemplo conferencias enlínea.

Redireccionamiento de peticiones. Los servlets pueden reenviar las peticiones a otros servidores y servlets. Esto permite que al ser usadosse balancee la carga entre varios servidores que atiendan al misma tarea,según el tipo de proceso que deban atender.





Aplicaciones más específicas implementadas con servletsCon los Servlets se puede implementar por ejemplo:Típicos sistemas middleware que hasta ahora únicamente seimplementaban con CGI's. Para consultar las bases de batos, los

Servlets pueden utilizar JDBC (Java Data Base Connection), lo que les permite extraer información de cualquier sistema de Base de Datos.

Automatización de un sistema de recepción y publicación deinformación. Por ejemplo podríamos montarnos una simple estaciónmeteorológica que permitiese acceso a su información mediante una página WEB. Por un lado tendríamos un servlet que recolectaría lainformación de los diversos tipos de censores y la almacenaría en basesde datos, y por otro lado, un servlet que se encargaría de presentar estainformación en función de las peticiones del cliente basándose en estasmismas bases de datos.Control de la recepción de correo electrónico, y de sistemas de news,chats, etc. Conviene recordar que Java está especialmente indicado parala programación utilizando los protocolos TCP/IP.Dado que pueden manejar múltiples peticiones en forma concurrente, es posible implementar aplicaciones de colaboración, como por ejemplouna aplicación de videoconferencia.

Arquitectura del paquete Servlets

El paquete javax.servlet proporciona clases e interfaces para escribir servlets. La arquitectura de este paquete se describe a continuación.

El Interface ServletLa abstracción central en el API Servlet es el interface Servlet. Todoslos servlets implementan este interface, bien directamente o, máscomúnmente, extendiendo una clase que lo implemente comoHttpServlet





El interface Servlet declara, pero no implementa, métodos que manejanel Servlet y su comunicación con los clientes. Los escritores de Servlets proporcionan algunos de esos métodos cuando desarrollan un servlet.

Interacción con el Cliente

Cuando un servlet acepta una llamada de un cliente, recibe dos objetos.• Un ServletRequest, que encapsula la comunicación desde elcliente al servidor.

• Un ServletResponse, que encapsula la comunicación de vueltadesde el servlet hacia el cliente.

ServletRequest y ServletResponse son interfaces definidos en el paquete javax.servlet.

El Interface ServletRequest

El Interface ServletRequest permite al servlet acceder a:Información como los nombres de los parámetros pasados por el cliente,el protocolo (esquema) que está siendo utilizado por el cliente, y losnombres del host remote que ha realizado la petición y la del server quela ha recibido.

El stream de entrada, ServletInputStream. Los Servlets utilizan estestream para obtener los datos desde los clientes que utilizan protocoloscomo los métodos POST y PUT del HTTP.

Los interfaces que extienden el interface ServletRequest permiten al

servlet recibir más datos específicos del protocolo. Por ejemplo, elinterface HttpServletRequest contiene métodos para acceder ainformación de cabecera específica HTTP.

El Interface ServletResponseEl Interface ServletResponse le da al servlet los métodos para responder al cliente.Permite al servlet seleccionar la longitud del contenido y el tipo MIMEde la respuesta.

Proporciona un stream de salida, ServletOutputStream, y un Writer através del cual el servlet puede responder datos.Los interfaces que extienden el interface ServletResponse le dan a losservlets más capacidades específicas del protocolo. Por ejemplo, elinterface HttpServletResponse contiene métodos que permiten al servletmanipular información de cabecera específica HTTP.


http://jserv.javasoft.com/products/java-server/documentation/webserver1.1/apidoc/javax.servlet.ServletRequest.html

http://jserv.javasoft.com/products/java-server/documentation/webserver1.1/apidoc/javax.servlet.ServletResponse.html

http://jserv.javasoft.com/products/java-server/documentation/webserver1.1/apidoc/javax.servlet.ServletInputStream.html

http://jserv.javasoft.com/products/java-server/documentation/webserver1.1/apidoc/javax.servlet.http.HttpServletRequest.html

http://jserv.javasoft.com/products/java-server/documentation/webserver1.1/apidoc/javax.servlet.ServletRequest.html

http://jserv.javasoft.com/products/java-server/documentation/webserver1.1/apidoc/javax.servlet.ServletResponse.html

http://jserv.javasoft.com/products/java-server/documentation/webserver1.1/apidoc/javax.servlet.ServletInputStream.html

http://jserv.javasoft.com/products/java-server/documentation/webserver1.1/apidoc/javax.servlet.http.HttpServletRequest.html




Capacidades Adicionales de los Servlets HTTPLas clases e interfaces descritos anteriormente construyen un servlet básico. Los servlets HTTP tienen algunos objetos adicionales que proporcionan capacidades de seguimiento de sesión. El escritor se

servlets pueden utilizar esos APIs para mantener el estado entre elservlet y el cliente persiste a través de múltiples conexiones durante un periodo de tiempo. Los servlets HTTP también tienen objetos que proporcionan cookies. El API cookie se utiliza para guardar datosdentro del cliente y recuperar esos datos.

Un Servlet Sencillo

Un Servlet Sencillo

La siguiente clase define completamente un servlet. public class SimpleServlet extends HttpServlet{

/*** Maneja el método GET de HTPP para construir una sencilla página

Web.*/public void doGet (HttpServletRequest request,

HttpServletResponse response)throws ServletException, IOException{

PrintWriter out;String title = "Simple Servlet Output";

// Primero selecciona el tipo de contenidos y otros campos decabecera de la respuesta

response.setContentType("text/html");

// Luego escribe los datos de la respuestaout = response.getWriter();

out.println("<HTML><HEAD><TITLE>");out.println(title);

out.println("</TITLE></HEAD><BODY>");out.println("<H1>" + title + "</H1>");out.println("<P>This is output from SimpleServlet.");out.println("</BODY></HTML>");out.close();

}}





• SimpleServlet extiende la clase HttpServlet, que implementa elinterface Servlet.

• SimpleServlet sobreescribe el método doGet de la clase HttpServlet.Este método es llamado cuando un cliente hace un petición GET (el

método de petición por defecto de HTTP), y resulta en una sencilla página HTML devuelta al cliente.• Dentro del método doGet

o La petición del usuario está representada por un objetoHttpServletRequest.

o La respuesta al usuario esta representada por un objetoHttpServletResponse.

o Como el texto es devuelto al cliente, el respuesta se envíautilizando el objeto Writer obtenido desde el objetoHttpServletResponse.

Interactuar con los Clientes

Un Servlet HTTP maneja peticiones del cliente a través de su métodoservice. Este método soporta peticiones estándar de cliente HTTPdespachando cada petición a un método designado para manejar esa petición. Por ejemplo, el método service llama al método doGetmostrado anteriormente en el ejemplo del servlet sencillo.

Peticiones y Respuestas Esta página explica la utilización de los objetos que representan

peticiones de clientes (un objeto HttpServletRequest) y las respuestasdel servlet (un objeto HttpServletResponse). Estos objetos se proporcionan al método service y a los métodos que service llama paramenejar peticiones HTTP.

Manejar Peticiones GET y POST Los métodos en los que delega el método service las peticiones HTTP,incluyen• doGet, para manejar GET, GET condicional, y peticiones de

HEAD• doPost, para menajar peticiones POST• doPut, para manejar peticiones PUT• doDelete, para manejar peticiones DELETE

Por defecto, estos métodos devuelven un error BAD_REQUEST (400). Nuestro servlet debería sobrescribir el método o métodos diseñados para manejar las interacciones HTTP que soporta. Esta sección muestracómo implementar método para manejar las peticiones HTTP máscomunes: GET y POST.


http://www.programacion.com/cursos/servlets_basico/simple.htm

http://www.programacion.com/cursos/servlets_basico/req-res.htm

http://www.programacion.com/cursos/servlets_basico/http-methods.htm

http://www.programacion.com/cursos/servlets_basico/simple.htm


http://www.programacion.com/cursos/servlets_basico/http-methods.htm




El método service de HttpServlet también llama al método doOptionscuando el servlet recibe una petición OPTIONS, y a doTrace cuandorecibe una petición TRACE. La implementación por defecto dedoOptions determina automáticamente que opciones HTTP son

soportadas y devuelve esa información. La implementación por defectode doTrace realiza una respuesta con un mensaje que contiene todas lascabeceras enviadas en la petición trace. Estos métodos no sesobreescriben normalmente.

Peticiones y Respuestas

Los métodos de la clase HttpServlet que manejan peticiones de clientetoman dos argumentos.

1. Un objeto HttpServletRequest, que encapsula los datos

desde el cliente.2. Un objeto HttpServletResponse, que encapsula larespuesta hacia el cliente.

Objetos HttpServletRequestUn objeto HttpServletRequest proporciona acceso a los datos decabecera HTTP, como cualquier cookie encontrada en la petición, y elmétodo HTTP con el que se ha realizado la petición. El objetoHttpServletRequest también permite obtener los argumentos que elcliente envía como parte de la petición.

Para acceder a los datos del cliente• El método getParameter devuelve el valor de un parámetronombrado. Si nuestro parámetro pudiera tener más de un valor,deberíamos utilizar getParameterValues en su lugar. El métodogetParameterValues devuelve un array de valores del parámetronombrado. (El método getParameterNames proporciona los nombres delos parámetros.• Para peticiones GET de HTTP, el método getQueryStringdevuelve en un String una línea de datos desde el cliente. Debemosanalizar estos datos nosotros mismos para obtener los parámetros y los

valores.• Para peticones POST, PUT, y DELETE de HTTP. Si esperamos los datos en formato texto, el método getReader

devuelve un BufferedReader utilizado para leer la línea de datos. Si esperamos datos binarios, el método getInputStream devuelve

un ServletInputStream utilizado para leer la línea de datos.





Objetos HttpServletResponseUn objeto HttpServletResponse proporciona dos formas de devolver

datos al usuario.• El método getWriter devuelve unWriter • El método getOutputStreamdevuelve un ServletOutputStream

Se utiliza el método getWriter para devolver datos en formato texto alusuario y el método getOutputStream para devolver datos binarios.

Si cerramos el Writer o el ServletOutputStream después de haber enviado la respuesta, permitimos al servidor saber cuando la respuestase ha completado.

Cabecera de Datos HTTPDebemos seleccionar la cabecera de datos HTTP antes de acceder aWriter o a OutputStream. La clase HttpServletResponse proporcionamétodos para acceder a los datos de la cabecera. Por ejemplo, el métodosetContentType selecciona el tipo del contenido. (Normalmente esta esla única cabecera que se selecciona manualmente).

Manejo de peticiones GET y POSTPara manejar peticiones HTTP en un servlet, extendemos la claseHttpServlet y sobreescribimos los métodos del servlet que manejan las peticiones HTTP que queremos soportar. Esta página ilustra el manejode peticiones GET y POST. Los métodos que manejan estas peticionesson doGet y doPost.

Manejar Peticiones GETManejar peticiones GET implica sobreescribir el método doGet. Elsiguiente ejemplo muestra a BookDetailServlet haciendo esto. Los

métodos explicados en Peticiones y Respuestas se muestran en negrita. public class BookDetailServlet extends HttpServlet {

public void doGet (HttpServletRequest request,HttpServletResponse response)

throws ServletException, IOException{





...// selecciona el tipo de contenido en la cabecera antes de acceder a

Writer response.setContentType("text/html");PrintWriter out = response.getWriter();

// Luego escribe la respuestaout.println("<html>" +

"<head><title>Book Description</title></head>" +...);

//Obtiene el identificador del libro a mostrar String bookId = request.getParameter("bookId");if (bookId != null) {

// Y la información sobre el libro y la imprime...

}out.println("</body></html>");out.close();

}...

}

El servlet extiende la clase HttpServlet y sobrescribe el método doGet.Dentro del método doGet, el método getParameter obtiene losargumentos esperados por el servlet.

Para responder al cliente, el método doGet utiliza un Writer del objetoHttpServletResponse para devolver datos en formato texto al cliente.Antes de acceder al writer, el ejemplo selecciona la cabecera del tipodel contenido. Al final del método doGet, después de haber enviado larespuesta, el Writer se cierra.

Manejar Peticiones POSTManejar peticiones POST implica sobreescribir el método doPost. Elsiguiente ejemplo muestra a ReceiptServlet haciendo esto. De nuevo,los métodos explicados en Peticiones y Respuestas se muestran ennegrita.

public class ReceiptServlet extends HttpServlet {

public void doPost(HttpServletRequest request,HttpServletResponse response)

throws ServletException, IOException{

...







// selecciona la cabecera de tipo de contenido antes de acceder aWriter

response.setContentType("text/html");PrintWriter out = response.getWriter();

// Luego escribe la respuestaout.println("<html>" +"<head><title> Receipt </title>" +...);

out.println("<h3>Thank you for purchasing your books from us " +

request.getParameter("cardname") +...);

out.close();}...

}

El servlet extiende la clase HttpServlet y sobreescribe el método doPost.Dentro del método doPost, el método getParameter obtiene losargumentos esperados por el servlet.

Para responder al cliente, el método doPost utiliza un Writer del objetoHttpServletResponse para devolver datos en formato texto al cliente.Antes de acceder al writer, el ejemplo selecciona la cabecera del tipo decontenido. Al final del método doPost, después de haber enviado larespuesta, el Writer se cierra.

Inicializar un Servlet

El método init proporcionado por la clase HttpServlet inicializa elservlet y graba la inicialización. Para hacer una inicialización específicade nuestro servlet, debemos sobreescribir el método init siguiendo estasreglas.

• Si ocurre un error que haga que el servlet no pueda manejar peticiones de cliente, lanzar una UnavailableException.Un jemplo de este tipo de error es la imposibilidad de establecer una

conexión requerida.• No llamar al método System.exit.• Guardar el parámetro ServletConfig para que el métodogetServletConfig pueda devolver su valor.

La forma más sencilla de hacer esto es hacer que el nuevo método initllame a super.init. Si grabamos el objeto nosotros mismos, debemos





sobreescribir el método getServletConfig para devolver el objeto desdesu nueva posición. Aquí hay un ejemplo del método init.

public class BookDBServlet ... {

private BookstoreDB books;public void init(ServletConfig config) throws ServletException {

// Store the ServletConfig object and log the initializationsuper.init(config);

// Load the database to prepare for requestsbooks = new BookstoreDB();

}...

}

El método init es bastante sencillo: llama al método super.init paramanejar el objeto ServletConfig y grabar la inicialización, y seleccionar un campo privado.

Si el BookDBServlet utilizará una base de datos real, en vez desimularla con un objeto, el método init sería más complejo. Aquí puedesver el pseudo-código de como podría ser ese método init.

public class BookDBServlet ... {

public void init(ServletConfig config) throws ServletException {

// Store the ServletConfig object and log the initializationsuper.init(config);

// Open a database connection to prepare for requeststry {

databaseUrl = getInitParameter("databaseUrl");... // get user and password parameters the same wayconnection = DriverManager.getConnection(databaseUrl,

user, password);} catch(Exception e) {

throw new UnavailableException (this,"Could not open a connection to the database");

}}...

}





Parámetros de InicializaciónLe segunda versión del método init llama al método getInitParameter.Este método toma el nombre del parámetro como argumento y devuelveun String que representa su valor.(La especificación de parámetros de inicialización es específica del

servidor. Por ejemplo, los parámetros son específicados como una propiedad cuando un servlet se ejecuta con el ServletRunner. La páginaLa Utilidad servletrunner contiene una explicación general de las propiedades y cómo crearlas).

Si por alguna razón, necesitamos obtener los nombres de los parámetros, podemos utilizar el método getParameterNames.

Destruir un Servlet

El método destroy proporcionado por la clase HttpServlet destruye elservlet y graba su destrucción. Para destruir cualquier recurso específicode nuestro servlet, debemos sobreescribir el método destroy. Estemétodo debería deshacer cualquier trabajo de inicialización y cualquier estado de persistencia sincronizado con el estado de memoria actual.El siguiente ejemplo muestra el método destroy que acompaña elmétodo init de la página anterior.

public class BookDBServlet extends GenericServlet {

private BookstoreDB books;

... // the init methodpublic void destroy() {

// Allow the database to be garbage collectedbooks = null;

}}

Un servidor llama al método destroy después de que se hayancompletado todas las llamadas de servidor, o en un servidor específicohayan pasado un número de segundos, lo que ocurra primero. Si nuestro

servlet manejar operaciones de larga ejecución, los métodos service se podrían estar ejecutando cuando el servidor llame al método destroy.Somos responsables de asegurarnos de que todos los threads hanterminado.

El método destroy mostrado arriba espera a que todas las interaccionesde cliente se hayan completado cuando se llama al método destroy, porque el servlet no tiene operaciones de larga ejecución.


http://www.programacion.com/cursos/servlets_basico/servletrunnerindex.htm

http://www.programacion.com/cursos/servlets_basico/servletrunnerindex.htm




Acceso a bases de datos mediante servlets y jdbc

Una de las tareas más importantes y más frecuentemente realizadas por los servlets es la conexión a bases de datos mediante JDBC. Esto esdebido a que los servlets son un componente ideal para hacer lasfunciones de capa media en un sistema con una arquitectura de trescapas como la mostrada a continuación.

Este modelo presenta la ventaja de que el nivel intermedio mantiene entodo momento el control del tipo de operaciones que se realizan contrala base de datos, y además, está la ventaja adicional de que los drivers

JDBC no tienen que residir en la máquina cliente, lo cual libera alusuario de la instalación de cualquier tipo de driver. En cualquier caso,tanto el Servidor http como el Servidor de Base de Datos pueden estar en la misma máquina, aunque en sistemas empresariales de ciertaimportancia esto no suele ocurrir con frecuencia.

JDBC (Java DataBase Connectivit y) es una parte del API de Java que proporciona clases para conectarse con bases de datos. Dichas clasesforman parte del package java.sql, disponible en el jdk . El nombre JDBC es fonéticamente similar a ODBC (Open DataBase

Connectivit y), que es el estándar más extendido para conectar PCs con bases de datos.


Applet / aplicación Java / Formulario

HTTP

Servidor Web (+Servlet)

Controlador JDBC

Protocolo de comunicación con la Base deDatos

Controlador de Base de Datos

Maquina Cliente

Capa intermediaMaquina Servidor

Servidor de Basede Datos




SQL (Structured Query Languag e) es un lenguaje estándar de altonivel que permite leer, escribir y en general gestionar bases de datos.

Los ejemplos que se presentan en este apartado hacen uso de estosconceptos de una forma muy simple, pero perfectamente válida para lo

que se pretende de los servlets en este documento.La arquitectura de los servlets hace que la escritura de aplicaciones quese ejecuten en el servidor sea relativamente sencilla y que seanaplicaciones muy robustas. La principal ventaja de utilizar servlets esque se puede programar sin dificultad la información que va a proporcionar entre peticiones del cliente. Es decir, se puede tener constancia de lo que el usuario ha hecho en peticiones anteriores.Además, cada objeto del servlet se ejecuta dentro de un thread de Java, por lo que se pueden controlar las interacciones entre múltiples objetos;y al utilizar el identificador de sincronización, se puede asegurar que los servlets del mismo tipo esperan a que se produzca la misma transacción,antes de procesar la petición; esto puede ser especialmente útil cuandomucha gente intenta actualizar al mismo tiempo la base de datos, o sihay mucha gente pendiente deconsultas a la base de datos cuando está en pleno proceso deactualización.

Ejemplo 1: Acceso a una base de datos Microsoft

El siguiente ejemplo muestra cómo compartir una única conexión entre

todas las peticiones de servicio.Antes de comenzar es necesario realizar los siguientes pasos paraconstruir nuestra base de datos, el código fuente Servlet y la páginaWeb que recolectara la información:

• Se deberá disponer de Microsoft Access. Con dicho programa sedebe crear una nueva base de datos, llamada por ejemploServletOpinion2.md b. En dicho archivo habrá que crear una tabla vacíallamada Opiniones_Recogidas cuyos campos se llamen nombr e,apellidos, opinion y comentarios, que sean respectivamente de tipo text,text, text y memo.

•

A continuación se debe configurar un driver para que puedaconectarse con dicha base de datos. Esto se hace a través del ODBC.Para ello se abre el Panel de Control ODBC y se elige la carpeta System

DS N. A continuación se preiona el botón Add y se selecciona el driver de Microsoft Access. Después clic en el botón Finish. En este momentoaparece un nuevo cuadro de diálogo con un campo llamado DataSource Name en el que se debe indicar el nombre con el que se quierehacer referencia a la base de datos, en este caso sera el nombre de





opinion. El campo Description permite introducir un breve textodescriptivo. presionado en el botón Select se debe elegir el ficheroServletOpinion2.md b. Con esto queda configurado el ODBC.

• Ya realizado lo anterior es necesario configurar las variables deentorno, que al momento de compilar el Servlet sean encontradas las

clases del paquete de Java Web Server esto de se hace de la siguienteforma:o En Windows 2000: Las propiedades del sistema, en laficha avanzado clic en el botón Variables de entorno. La sesiónvariables de usuario para administrador agregara una nueva,nombre de la variable será classpath y en valor de la variableintroducirá la siguiente ruta C:\jws\lib\servlet.jar (jws es eldirectorio donde esta instalo cambiara dependiendo durante lainstalación el destino cual eligió usted).o Windows98, Mellenium: modificara el archivoautoexec.bat colocando en la variable classpath la ruta

c:\jws\lib\servlet.jar

• Los archivos empleados que realizaran la conexión son la claseServletOpinion2 que se conectará con la base de datos mencionadaescribiendo en ella las opiniones de los usuarios. Dichas opiniones pueden ser recogidas con el fichero MiServlet2.htm que se incluye acontinuación de ServletOpinion2.java. Es importante prestar atención alas líneas en negrit a, en las que se concentran los conceptosfundamentales de este ejemplo.

Al momento de guardar los archivos deberá de hacerlos de la siguiente

forma:• El Servlet compilado (ServletOpinion2. class) lo guardara dentro

del directorio de Java Web Server en el directorio servlets.C:\jws\servlets

• La pagina Web dentro del directorio public_html de la carpeta deJava Web Server.

Ejecución de la aplicación

Al compilador su Servlet será en JDK, cuando ya a guardo sus archivosen su respectivo lugar como se describió anteriormente, es momento deiniciar el servidor ejecutando el demonio de Java Web Server, estedemonio se encuentra en la carpeta bin y es el archivo cuyo nombretiene httpd.exe. Deberá mantener la ventana de este programa abiertoque proporcionara el servicio.

Desde el navegador de Internet tecleara la siguiente dirección:





http://nombre_servidor:8080/MiServlet2.htm

Se abrirá la página del formulario que enviara los datos que tecleo alServlet ServletOpinion2.

En este ejemplo cabe resaltar lo siguiente:•

La conexión con la base de datos se hace por medio de un driver queconvierte de JDBC a ODBC. La carga de dicho driver JDBC-ODBC

tiene lugar durante la inicialización del servlet, al igual que laconexión con la base de datos. Basta pues con una única conexión ala base de datos para satisfacer todas las peticiones de los clientes (a priori, ya que puede ser necesario tener más conexiones abiertas si seespera un tráfico intenso). Además, se ha supuesto que el DSN delSistema de ODBC de 32 bits contenía la entrada opinion.

• A su vez, en el método destroy() se ha implementado la desconexión

de la base de datos, de forma que no quede recurso alguno ocupadouna vez que el servlet haya sido descargado.

•

En el método doPost() se ha comprobado que la adquisición de los parámetros del formulario era correcta, enviando un error al cliente encaso contrario. También podría haberse comprobado que ningúncampo estuviera vacío.

• El método actualizarBaseDeDatos() es el que se encarga de laintroducción de los valores en la base de datos, mientras que elmétodo devolverPaginaHTML() se encarga de la presentación en pantalla de los valores leídos. En la ejecución del query enactualizarBaseDeDatos() se tienen muy en cuenta posiblesexcepciones que pudieran surgir y se devuelve como valor de retornoun código de error distinto de cero para esos casos.

• Asimismo, mediante el bloque finally se consigue cerrar siempre el Statement tanto si se produce el error como si no, liberando recursosdel sistema de esa manera.

• Téngase especial cuidado con la sintaxis del quer y, y en especial conlas comillas simples en que debe ir envuelto cada String.

• Tras mostrar en pantalla los datos recogidos, se comprueba si se ha producido alguna actualización. Si este es el caso, se informa alcliente de esta circunstancia, mostrando un mensaje de error en casocontrario.

Código del Servlet ServletOpinion2. java

import java.io.*;import javax.servlet.*;import javax.servlet.http.*;import java.sql.*;

public class ServletOpinion2 extends HttpServlet {





// Declaración de variables miembroprivate String nombre = null;private String apellidos = null;private String opinion = null;private String comentarios = null;// Referencia a un objeto de la interface java.sql.Connection

Connection conn = null;// El siguiente método se ejecuta una única vez (al ser inicializado el servlet// por primera vez)// Se suelen inicializar variables y ejecutar operaciones costosas en tiempo// de ejecución (abrir ficheros, conectar con bases de datos, etc)public void init (ServletConfig config) throws ServletException {// Llamada al método init() de la superclase (GenericServlet)// Así se asegura una correcta inicialización del servletsuper.init(config);// dsn (Data Source Name) de la base de datosString dsn = new String("jdbc:odbc:opinion");// Carga del Driver del puente JDBC-ODBC

try {Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");}catch(ClassNotFoundException ex) {

System.out.println("Error al cargar el driver");System.out.println(ex.getMessage());

}// Establecimiento de la conexión con la base de datostry {

conn = DriverManager.getConnection(dsn, "", "");}catch (SQLException sqlEx) {

System.out.println("Se ha producido un error al" +" establecer la conexión con: " + dsn);System.out.println(sqlEx.getMessage());

}System.out.println("Iniciando ServletOpinion (version BD)...");} // fin del método init()// Este método es llamado por el servidor web al// "apagarse" (al hacer shut down).// Sirve para proporcionar una correcta desconexión de una base de datos,// cerrar ficheros abiertos, etc.public void destroy () {super.destroy();

System.out.println("Cerrando conexion...");try {conn.close();

}catch(SQLException ex){

System.out.println("No se pudo cerrar la conexion");System.out.println(ex.getMessage());

}} // fin del método destroy()





// Método de llamada mediante un HTTP POST

public void doPost (HttpServletRequest req, HttpServletResponse resp)throws ServletException, IOException {boolean hayError = false;// adquisición de los valores del formulario

if(req.getParameter("nombre")!=null)nombre = req.getParameter("nombre");

elsehayError=true;

if(req.getParameter("apellidos")!=null)apellidos = req.getParameter("apellidos");

elsehayError = true;

if(req.getParameter("opinion")!=null)opinion = req.getParameter("opinion");

elsehayError = true;

if(req.getParameter("comentarios")!=null)comentarios = req.getParameter("comentarios");else

hayError = true;// Mandar al usuario los valores adquiridos// (Si no se ha producido error)if(!hayError) {

if (actualizarBaseDeDatos() == 0)devolverPaginaHTML(resp);

elseresp.sendError(500, "Se ha producido un error"+" al actualizar la base de datos");

}elseresp.sendError(500, "Se ha producido un error"+" en la adquisición de parámetros");

} // fin doPost()

public int actualizarBaseDeDatos() {// crear un statement de SQLStatement stmt=null;int numeroFilasActualizadas=0;// Ejecución del query de actualización de la base de datostry {

stmt = conn.createStatement();numeroFilasActualizadas = stmt.executeUpdate("INSERT INTO"+" Opiniones_Recogidas VALUES"+"('"+nombre+"','"+apellidos+"','"+opinion+"','"+comentarios+"')");if(numeroFilasActualizadas!=1) return -1;}catch (SQLException sql) {System.out.println("Se produjo un error creando Statement");





System.out.println(sql.getMessage());return -2;

}// Se cierra el Statementif(stmt!=null) {try {

stmt.close();}catch(SQLException e){

System.out.println("Error cerrando Statement");System.out.println(e.getMessage());return -3;

}}return 0;} // fin finally} // fin método actualizarBaseDeDatos()

public void devolverPaginaHTML(HttpServletResponse resp) {// Se obtiene un PrintWriter donde escribir (sólo para mandar texto)PrintWriter out=null;try {

out=resp.getWriter();}catch (IOException io) {

System.out.println("Se ha producido una excepcion");}// Se establece el tipo de contenido MIME de la respuestaresp.setContentType("text/html");// Se mandan los valores

out.println("<html>");out.println("<head>");out.println("<title>Valores recogidos en el formulario</title>");out.println("</head>");out.println("<body>");out.println("<b><font size=+2>Valores recogidos del");out.println("formulario: </font></b>");out.println("<p><font size=+1><b>Nombre: </b>"+nombre+"</font>");out.println("<br><fontsize=+1><b>Apellido : </b>"+apellidos+"</font><b><font size=+1></font></b>");out.println("<p><font size=+1><b>Opinión: "+"</b><i>"+opinion+"</i></font>");

out.println("<br><font size=+1><b>Comentarios: </b>"+comentarios+"</font>");out.println("<P><HR><CENTER><H2>Valores actualizados "+"con éxito</CENTER>");out.println("</body>");out.println("</html>");// Se fuerza la descarga del buffer y se cierra el PrintWriter out.flush();out.close();


} // fin de devolverPaginaHTML()

// Función que permite al servidor web obtener una// pequeña descripción del servlet, qué// cometido tiene, nombre del autor, comentarios adicionales, etc.

public String getServletInfo() {return "Este servlet lee los datos de un formulario "+"y los introduce en una base da datos";

} // fin de getServletInfo()} // fin de la clase servletOpinion2

Pagina Web

<HTML><HEAD><TITLE>Envíe su opinión</TITLE></HEAD><BODY><H2>Por favor, envíenos su opinión acerca de este sitio web</H2>

<FORM ACTION="http://localhost:8080/servlet/ServletOpinion2"METHOD="POST"> Nombre: <INPUT TYPE="TEXT" NAME="nombre" SIZE=15><BR>Apellidos: <INPUT TYPE="TEXT" NAME="apellidos" SIZE=30><P>Opinión que le ha merecido este sitio web<BR><INPUT TYPE="RADIO" CHECKED NAME="opinion"VALUE="Buena">Buena<BR><INPUT TYPE="RADIO" NAME="opinion" VALUE="Regular">Regular<BR><INPUT TYPE="RADIO" NAME="opinion" VALUE="Mala">Mala<P>Comentarios <BR><TEXTAREA NAME="comentarios" ROWS=6 COLS=40></TEXTAREA><P>

<INPUT TYPE="SUBMIT" NAME="botonEnviar" VALUE="Enviar"><INPUT TYPE="RESET" NAME="botonLimpiar" VALUE="Limpiar"></FORM></BODY></HTML>

Practicas

Tomando las mismas bases del código del Servlet. Ccodifique 3 servletsmas que realicen las operaciones de consulta, actualización yeliminación de registros a la misma base de datos que se ha empleando.La metodología al realizar esas operaciones a la base de datos se dejarana su criterio.

Diseñar e implementar un sistema de base de datos de un control escolar a través del web. Que manejará las siguientes tablas:




- Alumnos (id_alum, nombre, apellido, direccion)- Profesor (id_prof, nombre, apellido, grado, fecha_ingreso,

domicilio)- Materias (id_mat, nombre, creditos)- Kardex(id_alum, id_prof, id_mat, calificacion)

Realizar los Servlets necesarios para realizar las operaciones básicas ala base de datos.





Autor:

Ing. Joel González EstradaMaestría en Tecnologías de la Información

manual java servlets

Documents