2006
Introducción .............................................................................................................................3
CAPITULO 1: INTRODUCCION ..............................................................................................4
Introducción...........................................................................................................................5
Aspectos Históricos ...............................................................................................................6
¿Qué es Java?.........................................................................................................................8
Evolución de las Versiones de Java .......................................................................................9
CAPITULO 2: PROGRAMACION ORIENTADA A OBJETOS...............................................10
Principios de la Orientación a Objetos ................................................................................11
CAPITULO 3: ELEMENTOS DEL LENGUAJE JAVA .............................................................13
Errores de Programación .....................................................................................................14
Edición, Compilación y Ejecución de Programas ...............................................................16
Elementos Básicos ...............................................................................................................21
Control de Flujo ...................................................................................................................28
Control de Excepciones .......................................................................................................29
Try – Throw – Throws - Catch - Finally ............................................................................32
CAPITULO 4: PROGRAMACION ORIENTADA A OBJETOS CON JAVA............................34
Abstracción (Aplicado)........................................................................................................35
Encapsulamiento (Aplicado) ...............................................................................................36
Herencia (Aplicado).............................................................................................................37
Polimorfismo (Aplicado) .....................................................................................................40
CAPITULO 5: INTRODUCCIÓN A UML ...............................................................................43
CAPITULO 6: PAQUETES DE JAVA......................................................................................44
Introducción.........................................................................................................................45
Paquetes y Directorios .........................................................................................................46
CAPITULO 7: MANEJO DE ARCHIVO EN JAVA..................................................................53
Introducción.........................................................................................................................54
Flujos ...................................................................................................................................55
Jerarquía de Clases ..............................................................................................................56
FileInputStream y FileOutputStream...................................................................................57
Ejemplo Introductorio FileInputStream...............................................................................58
Ejemplo Introductorio FileOutputStream............................................................................60
Ejemplo Introductorio FileReader .......................................................................................61
Ejemplo Introductorio FileWriter ........................................................................................62
CAPITULO 8: APPLETS.........................................................................................................64
Introducción a los Applets de Java ......................................................................................65
Applets .................................................................................................................................66
CAPITULO 9: INTERFASES GRÁFICAS DE USUARIO EN JAVA.......................................74
Eventos ..............................................................................................................................110
La Clase Event ...................................................................................................................111
2
Introducción
3
MANUAL DE JAVA
CAPITULO 1: INTRODUCCION
4
Introducción
5
Aspectos Históricos
Hace ya muchos años, por allá por fines de los 60, Martin Richards desarrollo
un lenguaje de programación denominado “BCPL”, el cual estaba orientado
principalmente para la programación de Sistemas Operativos y compiladores. En
1970, Kem Thomson presentaba su lenguaje, denominado “B”, en el cual se
escribieron las primeras líneas del sistema operativo UNIX, este lenguaje fue
desarrollado en los laboratorios AT&T DELL Laboratorios en un computador DEC
PDP-7.
Para 1978, la editora Prentice Hall, publica el libro “The C Programming Languaje”,
libro que ha sido el más vendido en la historia de los libros informáticos, con ésta
fama, C se convierte en el lenguaje preferido para desarrollar aplicaciones y
diferentes tipos de sistemas y programas, el problema surge porque C es de “open
source”, por lo tanto existieron tantas versiones como aplicaciones, que
prontamente se hicieron incompatibles entre ellas, es por esto que en 1983, se
realiza una congregación, denominada la X3J11, bajo la supervisión de la ANSI, en
donde se comienzan a desarrollar las referencias del lenguaje, para que los
desarrolladores tengan a que atenerse para no perder el estándar. Es así como para
el año 1989 es aprobado el estándar de C, bajo el nombre de ANSI/ISO 9899:1990.
6
James Goblin y su equipo, desarrollaron un lenguaje de programación que
denominaron “OAK” que significa Roble en Inglés, pues se cuenta que desde su
ventana en las oficinas de Sun Microsystem, él puede ver un roble que esta en el
patio.
El problema surge por que ya existía una empresa con un lenguaje denominado
“OAK”, con lo cual el equipo de James Goblin debió cambiar el nombre de su
lenguaje de programación. La historia cuenta que le denominaron JAVA por el café
que tomaban a la hora de descanso durante el desarrollo del lenguaje, otra teoría
cuenta que es por el café que le servían a Goblin y su equipo en una cafetería
cercana a las oficinas de Sun Microsystem.
Pero Goblin no se vería disminuido por lo sucedido, así que, con astucia, volcaron
JAVA al desarrollo de aplicaciones Web, debido a que a comienzos de los 90, la
WWW alcanzó niveles de desarrollo insospechados, es así como en 1995, Sun
Microsystem, presenta al mundo su primera versión de JAVA, la versión 1.0,
maravillando al mundo con el dinamismo que le otorgaba a las estáticas páginas
Web predominantes en esos años.
Nace así, una de las tecnologías más admiradas y venerada de los últimos años,
además que la explosión de los dispositivos electrónicos llegó con el tiempo, JAVA
ha comenzado a ocupar espacios que ningún otro lenguaje lo había logrado.
Permaneciendo así en Celulares, Pocket PC, Palms, Robots, Servidores Web, etc.
7
¿Qué es Java?
Para el mundo Web, Java es una tecnología facilitadota que permite crear paginas
Web que se entregaran de manera consistente a todos los usuarios con un
navegador habilitado para java y con independencia de a plataforma hardware que
se este utilizando. Toda esta maravilla la permite la JVM y se explica en este gráfico
a continuación.
Sistema Operativo
Navegador Java
Código
Fuente
Máquina Virtual Java Código Nativo Java
Actualmente, para cada Sistema Operativo, existe una Maquina Virtual para
descargar, además que Java es un Kit de Desarrollo gratis, el cual se puede
descargar desde la página de sus creadores y dueños, www.sun.com/java/.
8
Evolución de las Versiones de Java
J2EE
Está orientada a al desarrollo de aplicaciones de propósito empresarial o para
servidores y son numerosos los grandes fabricantes (IBM, Nokia, Motorola, Hewtlett-
Packard…) que lo soportan con especificaciones comunes.
Actualmente J2EE se ha convertido en un autentico estándar, reconocido por la
industria.
J2ME
Es un nuevo estándar para dispositivos inalámbricos (móviles, de bolsillo o de mano
(handhelds)) que requieren una integración en dispositivos con poco espacio físico y
memoria de trabajo.
Versiones
9
MANUAL DE JAVA
10
Principios de la Orientación a Objetos
Abstracción:
• Es un elemento fundamental de la POO
• Las personas gestionamos la complejidad a través de la abstracción.
o Por ejemplo, las personas andamos en un auto sin importar como este
trabaja internamente, sabemos conducirlo, pero muchas veces no nos
importa como funciona su motor, el aire acondicionado, los freso, la
caja de cambio etc., solo nos importa el auto como un todo.
• La abstracción es el proceso de capturar los detalles fundamentales
de un objeto mientras se suprimen o ignoran los detalles.
o Por ejemplo, si tenemos que ir de un sitio A a un sitio B en el vehículo
del ejemplo anterior, no nos vamos a concentrar en como funciona el
motor o las partes tecnológicas del auto, solo nos vamos a concentrar
en acelerar, virar a la derecha o izquierda por el camino, nada más.
• La noción de abstracción entraña la descomposición de un sistema complejo
o complicado en sus partes más fundamentales y describir estas partes en un
lenguaje sencillo y preciso.
• La abstracción se puede presentar como un Tipo Abstracto de Dato (TAD), lo
que quiere decir que es un modelo matemático de una estructura de dato
que especifica el tipo de dato almacenado, las operaciones soportadas pro
ellos y tipos de los parámetros de las operaciones.
• Un TAD especifica qué hace cada operación, pero no cómo lo hace.
• En Java, un TAD se puede expresar como una interfaz que normalmente es
una lista de declaraciones de métodos.
11
Encapsulamiento
• Es sinónimo de ocultación de información.
• Es el proceso de ocultar todos los detalles de un objeto que no contribuyen a
sus características esenciales.
• El usuario de un objeto nunca necesitará conocer el interior de una clase.
• Como ventaja, el encapsulamiento proporciona al programador libertad en la
implementación de los detalles de un sistema. La única restricción que tendrá
el programador es mantener la interfaz abstracta que ven los usuarios
externos.
• Encapsulamiento, desde un punto de vista más técnico, es el mecanismo que
enlaza juntos código y los datos que los manipulan y los mantienen seguros
de interfaces externas y mal uso.
• Se puede pensar en encapsulamiento, como el envoltorio que encierra al
código y a los datos.
• En Java, los fundamentos de la encapsulación están en la clase. Una clase
define la estructura y el comportamiento (datos y código) que se compartirá
por un conjunto de objetos.
• Cuando se crea una clase, se especifica el código y los datos que constituyen
esa clase, a estos elementos se les llama miembros de la clase. Estos
miembros pueden ser públicos o privados dentro de la misma clase. Así que
comúnmente se utilizan métodos públicos para manipular los datos de la
clase que son privados.
Herencia
• Herencia es el proceso mediante el cual un objeto adquiere las propiedades
de otro objeto. Por ejemplo, un pastor alemán es parte de la clase perro, y a
su vez es parte de la clase mamífero, que a su vez es de la clase animal.
• Sin el uso de la herencia, el objeto necesitaría definir todas las características
nuevamente. Sin embargo, usando herencia, un objeto solo necesita definir
aquellas cualidades que lo hace único dentro de la clase.
• Las nuevas clases pueden heredar atributos generales de su clase padre o
clase base, también denominada superclase.
Animal
Mamífero
Perro
12
• La herencia es un concepto poderos de Java. De hecho cada clase que se
define en Java se hereda de una clase existente, bien explicita o
implícitamente.
Polimorfismo
• Proviene del griego polymorphos, que significa “muchas formas”
• En la práctica, es la propiedad que permite enviar el mismo mensaje a
objetos de diferentes clases (totalmente diferentes). Del mismo modo cada
objeto responde a ese mensaje de manera distinta, dependiendo de su
implementación.
• El polimorfismo como sobrecarga (en Java) ocurre cuando una clase X tiene
múltiples métodos con el mismo nombre, cada uno de ellos con una signatura
distinta, por ejemplo.
o public double getDistancia()
o public double getDistancia(double x, double y)
En este caso, tenemos dos métodos con el mismo nombre, pero con
argumentos distintos.
• La signatura de un método es una combinación de nombre y tipo de
argumentos de un método.
• El polimorfismo se aplica sólo a métodos que tienen la misma signatura pero
están definidos en clases diferentes.
• Herencia, polimorfismo y sobrecarga de métodos soportan el desarrollo de
software reutilizable.
MANUAL DE JAVA
13
Errores de Programación
Editar y crear un
nuevo archivo .java
No existen errores
Los mensajes de error que produce el compilador no siempre ayudan a encontrar los
errores. Una mezcla de las advertencias del compilador, manual de instrucciones y
sobre todo la experiencia del programador, serán quienes proporcionen el
conocimiento suficiente para llegar a depurar programas con éxito. Existen tres tipos
de errores: errores de compilación (sintaxis), errores de ejecución y errores lógicos.
Errores de Compilación
• Este tipo de errores ocurren cuando el código viola un o más reglas
gramaticales de Java.
• Estos errores los detecta el compilador.
• Ejemplo: utilizar una variable que no se ha definido previamente.
Errores de Ejecución
14
• Este tipo de errores aparecen cuando el sistema termina de forma anormal y
que se detectan y visualizan durante la ejecución del programa.
• Un error de ejecución se produce cuando el usuario instruye a la
computadora para que ejecute una operación no válida.
• Ejemplo: realizar una división por cero.
• Un error de entrada ocurre cuando el usuario introduce un valor de entrada
imprevisto que el programa no puede manejar.
• Ejemplo: si el programa espera un número y el usuario ingresa una cadena
de caracteres.
Errores Lógicos
• Los errores lógicos ocurren cuando un programa realiza un algoritmo
incorrecto y no ejecuta la operación que estaba prevista.
• Son complicados de detectar, pues no se avisan como los errores de
compilación, además pueden no producir un término anormal del programa.
• Generalmente se detectan cuando se observan los valores de salida del
programa.
15
Edición, Compilación y Ejecución de Programas
Los programas escritos en java, pueden ser editados desde cualquier editor de
texto, y ejecutados desde una línea de comandos cualquiera, a continuación
presentaré un ejemplo sencillo de nuestro primer programa en Java.
class Holamundo{
static public void main(String [] args){
System.out.println("Hola mundo, este es el primer ejemplo en java");
}
}
NOTA: al utilizar algún editor, sea este Netbeans, JCreator, Eclipse, Visual age, etc,
no es necesario realizar el paso que explicaré a continuación debido a que los
editores por lo general encuentran la ruta al JDK de manera automática, por ende,
nos permiten a través de botones, realizar la compilación y ejecución de nuestros
programas.
16
Chiqueamos en la pestaña de “Opciones avanzadas” y presionamos en el botón de
“Variables de Entorno”
17
Esta ventana nos permite editar las variables que permanecerán en el entorno de
Windows, permitiéndonos así utilizarlas desde cualquier directorio en nuestro
computador.
18
La ventana nos quedaría de la siguiente forma, posteriormente aceptamos
19
Si volvemos a revisar nuestro directorio, observaremos que el compilador de java
genera un archivo en bytecode, este archivo se crea como Holamundo.class.
Javac Holamundo.java
20
Elementos Básicos
Comentarios
Los comentarios en Java se pueden anotar de dos maneras:
/*
Comentario de un bloque
*/
Palabras Reservadas
Las palabras reservadas son palabras que tiene un determinado significado para el
compilador y no pueden ser utilizadas para otros fines. Por ejemplo la palabra
“import” le indica al compilador que se necesita realizar una importación.
Modificadores
Existen palabras reservadas que Java denomina “Modificadores”, las cuales
especifican las propiedades de los datos, métodos y clases. Por ejemplo:
Public: Modificador que permite visualizar las variables y métodos desde cualquier
otro paquete de clases o clase.
Private: Modificador que impide visualizar las variables o métodos desde otras
clases y paquetes, solo se pueden manipular las variables o métodos con este
modificador dentro de la misma clase.
21
Abstract: Modificador que declara clases y métodos que se declaran de manera
abstracta.
Sentencias
Una sentencia representa una acción o una secuencia de acciones, cada sentencia
termina con un punto y coma (“;”), ejemplos de sentencias:
int c=0;
System.out.println (“Hola mundo”);
Bloques
Un bloque es una estructura de programa que agrupa sentencias. Los bloques
comienzan con una llave de apertura ({) y cierran con una llave de cierre (}), por
ejemplo:
if (a<34){
System.out.println(“menor que 34”);
}
22
Control de Flujo
Los controles de flujo cuentan de dos partes, bifurcaciones y bucles, todo lenguaje
de programación debe contenerlos, debido a que son claves al momento de
administrar la ejecución de un programa. A continuación veremos como se definen
ambos en Java.
• Bifurcaciones
o if – else if – else
Esta bifurcación permite realizar las preguntas de SI esta
condición ocurre, O SI esta otra condición ocurre, ENTONCES haga lo
siguiente. Un ejemplo de su utilización lo demuestro a continuación:
23
o switch - case
Esta bifurcación permite hacer selecciones de casos para hacer
más rápido la bifurcación, a continuación presentaré un ejemplo de este
comando.
24
• Bucles
o while
El while tiene como traducción “mientras”, y funciona de la
siguiente manera, mientras la condición se cumpla, el bloque se ejecuta.
Para entender de mejor manera el funcionamiento del bucle while,
veamos este ejemplo a continuación.
o for
El ciclo for, no permite realizar un ciclo gracias a que existe un
condición que debe cumplirse, esta condición va de la mano de un
número entero que se debe declarar dentro del for, y que puede ir
creciendo o disminuyendo. La estructura del for es la siguiente
25
A continuación veremos un ejemplo aclarador del uso del for.
26
Clases
La clase es la construcción fundamental de Java, la cual constituye una plantilla o
modelo para fabricar objetos. Un programa consta de una o más clases y cada una
de ellas puede contener declaraciones de datos y métodos. Cada archivo de clase se
compila en un archivo de Bytecode con la extensión .class.
Métodos
Un método es una colección de sentencias que realizan una serie de operaciones
determinadas. Por ejemplo:
System.out.println(“Bienvenido a mi Ejemplo”);
El método “main”:
Cada aplicación de Java debe tener un método main declarado por el programador
que defina don de comienza el flujo del programa. El método main tendrá siempre
una sintaxis similar a esta:
Los tipos primitivos de datos o variables de Java con aquellas variables sencillas que
contienen los tipos de información más habituales, valores boléanos, caracteres y
valores numéricos o de punto flotante.
27
Control de Flujo
Para crear programas en Java hay que tener en cuenta que toda implementación
que se realice se efectuará encapsulada en una clase. Un programa aplicación
fuente en Java se podría considerar formado por las siguientes partes:
Dado que una clase es un modelo y las instancias son los objetos de esa clase, a las
variables de instancia se les denomina así porque cada objeto contendrá una copia
de dichas variables, de forma que los datos de una objeto se encontrarán separados
de los de otro objeto, utilizándose los métodos para la modificación de los valores de
las variables de instancia.
28
Control de Excepciones
Según se van complicando los programas, cada vez es más difícil construirlos con
robustez.
Modelo Básico
Java sigue la sintaxis que usan los controladores de excepciones en C++. En primer
lugar, intentaremos ejecutar un bloque de declaraciones. Si aparece una condición
anormal, algo lanzará una excepción que podremos capturar con el controlador
adecuado. Además, puede haber un bloque de declaraciones que queremos ejecutar
(independientemente de que se den o no excepciones).
Siempre será mejor lanzar una excepción que cerrar el programa abruptamente, por
lo menos esta comprobado que el impacto que produce el cierre anormal del
programa en un usuario, a ver un mensaje de error, es mucho más fuerte.
Dentro de los programas básicos que hemos desarrollado esta el típico programa
que recibe datos desde el teclado, a continuación utilizaremos el mismo programa
para demostrar cuando se lanza una excepción al convertir una cadena a un int.
29
import java.io.*;
class Error{
static public void main(String [] args){
InputStreamReader isr= new InputStreamReader(System.in);
BufferedReader in= new BufferedReader(isr);
System.out.print("Ingrese un numero: ");
String cadena= in.readLine();
int numero= Integer.parseInt(cadena); //producirá un error si no
System.out.println("Fin del Programa"); // ingresamos un numero
}
}
import java.io.*;
class Error{
static public void main(String [] args)throws IOException{
InputStreamReader isr= new InputStreamReader(System.in);
BufferedReader in= new BufferedReader(isr);
System.out.print("Ingrese un numero: ");
String cadena= in.readLine();
int numero= Integer.parseInt(cadena); //producirá un error si no
System.out.println("Fin del Programa");// ingresamos un numero
}
}
30
Procedemos a compilar y a ejecutar
31
Try – Throw – Throws - Catch - Finally
Archivo Error2.java
import java.io.*;
class Error2{
static public void main (String [] args){
try{
lanzar_excepcion();
}catch(IOException provocado){
System.out.println("Excepcion capturada");
}catch (Exception e){
//hacemos algo si viene otro tipo de excepción
}finally{
System.out.println("Ejecución de bloque finally");
}
}
Explicaré a continuación cada una de las líneas del código para que se entienda que
hacen las palabras reservadas que están involucradas en el control de excepciones.
32
• Se importa import java.io.*; para poder utilizar el error de entrada y salida.
• Se crea un bloque try el cual puede capturar excepciones de cualquier tipo
dentro de su bloque de declaración.
• Se emplea la palabra catch, la cual permite capturar las excepciones que se
produzcan en el bloque try. Inicialmente programamos que se capturara una
excepción de tipo IOException (excepción de entrada y salida).
Posteriormente utilizamos otro catch para posibles excepciones de otro tipo
que no tuviéramos previstas, esto lo hice más que nada para demostrar que
uno puede utilizar cuantos bloques catch desee, según la cantidad de
excepciones que uno espere obtener de un bloque.
• Se utiliza la cláusula finally para demostrar su uso, esta cláusula puede ser
utilizada para volver a levantar o estabilizar el sistema después de una
excepción. Como podemos apreciar, en el interprete de comandos, primero
se capturo el excepción y luego se ejecutó el bloque finally.
• Por último escribimos un método lanzar_excepcion(), el cual levanta un
nuevo error de tipo IOException.
33
MANUAL DE JAVA
34
Abstracción (Aplicado)
(x,y)
v (x2+y2)
(0,0) X
35
Encapsulamiento (Aplicado)
Archivo Punto2d.java
class Punto2d{
//atributos
private double x;
private double y;
//Constructor
//metodo
public double getDistancia(){
return Math.sqrt((x*x)+(y*y));
}
public double getX(){
return x;
}
public double getY(){
return y;
}
}
Como podemos observar, los atributos de la clase, son declarados como privados,
por lo tanto no se puede acceder a ellos desde otra clase, al menos que se
consulten los métodos “get”, getX() y getY(), a esto se le denomina en parte
encapsulamiento, porque el termino encapsulamiento en sí, se explica en la
capacidad de generar una estructura o un molde con características similares para
las instancias que se generen en esta. A modo de ejemplo, todos las instancias de la
clase Punto2d que se generen, tendrán, gracias a la encapsulación, dos atributos,
que son x e y, y los tres métodos, getDistancia(), getX() y getY().
36
Herencia (Aplicado)
Un punto puede ser definido en un plano de tres dimensiones, para ello, el punto va
a tener una coordenada x, una y y una z, además la distancia de un punto de tres
dimensiones se calcula de la siguiente forma v (x2+y2+z2). Por lo tanto, también
podemos escribir los métodos, getDistancia(), getX(), getY() y crearemos el getZ().
En donde la flecha que une las dos clases representa que la clase Punto3d es
subclase de la clase Punto2d, es decir hereda las características de la clase Punto2d.
37
Como se ve esto en código, de la siguiente manera.
Archivo Punto3d.java
//constructor
public Punto3d(double x, double y, double z){
super(x,y);
this.z= z;
}
//metodos
public double getDistancia(){
double x2= Math.pow(super.getX(),2);
double y2= Math.pow(super.getY(),2);
double z2= z*z;
return Math.sqrt(x2+y2+z2);
}
public double getX(){
return super.getX();
}
La palabra clase super, es la que nos permite acceder a las variables y métodos de
la superclase, en este caso a Punto2d. Como sabemos que no podemos acceder a la
variable x directamente, es decir utilizando el siguiente código:
38
Éste código nos marcará una excepción, la cual nos indicará que estamos haciendo
referencia a una variable de tipo privada, por eso se crea el método publico getX(),
el cual tiene como función, retornar el valor de la variable x.
Pero, falta apreciar como podemos ejecutar todo esto, es decir, nos falta una clase
main para poder jugar con las clases que acabamos de crear.
39
Polimorfismo (Aplicado)
Archivo PruebaPuntos.java
class PruebaPuntos{
static public void main(String [] args){
Punto2d punto= new Punto2d(3.4, 5);
System.out.println("La distancia del Pundo2d es: "+
punto.getDistancia());
Punto3d otropunto = new Punto3d(3,5,7);
System.out.println();
System.out.println("La distancia del Pundo3d es: " +
otropunto.getDistancia());
}
}
La idea es que los tres archivos los guardemos en el mismo directorio, para nuestro
manual, estos tres archivos se encuentran en c:\manual\
Procederemos a compilarlos.
40
Ahora procedemos a ejecutar nuestro archivo main, es decir PruebaPuntos.java
Como podemos apreciar, la salida de nuestro archivo principal es súper simple, pero
¿se logra entender lo interesante de la codificación?, para aclarar un poco más todo
lo que hemos realizado, lo voy a explicar paso a paso.
Math.pow(super.getX(),2);
41
En el archivo PruebaPunto.java tenemos:
• Creamos una instancia de la clase Punto2d, que se llama punto.
o Éste objeto tiene dos atributos, un valor x y un valor y, además tiene
tres métodos, el getDistancia y los getX() y getY().
• Presentamos en pantalla el resultado de la función getDistancia(), aplicado al
objeto punto de la clase Punto2d.
• Creamos una instancia de la clase Punto3d, que se llamo otropunto.
o Éste objeto tiene 2 atributos heredados y uno propio, además
sobrecargamos el método getDistancia(), getX() y getY(), además
creamos un método propio denominado getZ().
• Presentamos en pantalla el resultado de la función getDistancia(), aplicado al
objeto otropunto de la clase Punto3d, que es heredera de la clase Punto2d.
42
MANUAL DE JAVA
43
MANUAL DE JAVA
44
Introducción
En éste capítulo aprenderemos las capacidades de los paquetes estándar que trae
Java, además aprenderemos a crear nuevos paquetes, a sacar partido a los
paquetes definidos dentro del JDK, ya que ellos prestan a menudo una ayuda muy
importante.
45
Paquetes y Directorios
Declaración de Paquetes
package nombre;
package miPaquete;
package java.awt.*;
Importación de Paquetes
import packageName.ClassName;
import packageName.*;
46
Paquetes Estándar de Java
Los paquetes representan una forma de controlar la jerarquía de las clases, pero no
nos ayudarán a exportarla. La versión 2 de Java tiene cerca de setenta paquetes
java.*. Ahora comenzaremos a estudiar los más utilizados.
Java.lang
Contiene las clases con las que puede trabajar el lenguaje principal. Trabaja con
envolturas de objetos, cadenas, multitarea y las correspondientes áreas
relacionadas.
java.util
Contiene las clases que se pueden utilizar desde un punto de vista más natural.
Entre estos nos encontramos con las clases especializadas en los calendarios y en
las colecciones, así como también otros diseños abstractos que codifican las
interfaces Comparator, Iterator y Observer.
java.io
java.awt
com.sun.java.swing
Ofrece un grupo de clases para componentes, controles de alto nivel y aquellas que
mejoran el aspecto.
java.net
Combina las clases que pueden trabajar con los programas de bajo nivel de
Internet, WWW y dispone de soporte HTML.
java.applet
Sólo contiene una clase que puede trabajar con el lenguaje HTML que se incluye en
los applet.
47
java.lang
La mayoría de las clases de java.lang son una aplicación de la clase Object, que es
la raíz de toda la jerarquía de la clase de Java.
import java.lang.*;
El asterisco indica que se importarán todas las clases del paquete. Sin embargo, no
se importarán las clases de los subpaquetes.
• Clases envolventes
• Clases que admiten cadenas
• Clases de bibliotecas matemáticas
• Clases que pueden trabajar multitarea
• Clases que permiten acceso de bajo nivel al sistema
• Clases de excepciones y errores.
Las clases envolventes son clases que permiten agregar metodos de trabajo a los
tipos primitivos de datos en Java.
48
java.util
Contiene más clases para datos abstractos (ADT) y trece interfaces. Aprovecha las
herencias más que el paquete java.lang, por ejemplo, la clase Propierties es una
extensión (subclase) de la clase Hashtable, que es (a su vez) una extensión de
Dictionary.
java.io
Los lectores y escritores se parecen a las corrientes de entrada y salida, con una
excepción, su unidad es un dato unicote.
Las clases de la corriente, del lector y del escritor que se encuentran dentro del
java.io se pueden agrupar en dos:
49
java.awt
50
com.sun.java.swing
• Widget de Jcomponent
• Clases para la gestión del diseño
o BoxLayout
o OverlayLayout
o ScrollPaneLayout
o ViewportLayout
o SizeRequirements
• Clases e interfaces de Model
• Clases Manager
o DesktopManager y DefaultDesktopManager
o FocusManager y DefaultFocusManager
o MenuSelectionManager
o RepaintManager
o ToolTipManager
o UIManager
• Clases de AbstractAction y KeyStroke y la interfaz Action
• Otras clases
o BorderFactory
o ImageIcon y la interfaz Icon
o LookAndFeel
o ProgressMonitor y ProgressMonitorInputStream
o SwingUtilities
o GrayFilter
o Timer
Además del paquete que hemos visto anteriormente, se puede trabajar también con
los siguientes:
51
java.net
El paquete java.net es uno del más importante de Java. Proporciona una serie de
interfaces de alto nivel y protocolo (menos sofisticados) especializados en la
comunicación, llamados TCP/IP y UDP/IP. java.net ahorra al programador gran parte
de las vicisitudes de la programación a nivel de Internet. Sus clases se pueden
agrupar con los siguientes puntos:
java.applet
Una de las principales razones por las que es un lenguaje muy fácil de aprender y de
una gran eficacia a la hora de distribuir componentes de software. Los applet en
Java, más o menos, son componentes distribuidos de software. La clase estándar
apenas contiene algo más que lo necesario para trabajar con estos applet.
El paquete java.applet, cuando se compara con otros paquetes, parece bastante
escaso. Solamente contiene una clase y tres interfaces. La clase java.applet.Applet
representa el depósito principal don de se encuentran los métodos que se encargan
de trabajar con los applet. Los métodos se pueden agrupar por categorías:
52
MANUAL DE JAVA
53
Introducción
Los archivos tienen como finalidad guardar datos de forma permanente. Una vez
que acaba la aplicación, los datos almacenados están disponibles para que otra
aplicación los utilice. Los archivos son dispositivos externos, en contraposición de
los datos que se guardan en arreglos (arrays), listas, árboles, etc. Que están en
memoria interna y por lo tanto desaparecen al acabar la ejecución del programa.
54
Flujos
Un flujo o Stream es una abstracción que se refiere a una corriente de datos que
fluyen entre un origen o fuente (productor) y un destino (consumidor). Entre el
origen y el destino debe existir una conexión o canal, también conocida como pipe
por la que circulan los datos.
Al iniciar un programa en java, tenemos tres flujos que quedan abiertos de manera
automática, estos son:
Estos tres objetos se crean al inicio del programa y sirven para admitir secuencias
de caracteres en modo texto. Así cuando se ejecuta.
55
Jerarquía de Clases
En el paquete java.io se encuentran todas las clases Stream necesarias para dar
entrada/salida a nuestros programas.
InputStream OutputStream
FileInputStream FileOutputStream
ByteArrayInputStream ByteArrayOutputStream
PipeInputStream PipeOutputStream
SequenceInputStream
StringBuffereInputStream
FilterInputStream FilterOutputStream
56
FileInputStream y FileOutputStream
57
Ejemplo Introductorio FileInputStream
Leer un archivo:
58
59
Ejemplo Introductorio FileOutputStream
60
Ejemplo Introductorio FileReader
61
Ejemplo Introductorio FileWriter
62
63
MANUAL DE JAVA
CAPITULO 8: APPLETS
64
Introducción a los Applets de Java
65
Applets
Arquitectura de lo Applets
Los applets tienen una arquitectura bien definida, la cual permite reconocer los
pasos de su inicialización de una manera simple:
Cuando un applet se carga, comienza su ciclo de vida, que pasaría por las siguientes
fases:
Jerarquía de un applet
Las características de las applets se pueden considerar desde el punto de vista del
programador y desde el del usuario. En este manual lo más importante es el punto
de vista del programador:
66
redefinir ciertos métodos heredados de Applet que controlan su ejecución: init(),
start(), stop(), destroy().
Se heredan otros muchos métodos de las super-clases de Applet que tienen que
ver con la generación de interfaces gráficas de usuario (AWT). Así, los métodos
gráficos se
heredan de Component, mientras que la capacidad de añadir componentes de
interfase de usuario se hereda de Container y de Panel.
Las applets también suelen redefinir ciertos métodos gráficos: los más importantes
son paint() y update(), heredados de Component y de Container; y repaint()
Heredado de Component.
Métodos de un Applet
init()
El método init() se llama cada vez que el applet carga por primera vez. Si el applet
llamado no lo sobrecarga, init() no hace nada. Fundamentalmente en este método
se debe fijar el tamaño del applet, aunque en el caso de Netscape el tamaño que
vale es el que se indique en la línea del fichero HTML que cargue el applet. También
se deben realizar en este método las cargas de imágenes y sonidos necesarios para
la ejecución del applet. Y, por supuesto, la asignación de valores a las variables
globales a la clase que se utilicen. En el caso de los applet, este método únicamente
es llamado por el sistema al cargar el applet.
start()
start() es la llamada para arrancar el applet cada vez que es visitado. La clase
Applet no hace nada en este método. Las clases derivadas deben sobrecargarlo
para comenzar la animación, el sonido, etc. Esta función es llamada
automáticamente cada vez que la zona de visualización en que está ubicado el
applet se expone a la visión, a fin de optimizar en uso de los recursos del sistema y
no ejecutar algo que no puede ser apreciado (aunque el programador puede variar
este comportamiento y hacer que un applet siga activo aun cuando esté fuera del
67
área de visión). Esto es, imaginemos que cargamos un applet en un navegador
minimizado; el sistema llamará al método init(), pero no a start(), que sí será
llamado cuando restauremos el navegador a un tamaño que permita ver el applet.
Naturalmente, start() se puede ejecutar varias veces: la primera tras init() y las
siguientes (porque init() se ejecuta solamente una vez) tras haber aplicado el
método stop().
stop()
stop() es la llamada para detener la ejecución del applet. Se llama cuando el applet
desaparece de la pantalla. La clase Applet tampoco hace nada en este método, que
debería ser sobrecargado por las clases derivadas para detener la animación, el
sonido, etc. Esta función es llamada cuando el navegador no incluye en su campo de
visión al applet; por ejemplo, cuando abandona la página en que está insertado, de
forma que el programador puede paralizar los threads que no resulten necesarios
respecto de un applet no visible, y luego recuperar su actividad mediante el método
start().
destroy()
paint( Graphics g )
Es la función llamada cada vez que el área de dibujo del applet necesita ser
refrescada. La clase Applet simplemente dibuja un rectángulo gris en el área, es la
clase derivada, obviamente, la que debería sobrecargar este método para
representar algo inteligente en la pantalla. Cada vez que la zona del applet es
cubierta por otra ventana, se desplaza el applet fuera de la visión o el applet cambia
de posición debido a un redimensionamiento del navegador, el sistema llama
automáticamente a este método, pasando como argumento un objeto de tipo
Graphics que delimita la zona a ser pintada; en realidad se pasa una referencia al
contexto gráfico en uso, y que representa la ventana del applet en la página Web.
update( Graphics g )
68
Component es llamar al método paint(), tras haber rellenado la zona del applet
con su color de fondo por defecto. Pudiera parecer así que se trata de un método de
efecto neutro, pero si la función paint() cambiara el color del fondo, podríamos
percibir un flick de cambio de colores nada agradable. Por tanto, habrá que cuidarse
por lo común, de eliminar este efecto de limpia primero, sobrecargando el método
update(), para que llame únicamente a paint(). Otra solución sería insertar el código
de pintado en una sobrecarga del método update() y escribir un método paint() que
sólo llame a update(). La última solución pasaría por usar el mismo método
setBackground( Color ), en el método init() para así evitar el efecto visual sin tener
que sobrecargar el método update(). Estas son las mismas razones que aconsejan
usar el método resize() inserto en init(), para evitar el mismo desagradable efecto.
repaint
Archivo: Appletuno.java
import java.applet.Applet;
import java.awt.*;
69
Como podemos apreciar, no es necesario escribir todos los métodos de un applet,
basta con escribir los que necesitamos para ejecutar nuestro applet.
Luego que escribimos nuestro código, pasaré a explicar como se realiza el proceso
de carga del applet.
Como sabemos, los applet son pequeñas aplicaciones que se ejecutan dentro de un
navegador Web, el tag que acompaña al applet es <APPLET> y se debe especificar
un applet de la siguiente manera:
Para nuestro archivo Appletuno.java, realizamos los siguientes pasos para ejecutarlo
<html>
<body>
<applet code="Appletuno.class" width=300 height=100>
</applet>
</body>
</HTML>
70
3. A continuación compilaremos el applet.
a. Procedemos a abrir un entorno de comando y nos dirigimos al
directorio donde esta el applet y procedemos a compilarlo con “javac”.
71
Al cerrar nuestro Applet, veremos que se escriben los mensajes de los métodos
stop() y destroy().
Como vimos anteriormente, nuestro applet presenta una frase, ahora esa frase va a
estar como parámetro en una página HTML dentro del tag <applet> </applet>.
Archivo prueba.html
<html>
<body>
<applet code="Appletuno.class" width=300 height=100>
<param name=variable value="Parametro traspasado desde mi HTML">
</applet>
</body>
</HTML>
Archivo Appletuno.java
import java.applet.Applet;
import java.awt.*;
72
System.out.println("Parando");
}
public void destroy(){
System.out.println("Preparando la destrucción");
}
public void paint(Graphics g){
System.out.println("Pintando");
g.setColor(Color.blue);
g.drawString(texto,15,25);
}
}
73
MANUAL DE JAVA
74
75
Introducción
La interfase de usuario es la parte del programa que permite a éste interactuar con
el usuario. Las interfaces de usuario pueden adoptar muchas formas, que van
desde la simple línea de comandos hasta las interfaces gráficas que proporcionan
las aplicaciones más modernas.
76
Estructura del AWT
La estructura de la versión actual del AWT podemos resumirla en los puntos que
exponemos a continuación:
77
Conenedores
Una interfase gráfica está construida en base a elementos gráficos básicos, los
Componentes. Típicos ejemplos de estos Componentes son los botones, barras de
desplazamiento, etiquetas, listas, cajas de selección o campos de texto. Los
Componentes permiten al usuario interactuar con la aplicación y proporcionar
información desde el programa al usuario sobre el estado del programa. En el AWT,
todos los Componentes de la interfase de usuario son instancias de la clase
Component o uno de sus subtipos.
Los Componentes deben circunscribirse dentro del Contenedor que los contiene.
Esto hace que el anidamiento de Componentes (incluyendo Contenedores) en
Contenedores crean árboles de elementos, comenzando con un Contenedor en la
raíz del árbol y expandiéndolo en sus ramas.
• Window
• Frame
• Dialog
• Panel
78
Window
Es una superficie de pantalla de alto nivel (una ventana). Una instancia de la clase
Window no puede estar enlazada o embebida en otro Contenedor. Una instancia
de esta clase no tiene ni título ni borde.
Frame
Es una superficie de pantalla de alto nivel (una ventana) con borde y título. Una
instancia de la clase Frame puede tener una barra de menú. Una instancia de esta
clase es mucho más aparente y más semejante a lo que nosotros entendemos por
ventana.
Dialog
Es una superficie de pantalla de alto nivel (una ventana) con borde y título. Una
instancia de la clase Dialog no puede existir sin una instancia asociada de la clase
Frame.
Panel
79
Crear un Contenedor
80
En el código de ejemplo que sigue, extendiendo el código anterior para que la
nueva clase sea una subclase de la clase Panel. En el método main() de esta
nueva clase se crea una instancia de ella y se le incorpora un objeto Frame
llamando al método add().
81
Un objeto Window, y en algunos casos incluso un objeto Dialog, pueden
reemplazar al objeto Frame. Son Contenedores válidos y los Componentes se
añaden en ellos del mismo modo que se haría sobre un Frame.
82
Añadir Componentes a un Contenedor
Para que la interfase sea útil, no debe estar compuesta solamente por
Contenedores, éstos deben tener Componentes en su interior. Los Componentes se
añaden al Contenedor invocando al método add() del Contenedor. Este método
tiene tres formas de llamada que dependen del manejador de composición o layout
manager que se vaya a utilizar sobre el Contenedor.
83
Layouts
84
En el applet que genera la figura siguiente, se utilizan los diferentes tipos de
Layouts que proporciona el AWT y Swing.
NOTA: Los Applets que se utilicen en los ejemplos, serán cargados con la página
HTML ejemplo.html, en donde el único cambio que se le ha hecho para cada uno
de los ejemplos, es cambiar el nombre del archivo class en el parámetro code.
A continuación, explicaré el uso de cada uno de los Layout del Layout Manager.
85
FlotLayout
Es el más simple y el que se utiliza por defecto en todos los Paneles si no se fuerza
el uso de alguno de los otros. Los Componentes añadidos a un Panel con
FlowLayout se encadenan en forma de lista. La cadena es horizontal, de izquierda a
derecha, y se puede seleccionar el espaciado entre cada Componente
86
BorderLayout
El Norte ocupa la parte superior del panel, el Este ocupa el lado derecho, Sur la
zona inferior y Oeste el lado izquierdo. Centro representa el resto que queda, una
vez que se hayan rellenado las otras cuatro partes.
GridLayout
87
La composición GridLayout proporciona gran flexibilidad para situar Componentes.
El layout se crea con un número de filas y columnas y los Componentes van dentro
de las celdas de la tabla así definida.
88
GridBagLayout
89
Vista del Applet.
90
Nótese la inclusión del método addComponent, éste método nos permite modificar
el Layout que se utilizará en el Applet, dentro del cual se crea un gridBagConstraint
para ubicar los componentes ingresados, las posiciones de estos componentes,
quedan como parámetros del método addComponent.
91
CardLayout
92
Vista del Applet con la primera selección del Cuadro de Selección utilizando el
primer card.
Vista del Applet con la segunda selección del Cuadro de Selección utilizando el
segundo card.
93
Crear un Layout Propio
94
Continuación.
95
Código del Applet que utiliza el Layout creado anteriormente.
96
Controles y Componentes
La finalidad de añadir controles como botones, cajas de texto, etiquetas, listas, etc.
es que el usuario interactué con el entorno y pueda realizar las operaciones que
desee. Nosotros seremos los encargados de añadir esos controles y asignarles las
acciones que van a realizar. Muchos de estos controles comparten métodos y
eventos.
Etiqueta (Label)
Se utilizan para dibujar una cadena de texto en una posición y con una alineación
(dentro del componente). Lo primero que hacemos es crearla y luego la
posicionamos dentro de la applet.
Creación:
ALINEACIÓN DESCRIPCIÓN
Label.LEFT Izquierda.
Label.RIGHT Derecha.
Label.CENTER Centrado.
97
Campos de Texto (TextField)
TextField implementa un área de entrada de texto de una sola línea. Todo aquello
que escribimos en una caja de texto es de tipo String por tanto si queremos realizar
operaciones matemáticas deberemos transformarlo a un valor numérico.
Creación:
98
Cuadros de Chequeo (Checkbox)
Las casillas de verificación son botones de opciones, los cuales pueden estar varios
seleccionados a la vez. El texto esta situado a la derecha. La clase Checkbox se
utiliza para crear el control, y los métodos getState y setState para obtener y
mostrar el estado, que admite dos valores True si esta seleccionado y False si no
esta seleccionado.
Estados:
Necesitamos ahora cambiar los Checkbox a botones de opción, para ello, debemos
únicamente crear un CheckboxGroup y entregárselos como parámetro a cada uno
de los Checkbox que deseamos estén como botones de opción.
Creación de Grupo:
Creación de Elementos:
99
Lista (List)
Mediante la clase List crearemos el objeto. Este tipo de lista puede admite más de
una selección, el orden de sus elementos es según han sido añadidos. Los
miembros son los mismos que en el control anterior solo cambia el modo de
construirlos. En este control aparecen unas barras de desplazamiento verticales
automáticamente.
Creación:
Agregar Ítem:
Seleccionar Ítem:
100
Botón (Button)
Son utilizados para ejecutar las acciones. La clase que se utiliza es Button. Una vez
creado hay que asociarlo al método action para realizar la operación. El texto que
aparece en los botones siempre va en el centro.
Creación:
A veces no es suficiente una entrada de texto de una única línea. TextArea es una
caja de texto multilínea, es decir, admite varias líneas. Como valores en la
construcción toma un String inicial, seguido del número de columnas y filas que se
desean visualizar. Además del método constructor existen otros de gran
importancia.
Creación:
Insertar Texto:
Al Final:
Posición Aleatorio:
Reemplazar:
101
Lista Desplegable de Selección (Choice)
Las Listas de Selección (Choice), funcionan de la misma manera que una List, salvo
que en su gráfica, aparece el valor seleccionado en una casilla, y si el usuario
desea seleccionar otro valor, deberá desplegar la lista para seleccionarlo.
Creación:
Agregar Ítem:
Seleccionar Ítem:
102
Barra de Desplazamiento (Scrollbar)
Creación:
CONSTANTE DESCRIPCIÓN
Establecer Valor:
Obtener Valor:
103
Panel (Panel)
Panel es una clase derivada de Container la cual nos va a servir para introducir
controles en su interior, de la misma forma que una canva. La principal utilidad que
se le puede dar es para colocar controles a una ventana en un punto que a nosotros
nos interese a través de un objeto Panel.
Creación:
Tamaño y Posición:
Movimiento:
Añadir Elemento:
104
Barra de Menú (MenuBar)
Cada ventana de nivel superior puede tener una barra de menús. Esta barra esta
compuesta por menús Popup, los cuales están compuestos de menús ítem. Los
menús de tipo ítem también pueden comportarse como Popup con lo que podremos
anidar submenús creando una jerarquía.
Lo primero es crear la barra de menús mediante la clase MenuBar. Una vez creada,
iremos creando los menús popup y cada uno de los ítems que contengan los popup.
Y por último tendremos que ir añadiendo los ítem a los popup y los popup a la barra.
También debemos añadir la barra de menú a la ventana.
105
Cuadro de Dibujos (Canvas)
Creación de la Subclase:
Creación del Objeto Canvas: Debe ser una clase distinta a la anterior.
Tamaño:
Los métodos relacionados con el diseño de los controles que hemos ido viendo
anteriormente también se pueden aplicar al objeto canvas. Como por ejemplo los
métodos para establecer color, tipo de letra, etc...
106
Opciones Gráficas de Dibujo
Los dos métodos anteriores, paint() y update(), junto con el método repaint() son
los que están involucrados en la presentación de gráficos en pantalla. El AWT, para
reducir el tiempo que necesitan estos métodos para realizar el repintado en pantalla
de gráficos, tiene dos axiomas:
107
La pantalla en Java se incrementa de izquierda a derecha y de arriba hacia abajo,
tal como muestra la figura:
Vamos a presentar métodos para dibujar varias figuras geométricas. Como estos
métodos funcionan solamente cuando son invocados por una instancia válida de la
clase Graphics, su ámbito de aplicación se restringe a los componentes que se
utilicen en los métodos paint() y update(). Normalmente los métodos de dibujo de
primitivas gráficas funcionan por pares: un método pinta la figura normal y el otro
pinta la figura rellena.
drawLine( x1,y1,x2,y2 )
drawRect( x,y,ancho,alto )
fillRect( x,y,ancho,alto )
clearRect( x,y,ancho.alto )
drawRoundRect( x,y,ancho,alto,anchoArco,altoArco )
fillRoundRect( x,y,ancho,alto,anchoArco,altoArco )
drawOval( x,y,ancho,alto )
fillOval( x,y,ancho,alto )
drawArc( x,y,ancho,alto,anguloInicio,anguloArco )
fillArc( x,y,ancho,alto,anguloInicio,anguloArco )
108
drawString( string s,x,y )
copyArea( xSrc,ySrc,ancho,alto,xDest,yDest )
109
Eventos
Java presenta una arquitectura para los eventos que funciona orientada al evento,
es decir define clases que se encargan de manejar la interactividad de las
aplicaciones con el usuario.
El paquete que contiene las clases para manipular los eventos están contenida en la
AWT, dentro de java.awt.event.
Dentro del AWT, todas las acciones que pueda realizar el usuario caen dentro de un
gran saco que son los eventos. Un evento describe, con suficiente detalle, una
acción particular del usuario. En lugar de que el programa activamente recoja todos
los eventos generados por el usuario, el sistema Java avisa al programa cuando se
produce un evento interesante.
110
La Clase E vent
key - Para eventos de teclado, es la tecla que se ha pulsado. Su valor será el valor
Unicode del carácter que representa la tecla. Otros valores que puede tomas son los
de las teclas especiales como INICIO, FIN, F1, F2, etc.
arg - Es un argumento dependiente del evento. Para objetos Button, este objeto arg
es un objeto String que contiene la etiqueta de texto del botón
Una instancia de la clase Event será creada por el sistema Java cada vez que se
genere un evento. Es posible, sin embargo, que un programa cree y envíe eventos a
los Componentes a través de su método postEvent().
111
Los eventos se catalogan por su naturaleza, que se indicará en el miembro id de su
estructura. Los grandes grupos de eventos son:
Eventos de Ventana
Son los que se generan en respuesta a los cambios de una ventana un frame o un
dialogo.
• WINDOW_DESTROY
• WINDOW_EXPOSE
• WINDOW_ICONIFY
• WINDOW_DEICONIFY
• WINDOW_MOVED
Eventos de Teclado
Son generados en respuesta a cuando el usuario pulsa y suelta una tecla mientras
un Componente tiene el foco de entrada.
• KEY_PRESS
• KEY_RELEASE
• KEY_ACTION
• KEY_ACTION_RELEASE
Eventos de Ratón
Son los eventos generados por acciones sobre el ratón dentro de los límites de un
Componente.
• MOUSE_DOWN
• MOUSE_UP
• MOUSE_MOVE
• MOUSE_ENTER
• MOUSE_EXIT
• MOUSE_DRAG
Eventos de Barras
• SCROLL_LINE_UP
• SCROLL_LINE_DOWN
• SCROLL_PAGE_UP
• SCROLL_PAGE_DOWN
• SCROLL_ABSOLUTE
112
Eventos de Lista
• LIST_SELECT
• LIST_DESELECT
Eventos Varios
• ACTION_EVENT
• LOAD_FILE
• SAVE_FILE
• GOT_FOCUS
• LOST_FOCUS
Evento
evt.<miembros de la clase>
ó
evt.<miembros de la clase> == evt.id
Vamos a desarrollar una aplicación simple para entender esta forma de generar
eventos.
113
Necesitaremos JCreator para generar la codificación respectiva.
Vamos a generar un frame que va a tener TextFields que van a representar los
miembros de la clase Event. Y objetos que van a provocar la interactividad.
114
Vamos inicialmente a importar el paquete java.awt con todas sus clases.
115
Entonces comenzamos a declarar los objetos que irán en nuestra pantalla.
116
117
Configurar los TextFields sin edición.
118
Y así hemos armado nuestra pantalla, pero falta llamarla para poder mostrarla.
Ahora, para poder ver como esta quedando nuestra ventana, vamos a poner una
leve edición en el método handleEvent.
Vamos a hacer que retorne algo, es decir, como se declara el retorno como bolean,
vamos a retornar true, solo para que compile y presente la ventana.
119
Vemos que ya va tomando forma:
Ahora solo nos falta ingresar el código en el método que manipula los eventos, el
handleEvent. En este método vamos a:
120
Ahora si compilamos y ejecutamos nuestro trabajo, se vería de la siguiente manera:
Como podemos observar y jugar con nuestra pequeña aplicación, hemos conseguido
una herramienta para entender el comportamiento de los miembros de la clase
Event.
Si movemos el Mouse por el applet, notaremos que las coordenadas van a cambiar,
si presionamos el botón, aparecerá el texto del mismo como argumento; a cada
evento se va modificando el tiempo en que ha ocurrido, etc.
121
Cuando un usuario interactúa con el applet, el sistema Java crea una instancia de la
clase Event y rellena sus datos miembros con la información necesaria para
describir la acción. Es en ese momento cuando el sistema Java permite al applet
controlar el evento. Este control comienza por el Componente que recibe
inicialmente el evento (por ejemplo, el botón que ha sido pulsado) y se desplaza
hacia arriba en el árbol de Componentes, componente a componente, hasta que
alcanza al Contenedor de la raíz del árbol. Durante este camino, cada Componente
tiene oportunidad de ignorar el evento o reaccionar ante él en una (o más) de las
formas siguientes:
El sistema Java pasa información del evento a un Componente a través del método
handleEvent() del Componente. Todos los métodos handleEvent() deben ser de la
forma:
122
No hay métodos de ayuda para ciertos tipos de eventos, aquí está la lista de los que
están disponibles para los programadores:
No seguir esta regla tan simple hará que no se invoquen adecuadamente los
métodos de ayuda.
123
ACTION_EVENT
Algunos de los eventos que más frecuentemente tendremos que controlar son los
siguientes:
ACTION_EVENT
MOUSE_DOWN
KEY_PRESS
WINDOW_DESTROY
Como ejemplo del manejo de eventos vamos a ver este evento que se provoca al
pulsar un botón, seleccionar un menú, etc. Para su control podemos manejarlo en el
método handleEvent() o en el método action().
Los dos métodos anteriores pertenecen a la clase Component por lo que todas las
clases derivadas de ésta contendrán estos dos métodos y se pueden sobrecargar
para que se ajuste su funcionamiento a lo que requiere nuestra aplicación.
Veamos el siguiente ejemplo, en que se controla este evento a través del método
handleEvent(), que es el método general de manejo de eventos:
Pero en este caso, cuando se produce este evento se llama al método action(), que
sería:
124
un botón que cambia su etiqueta cada vez que se pulsa. Aunque esta no es la única
forma de manejar eventos; de hecho se puede hacer:
125