INSTITUTO DE TECNOLOGÍA Y COMPUTACIÓN

MANUAL de JAVA y UML Básico

2006

CESAR ROJAS MORAGA RELATOR

Índice 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 Java se ha convertido hoy en día en uno de los lenguajes de programación más importantes, sobre el cual se están desarrollando aplicaciones de variadas índoles, como por ejemplo, aplicaciones Web, aplicaciones para dispositivos electrónicos, incluso para proyectos de robótica avanzada. El enfoque que tiene el curso es dar una capacitación en el lenguaje en sí, demostrando que la programación orientación a objeto es fácil de entender mientras se programe y se trabaje directamente en el código.

3

MANUAL DE JAVA CAPITULO 1: INTRODUCCION 4 .

5 .Introducción El lenguaje de programación que utiliza Java es netamente orientado a objeto. el nivel sintáctico es muy similar a C y C++. además posee un control del flujo de fácil manejo. A continuación presentaremos la Historia y comenzaremos a entrar en profundidad en el lenguaje Java. Contiene clases que pueden manipular los tipos de variables de manera fácil.

ésta versión es un Híbrido. Para 1978. lenguaje que incorpora a los lenguajes BCPL y C. es decir con clases. obteniendo lo mejor de ambos. para que los desarrolladores tengan a que atenerse para no perder el estándar. este lenguaje fue desarrollado en los laboratorios AT&T DELL Laboratorios en un computador DEC PDP-7. el proyecto tenía como meta desarrollar tecnología para el manejo de los dispositivos electrónicos nuevos que aparecerían en el mercado. pues permite desarrollar de manera estructurada como en C y también de manera orientada a objeto. Bjarne Stroustrup. la orientación a objeto. C se convierte en el lenguaje preferido para desarrollar aplicaciones y diferentes tipos de sistemas y programas. el cual estaba orientado principalmente para la programación de Sistemas Operativos y compiladores. pero en un computador DEC PDP-11. en donde se comienzan a desarrollar las referencias del lenguaje. una nueva e interesante capacidad. pues Sun esperaba obtener grandes proyectos. en 1972. la cual tenía a su haber el sistema operativo Solaris y también la Arquitectura SPARC. obtener ventaja de la gran expansión tecnológica que vendría con los dispositivos electrónicos. se realiza una congregación. bajo la supervisión de la ANSI. el problema surge porque C es de “open source”. denominado “B”. denominada la X3J11. conocida como C++. dando como resultado la versión avanzada de C. publica el libro “The C Programming Languaje”.Aspectos Históricos Hace ya muchos años. libro que ha sido el más vendido en la historia de los libros informáticos. y con ellos. bajo el mando de James Gosling. en el cual se escribieron las primeras líneas del sistema operativo UNIX. Dennos Ritchie desarrolla “C”. Martin Richards desarrollo un lenguaje de programación denominado “BCPL”. se encontraba Sun Microsystem. que prontamente se hicieron incompatibles entre ellas. con ésta fama. En los mismos laboratorios. por allá por fines de los 60. Es así como para el año 1989 es aprobado el estándar de C. bajo el nombre de ANSI/ISO 9899:1990. por lo tanto existieron tantas versiones como aplicaciones. 6 . es así como “C” comienza a ser pilar fundamental en la programación del código fuente de UNIX. Ésta empresa financia a comienzos de los 90 un proyecto denominado GREEN. Por el año 1980. En 1970. es por esto que en 1983. Kem Thomson presentaba su lenguaje. Dentro de las grandes empresas desarrolladoras de tecnología. la editora Prentice Hall. comienza a incluir dentro de la programación estructurada de C.

con lo cual el equipo de James Goblin debió cambiar el nombre de su lenguaje de programación. desarrollaron un lenguaje de programación que denominaron “OAK” que significa Roble en Inglés. además que la explosión de los dispositivos electrónicos llegó con el tiempo. una de las tecnologías más admiradas y venerada de los últimos años. debido a que a comienzos de los 90. así que. maravillando al mundo con el dinamismo que le otorgaba a las estáticas páginas Web predominantes en esos años. Palms. Sun Microsystem. pues se cuenta que desde su ventana en las oficinas de Sun Microsystem. él puede ver un roble que esta en el patio.0. Nace así. por lo cual se vio gravemente afectado el proyecto GREEN. Pero Goblin no se vería disminuido por lo sucedido. La historia cuenta que le denominaron JAVA por el café que tomaban a la hora de descanso durante el desarrollo del lenguaje.James Goblin y su equipo. JAVA ha comenzado a ocupar espacios que ningún otro lenguaje lo había logrado. El problema surge por que ya existía una empresa con un lenguaje denominado “OAK”. El tema principal es que la gran explosión de dispositivos electrónicos que esperaba la Sun nunca existió. además que parte de los proyectos que esperaban fueron otorgados a otras empresas. Pocket PC. a tal punto de ser casi clausurado. la versión 1. volcaron JAVA al desarrollo de aplicaciones Web. Servidores Web. Robots. es así como en 1995. presenta al mundo su primera versión de JAVA. con astucia. 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. 7 . etc. Permaneciendo así en Celulares. la WWW alcanzó niveles de desarrollo insospechados.

existe una Maquina Virtual para descargar. debido a que trata de resolver problemas de Internet con contenidos de Internet.sun. 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. cuando una maquina se conecta a un servidor. el cual se puede descargar desde la página de sus creadores y dueños. además que Java es un Kit de Desarrollo gratis. www. Java se ha convertido en el lenguaje de programación de Internet por excelencia.com/java/. indistintamente el hardware que posea el computador del usuario. Para el mundo Web. 8 . el compilador traduce el código fuente Java a Bytecode. • • En la actualidad. Al contrario de los compiladores normales que convierten el código fuente a instrucciones a nivel de máquina.¿Qué es Java? El significado de Java. Actualmente. es el de un lenguaje de programación y un entorno para ejecución de programas escritos en lenguaje Java. instrucciones que son interpretadas por una Máquina Virtual de Java. conocida como la JVM (Java Virtual Machine). el contenido de la WWW es pasivo y estático. Toda esta maravilla la permite la JVM y se explica en este gráfico a continuación. éste le transfiere el código nativo de java al computador del usuario para que la maquina virtual lo ejecute en el navegador del mismo. La entrega (Delivery) del contenido WWW es dependiente de la configuración de cada navegador Web de usuario. para cada Sistema Operativo. tal y como se le conoce en al actualidad. Computador Local Sistema Operativo Navegador Java Máquina Virtual Java Código Fuente Computador Servidor (Host) Código Nativo Java En ésta figura.

2 interfaz gráfica de usuario. posteriormente aparece la 1.1. Java 2 con SDK 1998. salto que no se representaba con un aumento de un dígito. ha servido para asentar la eficiencia y calidad de Java. pequeña versión centrada en la Web. y una tecnología de componentes denominada JavaBeans. Versiones La versión original de Java que se comercializó y se expandió rápidamente fue la 1. Java 2 con SDK 2001. es un Kit de Desarrollo Estándar. Nokia. introduce la posibilidad de trabajar con XML 1. incluye una nueva 1.5 9 .3 mejorada.0. que para muchos fue un salto bastante importante dentro del desarrollo de las capacidades del lenguaje. Posteriormente la versión 2. conectividad a bases de datos y muchas otras mejoras. Se puede considerar que Sun ha lanzado al mercado seis versiones importantes del lenguaje Java: Java 1. disponible uniformemente para todos los navegadores Web populares. de bolsillo o de mano (handhelds)) que requieren una integración en dispositivos con poco espacio físico y memoria de trabajo. con sus diferentes kit de desarrollo.1 1997. manipulación de eventos o sucesos. reescrito totalmente. La versión J2SDK.0 1995.4 Java 2 con SDK 1. Java 1. J2ME Es un nuevo estándar para dispositivos inalámbricos (móviles. mejora la interfaz de usuario. HewtlettPackard…) que lo soportan con especificaciones comunes. Motorola. el cual permite comenzar a desarrollar aplicaciones de aprendizaje previo al desarrollo profesional de aplicaciones en J2EE. reconocido por la industria. más accesibilidad y compilación más rápida. Java 2 con SDK 2000. Actualmente J2EE se ha convertido en un autentico estándar. añade características notables como multimedia 1.Evolución de las Versiones de Java Existen dos grandes especificaciones actualmente en entorno Java: J2EE Está orientada a al desarrollo de aplicaciones de propósito empresarial o para servidores y son numerosos los grandes fabricantes (IBM. versión ampliada significativamente.

MANUAL DE JAVA CAPITULO 2: PROGRAMACION ORIENTADA A OBJETOS 10 .

lo que quiere decir que es un modelo matemático de una estructura de dato que especifica el tipo de dato almacenado. Todos los lenguajes de POO proporcionan mecanismos que ayudan a implementar el modelo orientado a objetos. • La abstracción se puede presentar como un Tipo Abstracto de Dato (TAD).. La idea principal de un sistema orientado a objetos es un conjunto de objetos que interactúan entre sí y que están organizados en clases. nada más. • La abstracción es el proceso de capturar los detalles fundamentales de un objeto mientras se suprimen o ignoran los detalles. solo nos vamos a concentrar en acelerar. el aire acondicionado. es decir. Sin embargo. Existen dos paradigmas que controlan el modo en que se construye un programa.Principios de la Orientación a Objetos Todos los programas de computadora constan de dos elementos: código y datos. herencia y polimorfismo. • 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. Los programas que se escriben alrededor de “lo que esta sucediendo” (paradigma procedimental u orientado a procesos). o Por ejemplo. pero muchas veces no nos importa como funciona su motor. o Por ejemplo. El otro enfoque dice que los programas se pueden escribir alrededor de “quien está siendo afectado” (paradigma orientado a objetos). 11 . no nos vamos a concentrar en como funciona el motor o las partes tecnológicas del auto. pero no cómo lo hace. Abstracción: • Es un elemento fundamental de la POO • Las personas gestionamos la complejidad a través de la abstracción. las operaciones soportadas pro ellos y tipos de los parámetros de las operaciones. sabemos conducirlo. • Un TAD especifica qué hace cada operación. un TAD se puede expresar como una interfaz que normalmente es una lista de declaraciones de métodos. está en el núcleo de Java. • En Java. las personas andamos en un auto sin importar como este trabaja internamente. los freso. Estos principios o propiedades fundamentales son: abstracción. todos los programas en Java son orientados a objetos. encapsulamiento. código. solo nos importa el auto como un todo. La Programación Orientada a Objeto (de ahora en adelante POO). este enfoque caracteriza un programa como una serie de etapas lineales. Este paradigma es la base de Java. si tenemos que ir de un sitio A a un sitio B en el vehículo del ejemplo anterior. virar a la derecha o izquierda por el camino. la caja de cambio etc. De hecho. un programa se puede organizar conceptualmente alrededor de su código o alrededor de sus datos.

como el envoltorio que encierra al código y a los datos. usando herencia. un objeto solo necesita definir aquellas cualidades que lo hace único dentro de la clase. el encapsulamiento proporciona al programador libertad en la implementación de los detalles de un sistema. • Cuando se crea una clase. Herencia • Herencia es el proceso mediante el cual un objeto adquiere las propiedades de otro objeto. es el mecanismo que enlaza juntos código y los datos que los manipulan y los mantienen seguros de interfaces externas y mal uso.Encapsulamiento • Es sinónimo de ocultación de información. se especifica el código y los datos que constituyen esa clase. • Como ventaja. Estos miembros pueden ser públicos o privados dentro de la misma clase. • Las nuevas clases pueden heredar atributos generales de su clase padre o clase base. y a su vez es parte de la clase mamífero. Así que comúnmente se utilizan métodos públicos para manipular los datos de la clase que son privados. • El usuario de un objeto nunca necesitará conocer el interior de una clase. Por ejemplo. que a su vez es de la clase animal. • Es el proceso de ocultar todos los detalles de un objeto que no contribuyen a sus características esenciales. a estos elementos se les llama miembros de la clase. los fundamentos de la encapsulación están en la clase. desde un punto de vista más técnico. un pastor alemán es parte de la clase perro. • Se puede pensar en encapsulamiento. el objeto necesitaría definir todas las características nuevamente. • Sin el uso de la herencia. • En la POO se pueden derivar o extender nuevas clases de otras clases existentes. también denominada superclase. • En Java. • Encapsulamiento. Animal Mamífero Perro • Muchas personas ven en la naturaleza como un conjunto de objetos están relacionados entre sí de manera jerárquica. Esta propiedad se denomina herencia. Una clase define la estructura y el comportamiento (datos y código) que se compartirá por un conjunto de objetos. La única restricción que tendrá el programador es mantener la interfaz abstracta que ven los usuarios externos. 12 . Sin embargo.

• El polimorfismo como sobrecarga (en Java) ocurre cuando una clase X tiene múltiples métodos con el mismo nombre. • La signatura de un método es una combinación de nombre y tipo de argumentos de un método. que significa “muchas formas” • En la práctica. o public double getDistancia() o public double getDistancia(double x. De hecho cada clase que se define en Java se hereda de una clase existente.• La herencia es un concepto poderos de Java. Polimorfismo • Proviene del griego polymorphos. dependiendo de su implementación. • Herencia. • El polimorfismo se aplica sólo a métodos que tienen la misma signatura pero están definidos en clases diferentes. cada uno de ellos con una signatura distinta. Del mismo modo cada objeto responde a ese mensaje de manera distinta. por ejemplo. polimorfismo y sobrecarga de métodos soportan el desarrollo de software reutilizable. MANUAL DE JAVA CAPITULO 3: ELEMENTOS DEL LENGUAJE JAVA 13 . pero con argumentos distintos. tenemos dos métodos con el mismo nombre. bien explicita o implícitamente. double y) En este caso. es la propiedad que permite enviar el mismo mensaje a objetos de diferentes clases (totalmente diferentes).

incluso para programadores experimentados. • Estos errores los detecta el compilador. se visualiza un mensaje de error que devuelve la posible causa del error. Una mezcla de las advertencias del compilador. Desgraciadamente los errores no siempre se detectan y los mensajes de error no siempre son fáciles de interpretar.java Compilar Errores Editar y corregir errores de compilación No existen errores Ejecutar Programa Editar para corregir o ampliar Los mensajes de error que produce el compilador no siempre ayudan a encontrar los errores. Editar y crear un nuevo archivo . El proceso de corregir un error (bug en inglés) se denomina depuración ( debugging) del programa. Existen tres tipos de errores: errores de compilación (sintaxis). • Ejemplo: utilizar una variable que no se ha definido previamente. Errores de Ejecución 14 . serán quienes proporcionen el conocimiento suficiente para llegar a depurar programas con éxito.Errores de Programación Los errores de programación son inevitables. Cuando se detecta un error en Java. manual de instrucciones y sobre todo la experiencia del programador. El ciclo de Editar-Compilar-Ejecutar junto con la depuración paso a paso de los errores observados y fijados en los programas se pueden observar en la siguiente figura. 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.

15 .• • • • • Este tipo de errores aparecen cuando el sistema termina de forma anormal y que se detectan y visualizan durante la ejecución del programa. Ejemplo: si el programa espera un número y el usuario ingresa una cadena de caracteres. Un error de entrada ocurre cuando el usuario introduce un valor de entrada imprevisto que el programa no puede manejar. además pueden no producir un término anormal del programa. Errores Lógicos • Los errores lógicos ocurren cuando un programa realiza un algoritmo incorrecto y no ejecuta la operación que estaba prevista. • Generalmente se detectan cuando se observan los valores de salida 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. pues no se avisan como los errores de compilación. • Son complicados de detectar. Ejemplo: realizar una división por cero.

JCreator.java. preparamos las variables de entorno para poder compilar nuestro programa y ejecutarlo en cualquier directorio en el que se encuentre. NOTA: al utilizar algún editor. obtenemos las propiedades de Mi PC 16 .Edición. nos permiten a través de botones. Compilación y Ejecución de Programas Los programas escritos en java. 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. a continuación presentaré un ejemplo sencillo de nuestro primer programa en Java. class Holamundo{ static public void main(String [] args){ System. y ejecutados desde una línea de comandos cualquiera. Visual age. } } Posteriormente a esta edición. Primeramente. realizar la compilación y ejecución de nuestros programas. por ende. Eclipse. etc. Para ello. sea este Netbeans. pueden ser editados desde cualquier editor de texto.println("Hola mundo.out. editamos el texto en Java y lo guardamos como Holamundo. este es el primer ejemplo en java").

Chiqueamos en la pestaña de “Opciones avanzadas” y presionamos en el botón de “Variables de Entorno” 17 .

permitiéndonos así utilizarlas desde cualquier directorio en nuestro computador. 18 . Seleccionamos la variable Path y chiqueamos en “Nueva” Ingresamos el nombre de la variable como “java” y como valor de la variable. ponemos la dirección de la carpeta “bin” en el JDK de Java.Esta ventana nos permite editar las variables que permanecerán en el entorno de Windows.

java. 19 .java. podremos compilar nuestro archivo Holamundo.La ventana nos quedaría de la siguiente forma. Si revisamos el directorio veremos que solo esta nuestro archivo Holamundo. posteriormente aceptamos y volvemos a aceptar en la ventana de propiedades de Mi PC. con esto. ahora procederé a compilar el archivo con el comando “javac”.

class.) Esto nos demuestra que Java es multiplataforma. lo hacemos con el comando “java”. ya que su JVM ejecuta su Bytecode en cualquier máquina en la cual este instalada. Lo que realizamos se explica en este gráfico: Holamundo. Para ejecutar nuestro archivo en bytecode con la Maquina Virtual de Java.Si volvemos a revisar nuestro directorio.java Javac Holamundo.class (en Bytecode) Java Holamundo (Solaris) Java Holamundo (Windows) Java Holamundo (Otra Maquina y S. este archivo se crea como Holamundo.O.java Holamundo. 20 . observaremos que el compilador de java genera un archivo en bytecode.

private. Final: Modificador que declara constantes 21 . métodos y clases. permanecerán estáticos bajo la misma clase. Por ejemplo la palabra “import” le indica al compilador que se necesita realizar una importación. final. protected Public: Modificador que permite visualizar las variables y métodos desde cualquier otro paquete de clases o clase. las cuales especifican las propiedades de los datos. solo se pueden manipular las variables o métodos con este modificador dentro de la misma clase. y es modificada. static. abstract. Static: Modificador que indica que las variable so métodos declarados. se modificará a todos los miembros de la clase. es decir que si tengo una variable declarada de manera estática. Por ejemplo: public.Elementos Básicos Comentarios Los comentarios en Java se pueden anotar de dos maneras: //comentario de una sola línea /* 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. Private: Modificador que impide visualizar las variables o métodos desde otras clases y paquetes. El listado de las palabras reservadas de Java se presenta a continuación: Modificadores Existen palabras reservadas que Java denomina “Modificadores”.

Sentencias Una sentencia representa una acción o una secuencia de acciones. Protected: Modificador que permite a miembros de una misma clase o paquete a obtener la variables y métodos declarados como protegidos. Los bloques comienzan con una llave de apertura ({) y cierran con una llave de cierre (}).out. cada sentencia termina con un punto y coma (“. } 22 . no podrán acceder a las variables y métodos protegidos. pero las clases que se encuentran fuera del paquete.Abstract: Modificador que declara clases y métodos que se declaran de manera abstracta.out.println (“Hola mundo”). ejemplos de sentencias: int c=0. System.println(“menor que 34”). por ejemplo: if (a<34){ System.”). Bloques Un bloque es una estructura de programa que agrupa sentencias.

Un ejemplo de su utilización lo demuestro a continuación: Donde la salida de este programa es la siguiente 23 . todo lenguaje de programación debe contenerlos. ENTONCES haga lo siguiente. O SI esta otra condición ocurre. bifurcaciones y bucles. A continuación veremos como se definen ambos en Java.Control de Flujo Los controles de flujo cuentan de dos partes. • Bifurcaciones o if – else if – else Esta bifurcación permite realizar las preguntas de SI esta condición ocurre. debido a que son claves al momento de administrar la ejecución de un programa.

o switch .case Esta bifurcación permite hacer selecciones de casos para hacer más rápido la bifurcación. Y la salida de este programa es la siguiente: 24 . a continuación presentaré un ejemplo de este comando.

mientras la condición se cumpla. La estructura del for es la siguiente for (número . Para entender de mejor manera el funcionamiento del bucle while. o for El ciclo for. incremento o decremento){ Bloque… } 25 . veamos este ejemplo a continuación. y que puede ir creciendo o disminuyendo. el bloque se ejecuta.• Bucles o while El while tiene como traducción “mientras”. esta condición va de la mano de un número entero que se debe declarar dentro del for. y funciona de la siguiente manera. Que tiene la siguiente salida. condición . no permite realizar un ciclo gracias a que existe un condición que debe cumplirse.

Este ejemplo nos entrega la siguiente salida. 26 .A continuación veremos un ejemplo aclarador del uso del for.

27 .class. Un programa consta de una o más clases y cada una de ellas puede contener declaraciones de datos y métodos. NOTA: Las clases serán explicadas en un capítulo aparte. Es un método que visualiza un mensaje en el monitor o consola. } NOTA: Los métodos se explicarán más adelante. 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.out.Clases La clase es la construcción fundamental de Java.println(“Bienvenido a mi Ejemplo”). A continuación se presentan los ocho tipos primitivos de variables. Métodos Un método es una colección de sentencias que realizan una serie de operaciones determinadas. la cual constituye una plantilla o modelo para fabricar objetos. Cada archivo de clase se compila en un archivo de Bytecode con la extensión . valores boléanos. caracteres y valores numéricos o de punto flotante. El método main tendrá siempre una sintaxis similar a esta: static public void main (String [] args){ //… sentencias. Tipos Primitivos de Datos Los tipos primitivos de datos o variables de Java con aquellas variables sencillas que contienen los tipos de información más habituales. Por ejemplo: System.

Una serie de comentarios ubicados en cualquier parte programa. 28 .(//comentario) Declaraciones de las clases deseadas. puede no haber ninguna.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: • • • • • Una sentencia de Paquete (package) que también puede ser omitida. Definiciones de métodos. de forma que los datos de una objeto se encontrarán separados de los de otro objeto. Dado que una clase es un modelo y las instancias son los objetos de esa clase. utilizándose los métodos para la modificación de los valores de las variables de instancia. ninguna o varias sentencias de importación (import).(class) Una declaración de clase pública (public class). Una. a las variables de instancia se les denomina así porque cada objeto contendrá una copia de dichas variables. • • • • Declaraciones de variables de la clase (estáticas). Declaraciones de variables de instancia Definiciones de constructores. del A su vez una declaración de clase comenzará con al sentencia (class) y podrá contener.

Hay varios casos donde nos podemos encontrar con este tipo de situaciones. intentaremos ejecutar un bloque de declaraciones. es mucho más fuerte. En primer lugar. como por ejemplo: • • • • No existe el archivo que queremos abrir. 29 . No existe el otro extremo de la conexión de una red. Se ha perdido el archivo class que se quiere cargar o bien no cuenta con el formato adecuado. Una excepción es una condición anormal quien interrumpe el flujo lógico de un programa. algo lanzará una excepción que podremos capturar con el controlador adecuado. Uno de los operadores no se encuentra dentro del rango legal para dicha operación o método. Modelo Básico Java sigue la sintaxis que usan los controladores de excepciones en C++. cada vez es más difícil construirlos con robustez. Dentro de los programas básicos que hemos desarrollado esta el típico programa que recibe datos desde el teclado.Control de Excepciones Según se van complicando los programas. por lo menos esta comprobado que el impacto que produce el cierre anormal del programa en un usuario. a continuación utilizaremos el mismo programa para demostrar cuando se lanza una excepción al convertir una cadena a un int. Por ejemplo. Además. Siempre será mejor lanzar una excepción que cerrar el programa abruptamente. puede haber un bloque de declaraciones que queremos ejecutar (independientemente de que se den o no excepciones). a ver un mensaje de error. el tamaño correspondiente al índice de un array no puede ser superior al de la propia matriz y el divisor de una operación no puede ser igual a cero. Si aparece una condición anormal.

parseInt(cadena). String cadena= in.*.in). System.io.out. nos presentará un mensaje de error de compilación que nos dice que una excepción puede ser lanzada. podemos instalar una throws IOException después del método main de la siguiente manera. int numero= Integer.print("Ingrese un numero: "). Para solucionar este problema de compilación.println("Fin del Programa").*. class Error{ static public void main(String [] args){ InputStreamReader isr= new InputStreamReader(System.println("Fin del Programa"). concepto que veremos más adelante. que las excepciones posibles no están siendo soportadas. //producirá un error si no System.// ingresamos un numero } } 30 . BufferedReader in= new BufferedReader(isr). BufferedReader in= new BufferedReader(isr).out. String cadena= in.out. es decir.print("Ingrese un numero: "). // ingresamos un numero } } Si procedemos a compilar este código fuente. int numero= Integer. import java.out. //producirá un error si no System.in).io.readLine().readLine().import java. class Error{ static public void main(String [] args)throws IOException{ InputStreamReader isr= new InputStreamReader(System.parseInt(cadena). System. estas deben ser contenidas o deberán ser lanzadas.

situado después de los catch de un try. un bloque para detectar excepciones catch. finally. indica las excepciones que se pueden elevar de un método. se producirá un error de transformación. bloque. throws. una excepción para levantar (raise) excepciones. try. un manejador para captura excepciones de los bloques try. El modelo de un mecanismo de excepciones consta. opcional.lang. y el error es de tipo java. Para solucionar este problema explicaré el mecanismo de manejo de excepciones. pero que sucede si ingresamos una cadena de texto normal. de cinco nuevas palabras reservadas. throw. 31 .Procedemos a compilar y a ejecutar Deberíamos ingresar un número. el cual se explica en un mensaje a continuación Este mensaje de ejecución que se explica en la imagen anterior. throw. fundamentalmente. throws catch.NumberFormatException para la cadena de entrada “cesar”. y finally. dice que ha ocurrido una excepción en el hilo “main”. • • • • • try.

println("Excepcion capturada"). }catch(IOException provocado){ System.out. 32 .println("Ejecución de bloque finally").Finally Iniciemos la explicación con el siguiente código: Archivo Error2.Catch . class Error2{ static public void main (String [] args){ try{ lanzar_excepcion().*. } } Compilemos y ejecutemos este código 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. }catch (Exception e){ //hacemos algo si viene otro tipo de excepción }finally{ System.java import java.out.io.Try – Throw – Throws . } } static public void lanzar_excepcion()throws Exception{ //provocamos un lanzamiento con throw throw new IOException().

• • •

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
CAPITULO 4: PROGRAMACION ORIENTADA A OBJETOS CON JAVA

34

Abstracción (Aplicado)
Como comentamos anteriormente, la abstracción nos permite capturar lo más importante de un objeto, sin importar como funciona, aplicaremos esto de la siguiente manera, daré un objeto y comenzaremos a abstraerlo, para así conocer la aplicación de abstracción en la POO. Objeto: Punto bidimensional • • Una Punto tiene una coordenada x y una coordenada y; (x, y) (atributos) A una Línea se le puede calcular la Distancia del punto al centro del eje v (x2+y2), se puede pedir el valor de x, y (métodos)
Y (x,y)

v (x2+y2)
(0,0) X

Vamos a programar lo siguiente, en un diagrama de clases de UML se vería así:

35

sqrt((x*x)+(y*y)). porque el termino encapsulamiento en sí. dos atributos. private double y. //Constructor public Punto2d(double x. Archivo Punto2d. 36 . vamos a programar el diagrama de clases en UML que dejamos pendiente en el paso anterior.java class Punto2d{ //atributos private double x. son declarados como privados. this. todos las instancias de la clase Punto2d que se generen. protegiendo los datos y los métodos que desee sean privados. double y){ this.Encapsulamiento (Aplicado) El encapsulamiento e la capacidad que tiene el programador en dejar todo lo s abstraído en una clase. A modo de ejemplo. al menos que se consulten los métodos “get”. tendrán. Continuando con el ejemplo del punto. que son x e y. y los tres métodos. por lo tanto no se puede acceder a ellos desde otra clase. } //metodo public double getDistancia(){ return Math. gracias a la encapsulación. getX() y getY(). a esto se le denomina en parte encapsulamiento. getDistancia(). getX() y getY().x= x. los atributos de la clase.y= y. } public double getY(){ return y. y dejando los métodos esenciales como públicos para que otras clases o sistemas las puedan utilizar. se explica en la capacidad de generar una estructura o un molde con características similares para las instancias que se generen en esta. } public double getX(){ return x. } } Como podemos observar.

expondré un ejemplo de Herencia en código fuente de Java. Utilizaremos la siguiente abstracción: Un punto puede ser definido en un plano de tres dimensiones. Por lo tanto. como se explicó anteriormente. La idea es heredar las características de la clase Punto2d y agregar los nuevos atributos y métodos a la clase Punto3d. getDistancia(). para ello. getY() y crearemos el getZ(). A continuación.Herencia (Aplicado) La herencia. también podemos escribir los métodos. el punto va a tener una coordenada x. es la capacidad de traspasar las características de una clase padre a una clase hija. es decir hereda las características de la clase Punto2d. 37 . esto nos permite ahorrar líneas de código y reutilizar el software diseñado anteriormente. El diagrama de clase de Punto3d quedaría de la siguiente manera: En donde la flecha que une las dos clases representa que la clase Punto3d es subclase de la clase Punto2d. 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). getX().

} //metodos public double getDistancia(){ double x2= Math.Como se ve esto en código. en este caso a Punto2d.getY(). de la siguiente manera. double z){ super(x. double y2= Math.java class Punto3d extends Punto2d{ //atributos private double z. se utiliza una función de la clase Math que nos permite elevar a potencia un valor (Math. Dentro del método getDistancia(). es la que nos permite acceder a las variables y métodos de la superclase.sqrt).pow(super. //constructor public Punto3d(double x.z= z. } public double getZ(){ return z.y). this.getY().2). La palabra clase super. Como sabemos que no podemos acceder a la variable x directamente.pow(super. Además utilizamos otra función de la clase Math.x.2). } public double getX(){ return super.sqrt(x2+y2+z2). Archivo Punto3d.getX(). double z2= z*z. } } La palabra clase “extends” es la que indica que vamos a heredar de la clase Punto2d. } public double getY(){ return super. } 38 . return Math.getX(). double y. que nos permite obtener la raíz cuadrada de un número (Math. es decir utilizando el siguiente código: public double getX(){ return super.pow).

39 .Éste código nos marcará una excepción. por eso se crea el método publico getX(). la cual nos indicará que estamos haciendo referencia a una variable de tipo privada. Pero. falta apreciar como podemos ejecutar todo esto. nos falta una clase main para poder jugar con las clases que acabamos de crear. es decir. retornar el valor de la variable x. el cual tiene como función.

Punto3d otropunto = new Punto3d(3.getDistancia()).Polimorfismo (Aplicado) Como expliqué anteriormente. System. para nuestro manual.5.getDistancia()). solo que no han apreciado la manera básica como lo realizamos.4. } } Pundo2d es: "+ Pundo3d es: " + La idea es que los tres archivos los guardemos en el mismo directorio. Archivo PruebaPuntos. ya hemos programado polimorfismo. System. 40 . 5). System. de hecho.7). polimorfismo es la capacidad de crear métodos que se aplican a distintos objetos con el mismo comportamiento.println("La distancia del punto.out. estos tres archivos se encuentran en c:\manual\ Procederemos a compilarlos.out. Voy a presentar el método main en donde ejecutaremos.println("La distancia del otropunto.out.java class PruebaPuntos{ static public void main(String [] args){ Punto2d punto= new Punto2d(3.println().

• Declaramos el constructor.getX(). pero con la salvedad de que la única manera que tenemos de obtener los atributos x e y.java tenemos: • Declaramos una clase que contiene 2 atributos que fueron declarados como privados. declaramos el método getDistancia(). es llamando a los métodos getX() y getY() de la superclase.2). en donde podemos imaginar que estamos utilizando el constructor de Punto2d para entregar los valores a las variables x e y de esa clase. • Utilizamos la palabra clase this. la cual nos permite indicarle al compilador que el valor del parámetro x va a ser asignado a la variable de clase x (this. estos son entregados como parámetros directamente al constructor. • Declaramos sus atributos • Declaramos su constructor. la cual recibe el valor al cuadrado que nos devuelve la línea: Math. En el archivo Punto3d. • Para obtener la distancia. 41 . pero ¿se logra entender lo interesante de la codificación?. En el archivo Punto2d. getY() y getZ(). lo voy a explicar paso a paso. por eso se declaro una variable double en el método. lo cual nos permite utilizar sus métodos y atributos. que nos retorna el valor de la distancia. el cual entrega los valores iniciales de la clase. la salida de nuestro archivo principal es súper simple.y). • Declaramos los métodos getX(). es decir PruebaPuntos. • Declaramos el método getDistancia(). para aclarar un poco más todo lo que hemos realizado.Ahora procedemos a ejecutar nuestro archivo main.x). por lo tanto no se pueden acceder desde otra clase. el cual a su vez utiliza el constructor de la superclase Punto2d con la sentencia super(x. es decir nos ayuda a hacer una diferencia de las variables.java Como podemos apreciar.pow(super.java tenemos: • Heredamos con (extends) la clase Punto2d.

• Creamos una instancia de la clase Punto3d. getX() y getY(). además sobrecargamos el método getDistancia(). el getDistancia y los getX() y getY(). aplicado al objeto otropunto de la clase Punto3d. que es heredera de la clase Punto2d. • Presentamos en pantalla el resultado de la función getDistancia(). aplicado al objeto punto de la clase Punto2d. que se llamo otropunto.java tenemos: • Creamos una instancia de la clase Punto2d. o Éste objeto tiene dos atributos. además creamos un método propio denominado getZ(). 42 . que se comporta de manera similar en ambos. además tiene tres métodos. que se llama punto. Como apreciamos anteriormente tenemos 2 objetos distintos con un mismo método getDistancia(). un valor x y un valor y. o Éste objeto tiene 2 atributos heredados y uno propio.En el archivo PruebaPunto. • Presentamos en pantalla el resultado de la función getDistancia(). a esto se le denomina básicamente polimorfismo.

MANUAL DE JAVA CAPITULO 5: INTRODUCCIÓN A UML 43 .

MANUAL DE JAVA CAPITULO 6: PAQUETES DE JAVA 44 .

ya que ellos prestan a menudo una ayuda muy importante.Introducción En éste capítulo aprenderemos las capacidades de los paquetes estándar que trae Java. 45 . además aprenderemos a crear nuevos paquetes. a sacar partido a los paquetes definidos dentro del JDK.

Las declaraciones import tienen que aparecer al principio del archivo del programa. package miPaquete. Y packageName puede ser un nombre de un paquete o de una lista de ellos.awt. sólo se especifica la clase del paquete que se ha importado. import packageName. las dos declaraciones siguientes son completamente legales. donde nombre puede ser el nombre de un paquete o una lista de paquetes separados por comas. la cual nos permite hacer referencias a clases e interfaces definidas en otros paquetes.awt. los archivos class del paquete java. En la segunda. En la primera forma. package java. 46 . las clases se guardarán en un paquete determinado que no tendrá nombre. Importación de Paquetes La importación de paquetes se realiza mediante la palabra clave import. Los paquetes anidados aparecerán como una jerarquía de directorios dentro de dicho sistema. se utilizará el nombre simple para acceder a cualquiera de las clases e interfaces que se encuentren en dicho paquete. En un archivo de programa solamente puede aparecer una declaración package y ésta deberá estar en la primera línea no comentada del archivo. Pueden tener dos formas: import packageName.*. donde los distintos nombres aparecerán separados por puntos entre ellos. Estas declaraciones únicamente tendrán que utilizar el nombre de la clase en vez de todo el nombre completo.*.image se tendrán que guardar entre el directorio java\awt\image. Por ejem plo. Declaración de Paquetes La forma general de la declaración package es la siguiente: package nombre. La única que puede aparecer antes de ésta es package. si se omite.ClassName. Por ejemplo.Paquetes y Directorios Todos los paquetes se han de convertir en un subdirectorio que tenga el mismo nombre que el sistema de archivos.

lang Contiene las clases con las que puede trabajar el lenguaje principal.sun. java. cadenas.util Contiene las clases que se pueden utilizar desde un punto de vista más natural. com.io Suministra un archivo independiente del dispositivo y servicios E/S. Trabaja con envolturas de objetos. java.java.swing Ofrece un grupo de clases para componentes. 47 . WWW y dispone de soporte HTML. así como también otros diseños abstractos que codifican las interfaces Comparator. La versión 2 de Java tiene cerca de setenta paquetes java.*.net Combina las clases que pueden trabajar con los programas de bajo nivel de Internet. java. Entre estos nos encontramos con las clases especializadas en los calendarios y en las colecciones. pero no nos ayudarán a exportarla.awt Contiene la mayoría de las clases dedicadas a los gráficos. java. Ahora comenzaremos a estudiar los más utilizados. Java.Paquetes Estándar de Java Los paquetes representan una forma de controlar la jerarquía de las clases.applet Sólo contiene una clase que puede trabajar con el lenguaje HTML que se incluye en los applet. java. multitarea y las correspondientes áreas relacionadas. controles de alto nivel y aquellas que mejoran el aspecto. Iterator y Observer.

La subjerarquía Number es un buen ejemplo de cómo funciona la herencia orientada a objeto y de cuándo se debe de aplicar. De todos los paquetes.lang es el más excepcional porque es el único con el que nunca habrá que importar los programas de forma explícita.lang. Long.lang contiene las siguientes clases envolventes: • • • • • • • • • Integer para el tipo primitivo int Long para el tipo primitivo long Byte para el tipo primitivo byte Short para el tipo primitivo short Float para el tipo primitivo float Double para el tipo primitivo double Carácter para el tipo primitivo char Bolean para el tipo primitivo boolean Void para el tipo primitivo void Las clases envolventes son clases que permiten agregar metodos de trabajo a los tipos primitivos de datos en Java. Short. El asterisco indica que se importarán todas las clases del paquete.lang contiene los siguientes tipos de clases. Float y Double tienen puntos en común. Number se declara como una clase abstracta (esto se suele hacer para concretar clases). Las clases Byte. Clases concretas pueden ser raíces locales de todas las subjerarquías. import java. Integer.*. que es la raíz de toda la jerarquía de la clase de Java. El paquete java. El paquete java. 48 .java.lang La mayoría de las clases de java.lang son una aplicación de la clase Object. por eso se creó esta superclase. • • • • • • 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. java. no se importarán las clases de los subpaquetes. la verdad es que no es algo imprescindible. Aunque disponer de una clase principal (superclase) es algo bastante normal. El compilador se encarga de agregar la siguiente línea al principio de los archivos fuentes. Sin embargo.

lectura y escritura. Filtros de corriente. lector o escritor. 49 . por ejemplo. del lector y del escritor que se encuentran dentro del java. java. Si se dirigen hacia nosotros. si es el código quien trabaja con estos objetos. Los lectores y escritores se parecen a las corrientes de entrada y salida. entonces diremos que se trata de un flujo de entrada. mientras que si sales de nuestro sistema. que es (a su vez) una extensión de Dictionary. diremos que se trata de un flujo de salida. Conversión a objetos de corrientes.java. Clases que mejoran la funcionalidad de la corriente.io contiene un conjunto relacionada con las operaciones E/S. Escritores y lectores de caracteres. el lector o escritor a una fuente o un origen de datos E/S.io se pueden agrupar en dos: • • Clases que vinculan una corriente. Aprovecha las herencias más que el paquete java. Los primeros los leemos y los segundos los escribimos.lang. su clasificación principal podría ser ésta: • • • • • Entrada y salida de Bytes.util Contiene más clases para datos abstractos (ADT) y trece interfaces. se representa como un flujo lineal y secuencial de bytes de entrada o de salida. Una corrientes (stream) es un concepto abstracto que se suele utilizar dentro de la programación E/S. la clase Propierties es una extensión (subclase) de la clase Hashtable. podemos cambiar los dispositivos de entrada y salida sin modificar el código E/S de la aplicación.io El paquete java. con una excepción. su unidad es un dato unicote. La principal ventaja de las corrientes es que no se apartan de los dispositivos de entrada y salida que hemos estado viendo. Las clases de la corriente. Clase RandomAccessFile.

Graphics 2D y PrintGraphics. o El subárbol Component que contiene a Container.awt se divide en una serie de grupos principales. o FlowLayout o BorderLayout o CardLayout o GridLayout o GridBagLayout y GridBagContraints o Instes Clases Gráficas o Graphics. o El subárbol MenuComponent. o GradientPaint y TexturePaint o RenderingHints Clases Geométricas o Point o Polygon o Dimension o Rectangle o Shape Clases para Eventos o Event o AWTEvent o AWTEventMulticaster o AWTQueue o ActiveEvent Clases Varias o MediaTraker o Toolkit o PrintJob o Cursor o ComponentOrientation • GraphicsDevice y • • • 50 . Clases especializadas en la gestión de capas. GraphicsEnvironment. GraphicsConfiguration.awt El paquete java. o Image o Color y SystemColor o Font o FontMetrics o AlphaComposite y Composite o BasicStroke y Stroke o GraphicsConfigTemplate. • • Dos dedicados a los componentes GUI.java.

swing.swing Los paquetes com.sun.event com.swing.sun.undo Define varios estilos para dibujar bordes Admite clases para los componentes del color Clases para los eventos propios de swing Admite clases para seleccionar archivos Clases para trabajar con módulos conectables Clases que admiten el uso de las tablas Clases que admiten componentes de texto.java.com.filechooser com.sun.sun.sun.java.java.swing.java.java.sun.swing.sun.swing se introdujeron con la versión 1.java.swing.tree com. incluyendo HTML y Rich Text Format(RTF) Clases que admiten componentes de árboles Clases que pueden trabajar con las implementación deshacer/rehacer 51 .java.sun. • • 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.border com.text.colorchooser com.swing.sun.swing.plaf.sun.java.2 de Java y suponen la segunda generación de los widget gráficos de Java.java.swing.* com.sun.* com.java.swing. se puede trabajar también con los siguientes: com.table com.java. Sus clases se pueden agrupar en las siguientes áreas.

pausa y reestablecimiento de la funcionalidad de los Applet.Applet representa el depósito principal don de se encuentran los métodos que se encargan de trabajar con los applet. • Carga de imágenes de alto nivel. son componentes distribuidos de software.net El paquete java.applet. PasswordAuthentication. java. La clase estándar apenas contiene algo más que lo necesario para trabajar con estos applet. más o menos.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.java. • Soporte de parámetros incluidos por los applet. Controladores para los tipos MIME (ContentHandler y URLStreamHandler). Muestra en pantalla el estado (showStatus(String)). java. Clases sin un conexión UDP/IP (DatagramPacket. Diversas clases de autentificación URL (Authenticator. La clase java. • Carga de audio de alto nivel y reproducción para applet y reproducciones. Sus clases se pueden agrupar con los siguientes puntos: • • • • • • Dirección de Internet (clases InetAddress y URL). DatagramSocket y MulticastSocket). llamados TCP/IP y UDP/IP. • Consultas de orígenes (getDocumentBase() y getCodeBase()). Clases orientadas a la conexión TCP/IP (varias clases de Socket). Los applet en Java.net ahorra al programador gran parte de las vicisitudes de la programación a nivel de Internet. cuando se compara con otros paquetes.net es uno del más importante de Java.applet. parece bastante escaso. Los métodos se pueden agrupar por categorías: • Iniciación. El paquete java. Solamente contiene una clase y tres interfaces. Clases relacionadas con la Web (varias clases URLConnection). URLDecoder y URLEncoder). Proporciona una serie de interfaces de alto nivel y protocolo (menos sofisticados) especializados en la comunicación. 52 .

MANUAL DE JAVA CAPITULO 7: MANEJO DE ARCHIVO EN JAVA 53 .

listas. Los archivos tienen como finalidad guardar datos de forma permanente. Con sus clases y métodos proporcionados por el paquete de clases de entrada y salida (java. etc. de acceso directo. Los archivos son dispositivos externos. 54 . Los flujos pueden estar abiertos o cerrados. etc. árboles.io) se pueden tratar archivos secuénciales. Que están en memoria interna y por lo tanto desaparecen al acabar la ejecución del programa. los datos almacenados están disponibles para que otra aplicación los utilice. o también denominado secuencia. en contraposición de los datos que se guardan en arreglos (arrays). conducen los datos entre el programa y los dispositivos externos.Introducción El manejo de archivos en Java se realiza mediante flujos (stream) o canal. archivos indexados. Una vez que acaba la aplicación.

in: Objeto entrada estándar. Entre el origen y el destino debe existir una conexión o canal. System. también conocida como pipe por la que circulan los datos. Abrir un archivo supone crear un objeto y quedar asociado con un flujo. por lo tanto se debe importar: Para todas las clases. Estos tres objetos se crean al inicio del programa y sirven para admitir secuencias de caracteres en modo texto.out: Objeto salida estándar. Al iniciar un programa en java. El paquete java. permite al sistema la salida de errores por pantalla.err: Objeto para salida estándar de errores. tenemos tres flujos que quedan abiertos de manera automática. siempre que se vaya a procesar un archivo se tienen que utilizar clases de este paquete. Así cuando se ejecuta.io agrupa el conjunto de clases para el manejo de entrada y salida. estos son: System. Se escribe la secuencia de caracteres en la pantalla. System.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). La apertura del archivo supone establecer una conexión del programa y el dispositivo que contiene el archivo. permite al programa la entrada de flujos de bytes desde el teclado. 55 . permite al programa la salida de datos por la pantalla.

InputStream FileInputStream ByteArrayInputStream PipeInputStream SequenceInputStream StringBuffereInputStream FilterInputStream OutputStream FileOutputStream ByteArrayOutputStream PipeOutputStream FilterOutputStream 56 . Los flujos de datos. Además InputStream es la clase base de todas las clases definidas para Stream de entrada. Ambas son clases abstractas que declaran métodos que deben de redefinirse en sus clases derivadas. Por ello Java declara dos clases que derivan directamente de la clase Object: InputStream y OutputStream. de caracteres. de bytes se pueden calificar en flujos de entrada (InputStream) y en flujos de salida (OutputStream).Jerarquía de Clases En el paquete java.io se encuentran todas las clases Stream necesarias para dar entrada/salida a nuestros programas. y OutputStream es la clase base para todas las clases de Stream de salida.

int org. int largo) throws IOException Escribe el array s desde la posición org y un máximo de largo bytes en el flujo 57 . FileInputStream (String nombre) throws FileNotFoundException Crea un objeto inicializado con el nombre de archivo que pasa como argumento FileInputStream (File nombre) throws FileNotFoundException Crea un objeto inicializado con el objeto File pasado como parámetro int read() throws IOException Lee un byte del flujo asociado. Los constructores de la clase permiten crear objetos asociados a un archivo. o bien con el archivo como un objeto File. se pueden escribir bytes en un flujo de salida asociado a un archivo. Algunos de los métodos más importantes de ésta clase. bolean sw) throws IOException Crea un objeto inicializado con el nombre de archivo que se pasa como argumento. Devuelve -1 si alcanza el fin de archivo o bien el número de bytes leídos Con la clase FileOutputStream. A continuación presento algunos de los métodos más utilizados en esta clase. En el caso de qye sw = trae los bytes escritos se añaden al final FileOutputStream(File nombre) throws IOException Crea un objeto inicializado con el objeto File pasado como argumento void write(byte a) throws IOException Escribe el byte a en el flujo asociado void write(byte [] a) throws IOException Escribe el array de bytes a en el flujo asociado void write(byte [] a. int largo) throws IOException Lee una secuencia de bytes del flujo y se almacena en el array s desde la posición org y un máximo de largo bytes. int org.FileInputStream y FileOutputStream La clase FileInputStream se utiliza para leer bytes desde un archivo. cabe destacar que todos son públicos y que es importante tener en cuenta el tipo de excepción que pueden lanzar. devuelve -1 si alcanza el fin de archive. FileOutputStream(String nombre) throws IOException Crea un objeto inicializado con el nombre de archivo que se pasa como parámetro FileOutputStream(String nombre. o bien el número de bytes leídos int read(byte [] s. Devuelve -1 si alcanza el fin de archivo int read(byte [] s) throws IOException Lee una secuencia de bytes del flujo y se almacena en el array s. Los constructores inicializan objetos con el con el nombre del archivo.

a leerlo con la case derivada de InputStream Se crea un objeto FileInputStream. con el siguiente contenido.Ejemplo Introductorio FileInputStream Vamos a leer un archivo con la clase derivada de InputStream y luego utilizaremos una clase derivada de Read y Writer. La salida de este programa sería la siguiente. con la cual se facilita de manera considerada el manejo de archivos. Ahora procederemos FileInputStream. Leer un archivo: Inicialmente vamos a crear un archivo de texto. de nombre datos. se van evaluando los caracteres que se van sacando desde el archivo hasta que el numero del caracter sea distinto de -1. posteriormente.txt. con el nombre del archivo. 58 .

59 .

utilizaremos la clase derivada de OutputStream FileOutputStream. al cual se le entrega como parámetro de constructor el nombre del archivo en donde se va a escribir. Se crea un objeto de la clase FileOutputStream.txt. la información ingresada esta almacenada en el archivo Temporal. 60 . El ingreso de información es el siguiente. posteriormente. se van agregando al archivo los datos ingresados por el usuario hasta que este presione F6. tecla que posee como número el -1. Al revisar el archivo.Ejemplo Introductorio FileOutputStream A continuación.

El código fuente es el siguiente. 61 . Se crea inicialmente un objeto de la clase FileReader. el cual se utiliza para entregarlo como argumento al BufferedReader. La salida.Ejemplo Introductorio FileReader Utilizando el siguiente archivo de texto para leer la información que contiene. seguido. que es el lector de Buffer. liego de leer el archivo es la siguiente. se leen las líneas del archivo entregado y las presenta en la pantalla concatenadas con el caracter de fin de línea “\n”.

txt con el objeto FileWriter que deriva de la clase Writer.txt”. El ingreso de información es el siguiente. lo utiliza PrintWriter.txt queda de la siguiente manera. se crea un objeto BufferedWriter. este flujo de salida. que es el objeto que nos permite enviar los caracteres al archivo.Ejemplo Introductorio FileWriter Vamos escribir información en un archivo de texto denominado Temporal. El archivo Temporal. después. Se crea un objeto de BufferedReader para que el usuario pueda ingresar la información que desea enviar al archivo. posteriormente. que es el nombre del archivo al cual le vamos a enviar lo que el usuario ingrese. que hace referencia al flujo de salida y que utiliza a FileWriter como parámetro de constructor. se crea un objeto de la clase FileWriter. con parámetro de constructor “Temporal. 62 .

63 .

MANUAL DE JAVA CAPITULO 8: APPLETS 64 .

Introducción a los Applets de Java
Para decir que es un applet en realidad, utilizaré la definición de Patrick Naughton, quien indica que… “un Applet es una pequeña aplicación accesible en un servidor Internet, que se trasporta por al red, se instala automáticamente y se ejecuta in situ como parte de un documento Web”. Un applet, se carga y se ejecuta dentro de un navegador Web, más adelante veremos como se debe escribir este tag.

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: • • • • Se crea una instancia de la clase que controla el Applet. El Applet se inicializa. El Applet comienza a ejecutarse. El Applet comienza a recibir llamadas de los métodos primarios de un Applet. o init() (inicializar) o star() (empezar) o paint() (pintar)

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: Las applets no tienen un método main() con el que comience la ejecución. El papel central de su ejecución lo asumen otros métodos que se verán posteriormente. Todas las applets derivan de la clase java.applet.Applet. La Figura anterior muestra la jerarquía de clases de la que deriva la clase Applet. Las applets deben

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. Las applets disponen de métodos relacionados con la obtención de información, como por ejemplo: getAppletInfo(), getAppletContext(), getParameterInfo(), getParameter(), getCodeBase(), getDocumentBase(), e isActive(). El método showStatus() se utiliza para mostrar información en la barra de estado del browser. Existen otros métodos relacionados con imágenes y sonido: getImage(), getAudioClip(), play(), etc. Métodos de un Applet Los métodos propios de la clase 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

es la clase derivada. Se llama cuando el applet desaparece de la pantalla. La clase Applet simplemente dibuja un rectángulo gris en el área. destroy() El método destroy() se llama cuando ya no se va a utilizar más el applet. cuando se cierra el navegador. de forma que el programador puede paralizar los threads que no resulten necesarios respecto de un applet no visible. cuando se necesita que sean liberados todos los recursos dispuestos por el applet. Cada vez que la zona del applet es cubierta por otra ventana. paint( Graphics g ) Es la función llamada cada vez que el área de dibujo del applet necesita ser refrescada. pero en realidad la llamada se realiza al método update(). Esto es. el sistema llama automáticamente a este método. obviamente. pero no a start(). cuando abandona la página en que está insertado. etc. Es decir. 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(). el sistema llamará al método init().área de visión). cuyo comportamiento establecido en la clase 68 . Los applet multithread deberían utilizar destroy() para detener los threads que quedasen activos. La clase Applet tampoco hace nada en este método. aunque. Naturalmente. las clases derivadas pueden sustituir esta funcionalidad para sus propósitos especiales. por ejemplo. pasando como argumento un objeto de tipo Graphics que delimita la zona a ser pintada. de cualquier forma. que sí será llamado cuando restauremos el navegador a un tamaño que permita ver el applet. stop() stop() es la llamada para detener la ejecución del applet. se desplaza el applet fuera de la visión o el applet cambia de posición debido a un redimensionamiento del navegador. que debería ser sobrecargado por las clases derivadas para detener la animación. en realidad se pasa una referencia al contexto gráfico en uso. el sonido. y que representa la ventana del applet en la página Web. por ejemplo. Esta funcionalidad es suficiente para la mayoría de los casos. La clase Applet no hace nada en este método. La clase Applet simplemente limpia el área y llama al método paint(). Las clases derivadas deberían sobrecargarlo para hacer una limpieza final. update( Graphics g ) Esta es la función que realmente se llama cuando se necesita una actualización de la pantalla. y luego recuperar su actividad mediante el método start(). la que debería sobrecargar este método para representar algo inteligente en la pantalla. en las situaciones detalladas anteriormente que dañan la zona de exposición del applet. Esta función es llamada cuando el navegador no incluye en su campo de visión al applet. el sistema llama al método paint(). imaginemos que cargamos un applet en un navegador minimizado.

*.out.println("Pintando"). Pero hay que tener cierto cuidado.cyan). } public void stop(){ System. porque AWT posee cierta inteligencia (combinación casi siempre nefasta). Por tanto. podríamos percibir un flick de cambio de colores nada agradable. g.setColor(Color.out. public class Appletuno extends Applet{ String texto. } public void destroy(){ System. Pudiera parecer así que se trata de un método de efecto neutro.println("Comenzando"). para evitar el mismo desagradable efecto. public void init(){ texto= “Primera Frase en un Applet!!!”. La última solución pasaría por usar el mismo método setBackground( Color ).Applet. } public void start(){ System. para que llame únicamente a paint().println("Preparando la destrucción"). pero si la función paint() cambiara el color del fondo. g.println("Parando"). sobrecargando el método update().out. } public void paint(Graphics g){ System.drawString(texto.blue). } } 69 .25).java import java. 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(). AWT ignorará las llamadas a update() que estime oportuno. de eliminar este efecto de limpia primero.awt. tras haber rellenado la zona del applet con su color de fondo por defecto. import java. setBackground(Color.15. A continuación ejecutaremos nuestro primer Applet: Archivo: Appletuno. en el método init() para así evitar el efecto visual sin tener que sobrecargar el método update(). de forma que si se llama a update() mediante repaint() con una frecuencia muy corta. Estas son las mismas razones que aconsejan usar el método resize() inserto en init(). habrá que cuidarse por lo común. pues considera a esta función como un bien escaso.out. repaint Llamando a este método se podrá forzar la actualización de un applet.applet. la llamada a update().Component es llamar al método paint().

Luego que escribimos nuestro código. escribimos una página HTML simple y lo guardamos en el mismo directorio donde guardamos el Appletuno. en un notepad. <html> <body> <applet code="Appletuno.class" width=300 height=100> </applet> </body> </HTML> 70 .Como podemos apreciar.java.java.class" [CODEBASE="unURL"] [NAME="unName"] WIDTH="wpixels" HEIGHT="hpixels" [ALT="TextoAlternativo"]> [texto alternativo para browsers que reconocen el tag <applet> pero no pueden ejecutar el applet] [<PARAM NAME="MyName1" VALUE="valueOfMyName1">] [<PARAM NAME="MyName2" VALUE="valueOfMyName2">] </APPLET> Para nuestro archivo Appletuno. no es necesario escribir todos los métodos de un applet. basta con escribir los que necesitamos para ejecutar nuestro applet. pasaré a explicar como se realiza el proceso de carga del applet. Escribimos el Tag <APPLET> dentro de una página HTML Esto lo realizamos de la siguiente manera. los applet son pequeñas aplicaciones que se ejecutan dentro de un navegador Web. realizamos los siguientes pasos para ejecutarlo 1. el tag que acompaña al applet es <APPLET> y se debe especificar un applet de la siguiente manera: <APPLET CODE="miApplet. Como sabemos. Escribimos el código del applet (ya realizado) 2.

nuestro applet aparecerá de la siguiente manera: 71 . el appletviewer. Los mensajes que aparecen abajo. a. Para poder ver un Applet. podemos hacerlo de 2 manera. lo más importante de todo. Bueno. Si se dan cuenta. b. uno es ejecutándolo con el visor de applet de la JVM. Procedemos a abrir un entorno de comando y nos dirigimos al directorio donde esta el applet y procedemos a compilarlo con “javac”. el appletviewer carga el archivo HTML que contiene el applet. Esto se hace de la siguiente manera. demostrando al momento que se ejecutan.3. A continuación compilaremos el applet. son los de los métodos.

} public void start(){ System. import java.java import java. ahora esa frase va a estar como parámetro en una página HTML dentro del tag <applet> </applet>.awt. public void init(){ texto= getParameter("variable").html Archivo prueba.println("Comenzando").Al cerrar nuestro Applet.html <html> <body> <applet code="Appletuno. setBackground(Color.out. nuestro applet presenta una frase. Primero hacemos la modificación de prueba.class" width=300 height=100> <param name=variable value="Parametro traspasado desde mi HTML"> </applet> </body> </HTML> a continuación hacemos la modificación del applet Appletuno. public class Appletuno extends Applet{ String texto.*.java Archivo Appletuno. A continuación. veremos que se escriben los mensajes de los métodos stop() y destroy().cyan). } public void stop(){ 72 . utilizaremos un ejemplo de traspaso de parámetros de una página HTML a nuestro applet. Como vimos anteriormente.Applet.applet.

73 .println("Pintando"). podemos comenzar a echar a volar la imaginación de las cosas que podríamos hacer con esta capacidad. g. } public void paint(Graphics g){ System. g. } } Procedemos a compilar nuestro Appletuno.println("Parando").} public void destroy(){ System.15.println("Preparando la destrucción").setColor(Color.blue).out.drawString(texto.java y a ejecutarlo con appletvewer (visor de Applet) System.out. El resultado sería el siguiente Ya que aprendimos a realizar traspasos de parámetros.25).out.

MANUAL DE JAVA CAPITULO 9: INTERFASES GRÁFICAS DE USUARIO EN JAVA 74 .

75 .

La interfase de usuario es el aspecto más importante de cualquier aplicación. El AWT proporciona un conjunto de herramientas para la construcción de interfaces gráficas que tienen una apariencia y se comportan de forma semejante en todas las plataformas en que se ejecute. puede no visualizarse correctamente en otra diferente. 76 . el AWT también es independiente de la plataforma en que se ejecute. Debido a que el lenguaje de programación Java es independiente de la plataforma en que se ejecuten sus aplicaciones. El AWT fue diseñado pensando en que el programador no tuviese que preocuparse de detalles como controlar el movimiento del ratón o leer el teclado. el sistema operativo transmite información desde el ratón y el teclado como dispositivos de entrada al programa. Este es un punto fuerte del AWT. El AWT constituye una librería de clases orientada a objeto para cubrir estos recursos y servicios de bajo nivel. Java proporciona los elementos básicos para construir decentes interfaces de usuario a través del AWT. ni tampoco atender a detalles como la escritura en pantalla. Los elementos de interfase proporcionados por el AWT están implementados utilizando toolkits nativos de las plataformas. pero también tiene la desventaja de que una interfase gráfica diseñada para una plataforma. Al nivel más bajo. Una aplicación sin un interfaz fácil. Las interfaces de usuario pueden adoptar muchas formas. preservando una apariencia semejante a todas las aplicaciones que se creen para esa plataforma. impide que los usuarios saquen el máximo rendimiento del programa. que van desde la simple línea de comandos hasta las interfaces gráficas que proporcionan las aplicaciones más modernas.Introducción La interfase de usuario es la parte del programa que permite a éste interactuar con el usuario.

sino que están situados a través de una disposición controlada (Layouts) • El común denominador de más bajo nivel se acerca al teclado. en vez de tener un tamaño fijo • Es bastante dependiente de la máquina en que se ejecuta la aplicación (no puede asumir que un diálogo tendrá el mismo tamaño en cada máquina) • Carece de un formato de recursos.) • La arquitectura de la aplicación es dependiente del entorno de ventanas. etc. ni llamadas a X. No se puede separar el código de lo que es propiamente interfase 77 . que son los controles básicos • No se usan posiciones fijas de los Compone ntes.Estructura del AWT La estructura de la versión actual del AWT podemos resumirla en los puntos que exponemos a continuación: • Los Contenedores contienen Componentes. ratón y manejo de eventos • Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute la aplicación (no hay áreas cliente. ni hWnds.

El AWT proporciona cuatro clases de Contenedores: • • • • Window Frame Dialog Panel Además de estos Contenedores. cambiar la forma del cursor o modificar el icono de la aplicación. Los Componentes permiten al usuario interactuar con la aplicación y proporcionar información desde el programa al usuario sobre el estado del programa. sustracción. los Componentes. recuperación. los Contenedores son en sí mismos Componentes y como tales pueden ser situados dentro de otros Contenedores. de añadir a la clase Component la funcionalidad de adición. etiquetas. además. También contienen el código necesario para el control de eventos. listas. es un subtipo de la clase Panel y puede tener Componentes. Container es una clase abstracta derivada de Component. 78 . Los Contenedores contienen y organizan la situación de los Componentes. En el AWT. 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. en esencia.Conenedores Una interfase gráfica está construida en base a elementos gráficos básicos. Típicos ejemplos de estos Componentes son los botones. todos los Componentes de la interfase de usuario son instancias de la clase Component o uno de sus subtipos. sino agrupados dentro de Contenedores. Los Componentes no se encuentran aislados. barras de desplazamiento. que representa a cualquier componente que pueda contener otros componentes. control y organización de otros componentes. todos los Contenedores son instancias de la clase Container o uno de sus subtipos. Se trata. cajas de selección o campos de texto. la clase Applet también es un Contenedor. comenzando con un Contenedor en la raíz del árbol y expandiéndolo en sus ramas. En el AWT.

Una instancia de esta clase no tiene ni título ni borde. Una instancia de esta clase es mucho más aparente y más semejante a lo que nosotros entendemos por ventana. Una instancia de la clase Dialog no puede existir sin una instancia asociada de la clase Frame. Una instancia de la clase Panel. Panel Es un Contenedor genérico de Componentes. simplemente proporciona un Contenedor al que ir añadiendo Componentes. Una instancia de la clase Window no puede estar enlazada o embebida en otro Contenedor. Frame Es una superficie de pantalla de alto nivel (una ventana) con borde y título. 79 . Dialog Es una superficie de pantalla de alto nivel (una ventana) con borde y título.Window Es una superficie de pantalla de alto nivel (una ventana). Una instancia de la clase Frame puede tener una barra de menú.

el programador debe crear en primer lugar una instancia de la clase Window o de la clase Frame. 80 . se fija en la llamada al constructor. el programador puede ir añadiendo Componentes directamente a la instancia que se crea de la clase Applet. Cuando lo que se construye es un applet. En el siguiente ejemplo se crea un Frame vacío. el programador debe crear un Contenedor. ya existe un Frame (la ventana del navegador). Debido a que la clase Applet está derivada de la clase Panel. El la ventana resultante del Frame ejecutado en el código anterior es la siguiente. Cuando se construye una aplicación.Crear un Contenedor Antes de poder incorporar Componentes a la interfase de usuario que se desea implementar. se redimensiona y posteriormente se muestra. que corresponderá al título de la ventana. Un Frame inicialmente está invisible. para poder verlo es necesario invocar al método show(): Nótese que se crea un nuevo objeto de la clase Frame. El título del Frame.

El código siguiente muestra esta circunstancia: El applet cargado es el siguiente. con nombre Ejemplo 2. El resultado de ambos ejemplos es idéntico a efectos de apariencia en pantalla: Se crea un objeto de la clase Frame. este se agrega al Frame y el Frame se procede a mostrar. luego. utilizando la herencia de la clase. 81 . 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(). Derivando la nueva clase directamente de la clase Applet en vez de Panel. se procede a crear un objeto Ejemplo2. nuestro ejemplo puede ahora ejecutarse tanto como una aplicación solitaria como dentro de una página HTML en un navegador.En el código de ejemplo que sigue. que en el fondo es un Panel.

pueden reemplazar al objeto Frame. 82 . y en algunos casos incluso un objeto Dialog. Son Contenedores válidos y los Componentes se añaden en ellos del mismo modo que se haría sobre un Frame.Un objeto Window.

Los Componentes se añaden al Contenedor invocando al método add() del Contenedor.Añadir Componentes a un Contenedor Para que la interfase sea útil. no debe estar compuesta solamente por Contenedores. En el código siguiente. 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. incorporamos dos botones al código del último ejemplo. al iniciarse la ejecución se crean los botones. ya que el método init() es llamado tanto por el navegador como por el método main(): La ventana siguiente es la resultante de la ejecución del Applet Ejemplo4. De todos modos. La creación se realiza en el método init() porque éste siempre es llamado automáticamente al inicializarse el applet. 83 . éstos deben tener Componentes en su interior.

en la actual versión. su repintado cuando sea cubierto por otra ventana. etc. deberemos prever el redimensionamiento del applet. de forma transparente para nosotros.Layouts Los Layout Managers o manejadores de composición. codificamos a mano tal disposición. de todas esas cuitas de formatos. Sigamos imaginando.. además de todas las cuestiones relacionadas con un posible cambio de plataforma (uno nunca sabe a donde van a ir a parar los propios hijos. pues estos gestores son instancias de las distintas clases derivadas de Layout Manager y que se utilizan en el applet que genera la figura siguiente. o los Applets). especifican la apariencia que tendrán los Componentes a la hora de colocarlos sobre un Contenedor. Java dispone de varios. es decir. 84 . tal como se muestra en la imagen: ¿Por qué Java proporciona estos esquemas predefinidos de disposición de componentes? La razón es simple: imaginemos que deseamos agrupar objetos de distinto tamaño en celdas de una rejilla virtual: si confiados en nuestro conocimiento de un sistema gráfico determinado. que un hábil equipo de desarrollo ha previsto las disposiciones gráficas más usadas y ha creado un gestor para cada una de tales configuraciones. Bien. ayudan a adaptar los diversos Componentes que se desean incorporar a un Panel. en traducción literal. donde se muestran los diferentes tipos de Layouts que proporciona el AWT. que se ocupará. ahora.

es cambiar el nombre del archivo class en el parámetro code. explicaré el uso de cada uno de los Layout del Layout Manager. Código de página ejemplo. NOTA: Los Applets que se utilicen en los ejemplos. serán cargados con la página HTML ejemplo.En el applet que genera la figura siguiente.html A continuación. en donde el único cambio que se le ha hecho para cada uno de los ejemplos.html. se utilizan los diferentes tipos de Layouts que proporciona el AWT y Swing. 85 .

de izquierda a derecha. 86 . y se puede seleccionar el espaciado entre cada Componente La ventana del Applet del código anterior es la siguiente. La cadena es horizontal. Los Componentes añadidos a un Panel con FlowLayout se encadenan en forma de lista.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.

GridLayout 87 . Sur. El Norte ocupa la parte superior del panel. una vez que se hayan rellenado las otras cuatro partes. Oeste y Centro. La composición utiliza cinco zonas para colocar los Componentes sobre ellas: Norte. Vista del Applet. Centro representa el resto que queda. el Este ocupa el lado derecho. Es el layout o composición que se utilizan por defecto Frame y Dialog. Este.BorderLayout La composición BorderLayout (de borde) proporciona un esquema más complejo de colocación de los Componentes en un panel. Sur la zona inferior y Oeste el lado izquierdo.

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. Vista del Applet. 88 .

GridBagLayout Es igual que la composición de GridLayout. con la diferencia que los Componentes no necesitan tener el mismo tamaño. 89 . Es quizá el layout más sofisticado y versátil de los que actualmente soporta AWT.

se utiliza una modificación del Layout GridBagLayout en donde podemos ubicar objeto a nuestra manera en un Frame. A continuación. pero nosotros podemos realizar algunos cambios y creando unos métodos. es un poco complicada la utilización del GridBagLayout. podemos hacer que construir un marco con GridBagLayout se vuelva un poco más fácil.Vista del Applet. Como se pudo apreciar. 90 .

dentro del cual se crea un gridBagConstraint para ubicar los componentes ingresados. las posiciones de estos componentes.Nótese la inclusión del método addComponent. 91 . quedan como parámetros del método addComponent. Vista del Applet. éste método nos permite modificar el Layout que se utilizará en el Applet.

Este layout suele ir asociado con botones de lista (Choice).CardLayout Este es el tipo de composición que se utiliza cuando se necesita una zona de la ventana que permita colocar distintos Componentes en esa misma zona. 92 . de tal modo que cada selección determina el panel (grupo de componentes) que se presentarán.

Vista del Applet con la segunda selección del Cuadro de Selección utilizando el segundo card. 93 .Vista del Applet con la primera selección del Cuadro de Selección utilizando el primer card.

fundamentalmente en el momento en que parezca que ninguno de los Layouts que hemos visto satisface nuestras exigencias. que es el más flexible. lo cual puede no resultar sencillo. así que en lo posible se deben utilizar los métodos de colocación de componentes que proporciona AWT. 94 . deberíamos volver a comprobar que el GridBagLayout.Crear un Layout Propio Se puede crear un Layout personalizado en base a la interfase LayoutManager. Creación de clase MiLayout que implementa la i nterfaz LayoutManager. de verdad no cumple nuestros requerimientos. Hay que redefinir los cinco métodos que utiliza este interfase.

95 .Continuación.

Vista del Applet 96 .Código del Applet que utiliza el Layout creado anteriormente.

Etiqueta (Label) Se utilizan para dibujar una cadena de texto en una posición y con una alineación (dentro del componente). etc. Lo primero que hacemos es crearla y luego la posicionamos dentro de la applet. etiquetas. Muchos de estos controles comparten métodos y eventos.LEFT Label. Creación: ALINEACIÓN DESCRIPCIÓN Izquierda. Derecha. listas.Controles y Componentes La finalidad de añadir controles como botones.CENTER 97 . Centrado.RIGHT Label. cajas de texto. Label. 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.

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.Campos de Texto (TextField) TextField implementa un área de entrada de texto de una sola línea. Creación: Guardar Texto: (valido para etiquetas) Mostrar Texto: (valido para etiquetas) 98 .

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. y los métodos getState y setState para obtener y mostrar el estado. (por defecto están sin seleccionar). los cuales pueden estar varios seleccionados a la vez. que admite dos valores True si esta seleccionado y False si no esta seleccionado. con el segundo se crea sin indicar el estado.Cuadros de Chequeo (Checkbox) Las casillas de verificación son botones de opciones. El texto esta situado a la derecha. Creación: Tenemos 2 maneras para crearlos. El primero si se quiere establecer un valor inicial. Creación de Grupo: Creación de Elementos: 99 . Estados: Necesitamos ahora cambiar los Checkbox a botones de opción. La clase Checkbox se utiliza para crear el control. para ello.

En este control aparecen unas barras de desplazamiento verticales automáticamente. el orden de sus elementos es según han sido añadidos. Este tipo de lista puede admite más de una selección. Los miembros son los mismos que en el control anterior solo cambia el modo de construirlos.Lista (List) Mediante la clase List crearemos el objeto. Creación: Agregar Ítem: Seleccionar Ítem: Obtener el índice seleccionado: Obtener el valor seleccionado: 100 .

es decir. Como valores en la construcción toma un String inicial. Una vez creado hay que asociarlo al método action para realizar la operación.Botón (Button) Son utilizados para ejecutar las acciones. Además del método constructor existen otros de gran importancia. TextArea es una caja de texto multilínea. Creación: Insertar Texto: Al Final: Posición Aleatorio: Reemplazar: 101 . El texto que aparece en los botones siempre va en el centro. La clase que se utiliza es Button. Creación: Áreas de Texto (TextArea) A veces no es suficiente una entrada de texto de una única línea. seguido del número de columnas y filas que se desean visualizar. admite varias líneas.

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:

Obtener el índice seleccionado:

Obtener el valor seleccionado:

102

Barra de Desplazamiento (Scrollbar)

Se utiliza para seleccionar valores continuos entre un mínimo y un máximo especificado. Las barras pueden tener una orientación vertical u horizontal. Los métodos asociados sirven para obtener y establecer la posición de la barra y su valor mínimo y máximo. Para trabajar con las barras se utilizan los eventos que van asociadas a ellas junto con el método handleEvent.
Creación:

CONSTANTE Scrollbar.VERTICAL Scrollbar.HORIZONTAL

DESCRIPCIÓN
Orientación vertical Orientación horizontal

Valores Mínimos y Máximos:

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

Los menús de tipo ítem también pueden comportarse como Popup con lo que podremos anidar submenús creando una jerarquía. los cuales están compuestos de menús ítem. 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. Lo primero es crear la barra de menús mediante la clase MenuBar. También debemos añadir la barra de menú a la ventana.Barra de Menú (MenuBar) Cada ventana de nivel superior puede tener una barra de menús. Crear Barra de Menú: Crear Menú Popup: Crear Menú Ítem: Añadir Menú Ítem a Menú Popup: Añadir Menú Popup a la Barra de Menú: Añadir la Barra de Menú a la Ventana: 105 . Esta barra esta compuesta por menús Popup.

Es muy útil cuando el control que implementamos no responde a eventos.Cuadro de Dibujos (Canvas) Además de los componentes estándar. tipo de letra. La clase Canvas no responde a los eventos directamente si no que es el programador quien debe definir una subclase de Canvas a la que se envían todos los eventos y.. otra clase donde crearemos el objeto de la subclase e implementaremos todo el código del programa. que nos permite implementar cualquier otro tipo de control en su interior y capturar sus eventos a través de la canva. 106 . Como por ejemplo los métodos para establecer color. etc. hay un componente (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.

contiene la información que va a afectar a todas las operaciones gráficas. un programa necesita un contexto gráfico válido. e incluso dispone de información sobre el eventual destino de las operaciones gráficas (pantalla o imagen). Para poder pintar. Java proporciona la clase Graphics. es esencial el entendimiento de la clase Graphics. la clase Graphics proporciona métodos que permiten el dibujo de primitivas. así que debemos crear un componente y pasarlo al programa como un argumento a los métodos paint() o update(). la fuente de caracteres. Esta clase proporciona el entorno de trabajo para cualquier operación gráfica que se realice dentro del AWT.Opciones Gráficas de Dibujo A continuación se presentan los diferentes métodos para construir figuras en contenedores o componentes trabajen con la clase Graphics g. etc. el AWT repinta solamente aquellos Componentes que necesitan ser repintados. También hay clases para la manipulación de imágenes. Para ello. haremos cosas más interesantes que mostrar texto. antes de adentrarse en el dibujo de cualquier cosa en Java. paint() y update(). representado por una instancia de la clase Graphics. Por otro lado. Ahora. el AWT repinta solamente la porción del Componente que estaba oculta 107 . cómo lanzarlos y los fundamentos básicos de la presentación de información sobre ellos. la localización y dimensiones del rectángulo en que se va a pintar. es decir. pero también tiene muchos otros métodos de dibujo. no se puede instanciar directamente. Juega dos importantes papeles: por un lado. En capítulos anteriores ya se ha mostrado cómo escribir Applets. pues. doble-buffering. figuras y la manipulación de fonts de caracteres y colores. que permite mostrar texto a través del método drawString(). El AWT. Para cualquier programador. Los dos métodos anteriores. ya que cualquier página HTML puede mostrar texto. incluyendo los colores de fondo y texto. si un Componente estaba tapado y se destapa. para reducir el tiempo que necesitan estos métodos para realizar el repintado en pantalla de gráficos. junto con el método repaint() son los que están involucrados en la presentación de gráficos en pantalla. como esta clase es abstracta. tiene dos axiomas: • • Primero. es el contexto gráfico. Pero. bien porque estuviesen cubiertos por otra ventana o porque se pida su repintado directamente Segundo.

y. su ámbito de aplicación se restringe a los componentes que se utilicen en los métodos paint() y update().ancho.alto ) drawArc( x.alto.anchoArco.y.altoArco ) fillRoundRect( x. tal como muestra la figura: Los pixels de la pantalla son pues: posición 0 + ancho de la pantalla .y. Como estos métodos funcionan solamente cuando son invocados por una instancia válida de la clase Graphics.ancho.ancho.ancho. Vamos a presentar métodos para dibujar varias figuras geométricas. En los textos.alto ) fillRect( x.y2 ) drawRect( x.boolean elevado ) fill3DRect( x.ancho.alto.alto.anguloInicio.altoArco ) draw3DRect( x.alto.anguloArco ) drawPolygon( int[] puntosX.y.ancho.alto ) drawRoundRect( x.y.alto.ancho.x2.y.y.y. drawLine( x1.y.alto ) clearRect( x.anguloArco ) fillArc( x.La pantalla en Java se incrementa de izquierda a derecha y de arriba hacia abajo.anchoArco.y1. 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.ancho.boolean elevado ) drawOval( x.ancho. el punto de inserción se encuentra en la línea base de la primera letra.numPuntos ) 108 .y.1.numPuntos ) fillPolygon( int[] puntosX.anguloInicio.int[] puntosY[].ancho.alto ) fillOval( x.alto.ancho.int[] puntosY[].y.

x.offset.longitud.longitud.yDest ) 109 .y ) drawBytes( byte data[].offset.y ) drawChars( char data[].x.x.drawString( string s.y ) copyArea( xSrc.ancho.xDest.alto.ySrc.

En lugar de que el programa activamente recoja todos los eventos generados por el usuario. una acción particular del usuario. El paquete que contiene las clases para manipular los eventos están contenida en la AWT. 110 . es decir define clases que se encargan de manejar la interactividad de las aplicaciones con el usuario. Un evento describe. con suficiente detalle. todas las acciones que pueda realizar el usuario caen dentro de un gran saco que son los eventos.awt.Eventos Java presenta una arquitectura para los eventos que funciona orientada al evento. dentro de java. Dentro del AWT. el sistema Java avisa al programa cuando se produce un evento interesante.event.

when . este objeto arg es un objeto String que contiene la etiqueta de texto del botón evt . Intenta capturar las características fundamentales de todos los eventos que genera el usuario. clickCount .).El número de clicks de ratón consecutivos. es la tecla que se ha pulsado.Instante en que se ha producido el evento modifiers . Alt. y . Ctrl. 111 .La combinación aritmética del estado en que se encuentran las teclas modificadoras Mays. Los datos miembro de la clase Event son los que se indican a continuación: id . Su valor será el valor Unicode del carácter que representa la tecla. F2. los referidos a acciones del usuario respecto de componentes (elección de un menú.Es un argumento dependiente del evento. sin embargo. Para objetos Button.Las coordenadas en donde se ha producido el evento relativas al Componente que actualmente está procesando ese evento. pulsaciones de teclas. Sólo tiene importancia en los eventos MOUSE_DOWN arg . La clase Event es el jugador principal en el juego de los eventos. creación/movimiento/destrucción de partes gráficas y.El siguiente evento en una lista encadenada de eventos Una instancia de la clase Event será creada por el sistema Java cada vez que se genere un evento. por último.La Clase E vent Un contenedor soltado en un entorno gráfico se convierte en rápido receptor de eventos de todo tipo. F1.Para eventos de teclado. pulsación de un botón. etc. que un programa cree y envíe eventos a los Componentes a través de su método postEvent(). etc. Es posible. FIN. Otros valores que puede tomas son los de las teclas especiales como INICIO. singularmente de los relacionados con el movimiento del ratón. El origen se toma en la esquina superior izquierda del Componente key .El tipo de evento que se ha producido target .Componente sobre el que se ha producido el evento x.

• • • • • • MOUSE_DOWN MOUSE_UP MOUSE_MOVE MOUSE_ENTER MOUSE_EXIT MOUSE_DRAG Eventos de Barras Son los eventos generados como respuesta a la manipulación de barras de desplazamiento (scrollbars). • • • • • SCROLL_LINE_UP SCROLL_LINE_DOWN SCROLL_PAGE_UP SCROLL_PAGE_DOWN SCROLL_ABSOLUTE 112 . • • • • • 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.Los eventos se catalogan por su naturaleza. • • • • 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. 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. que se indicará en el miembro id de su estructura.

• • • • • ACTION_EVENT LOAD_FILE SAVE_FILE GOT_FOCUS LOST_FOCUS Ahora para comprender un poco más lo anteriormente nombrado vamos a graficar lo siguiente: Evento public bolean handleEvent( Event evt) evt.x evt. podemos tomar acciones para responderle al usuario o manipular nuestro sistema. y si esto coincide. denominado handleEvent. podemos obtener el miembro de la clase del objeto evt. y que recibe como parámetro el objeto evt de la clase Event.Eventos de Lista Son los eventos generados al seleccionar elementos de una lista. es que al producirse un evento.<miembros de la clase> == evt. como por ejemplo la posición x e y del evento.KEY_PRESS. con evt.id Lo que represento acá en este gráfico.<miembros de la clase> ó evt. • • LIST_SELECT LIST_DESELECT Eventos Varios Son los eventos generados en función de diversas acciones. Posteriormente. podemos hacer que todos se vayan al mismo método. por ejemplo si una tecla fue presionada. 113 .id == evt.y y si deseamos comparar el id del evento con los presentados anteriormente. nos vamos consultar si evt. Vamos a desarrollar una aplicación simple para entender esta forma de generar eventos.

114 .Necesitaremos JCreator para generar la codificación respectiva. Inicialmente crearemos un nuevo archivo en JCreator. Y objetos que van a provocar la interactividad. Vamos a generar un frame que va a tener TextFields que van a representar los miembros de la clase Event. El archivo se denominará VisorEventos Damos “Finish” y comenzamos.

Deberá lucir más o menos así: 115 . Comenzamos por inicializar los objetos que van a estar en la pantalla. 2. 4. Luego generamos la estructura que tendrá nuestro archivo. 3. 1.awt con todas sus clases.Vamos inicialmente a importar el paquete java. Clase VisorEventos que se extiende de Frame Método main Constructor de VisorEventos Método handleEvent(Event evt) Nuestro archivo debería lucir más o menos así: Ahora vamos a comenzar a generar la estructura externa que va a presentar nuestro Frame.

Label que se encargará de ir colocando los nombres a la izquierda 2. 8. 2. Como lucirá todo esto: 116 . vamos adentrarnos en el constructor VisorEventos. 3. Vamos a crear un Layout para el Frame (BorderLayout) y se lo entregamos al Frame. En el visor de eventos vamos a: 1. 7. previamente configurados para lo que los necesitamos. Ahora que tenemos inicializado lo principal. Lo anterior debe lucir de la siguiente manera entre el inicio de la clase y el método main (solo por orden se ubica en este sector). 10. Los TextFields que irán a la derecha presentando la información 3. Agregaremos el botón y el combo al Panel. Un botón al final junto con Combo con tres números. (GridLayout) Agregaremos los componentes inicializados anteriormente al Panel Dejaremos sin editar a los TextFields. 1. Agregaremos el Panel al Sur del Frame (South). 6. Agregaremos el Panel al centro del Frame (Center). Vamos a crear un Panel Vamos a crear un Layout. Crearemos un nuevo Panel 9. que se lo vamos a pasar al panel. Entregar el nombre de la ventana y el tamaño al constructor de la superclase.Entonces comenzamos a declarar los objetos que irán en nuestra pantalla. 4. 5.

117 .

118 .Configurar los TextFields sin edición.

en este método vamos: 1. pero falta llamarla para poder mostrarla. es decir. Ahora. Vamos al método main. A agregar una nueva instancia de la clase VisorEventos. como se declara el retorno como bolean. vamos a poner una leve edición en el método handleEvent. vamos a retornar true. 2. solo para que compile y presente la ventana. Vamos a hacer que retorne algo. Ahora podemos ejecutar compilar nuestra aplicación y ejecutarla. 119 .Y así hemos armado nuestra pantalla. para poder ver como esta quedando nuestra ventana. vamos a presentar la instancia creada.

4. Veremos el uso del id. el handleEvent.exit (0). al preguntar por WINDOW_DESTROY. Veremos si el argumento viene como null o si trae un valor con if corto. valueOf. Los vamos a convertir a String a través de los métodos de la clase String. para terminar la aplicación con System. Lo anterior lucirá más menos así: 120 .Vemos que ya va tomando forma: Ahora solo nos falta ingresar el código en el método que manipula los eventos. obteniendo los miembros de la clase Event del objeto evt. Retornaremos el valor que nos arroje la superclase. 2. 3. Configurar los textos de los TextFields. En este método vamos a: 1.

a cada evento se va modificando el tiempo en que ha ocurrido. etc. Podemos ir aprendiendo mucho de esta aplicación. se vería de la siguiente manera: Como podemos observar y jugar con nuestra pequeña aplicación. si presionamos el botón.Ahora si compilamos y ejecutamos nuestro trabajo. notaremos que las coordenadas van a cambiar. Si movemos el Mouse por el applet. aparecerá el texto del mismo como argumento. 121 . hemos conseguido una herramienta para entender el comportamiento de los miembros de la clase Event.

sin embargo. El valor devuelto por el método handleEvent() es importante. Un valor true indica que el evento ha sido controlado y que su propagación debe detenerse.Cuando un usuario interactúa con el applet. Durante este camino. o que no ha sido controlado en su totalidad y debe continuar su propagación hacia arriba en el árbol de Componentes. el programador puede colocar el código en un método de ayuda. El método handleEvent() es un lugar para que el programador pueda insertar código para controlar los eventos. cada Componente tiene oportunidad de ignorar el evento o reaccionar ante él en una (o más) de las formas siguientes: • Modificar los datos miembros de la instancia de Event • Entrar en acción y realizar cálculos basados en la información contenida en el evento • Indicar al sistema Java que el evento no debería propagarse más arriba en el árbol El sistema Java pasa información del evento a un Componente a través del método handleEvent() del Componente. 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. Un valor false indica que el evento ha sido ignorado. el botón que ha sido pulsado) y se desplaza hacia arriba en el árbol de Componentes. Indica al sistema Java si el evento ha sido o no completamente controlado por el controlador. en lugar de colocarlo en el método handleEvent(). Este control comienza por el Componente que recibe inicialmente el evento (por ejemplo. A veces. 122 . En estos casos. hasta que alcanza al Contenedor de la raíz del árbol. un Componente solamente estará interesado en eventos de un cierto tipo (por ejemplo. componente a componente. eventos del ratón). Es en ese momento cuando el sistema Java permite al applet controlar el evento. Todos los métodos handleEvent() deben ser de la forma: public boolean handleEvent( Event evt ) Un controlador de eventos solamente necesita una información: una referencia a la instancia de la clase Event que contiene la información del evento que se ha producido.

aquí está la lista de los que están disponibles para los programadores: action( Event evt. public boolean handleEvent( Event evt ) { if( evt.int key ) false indicará que el método de ayuda no maneja el evento.handleEvent( evt ) ).int x.int y ) mouseMove( Event evt.int x.int y ) mouseDrag( Event evt. No seguir esta regla tan simple hará que no se invoquen adecuadamente los métodos de ayuda.int x.int y ) mouseDown( Event evt. siempre finalicen con la sentencia: return( super..Object obj ) lostFocus( Event evt.target instanceof MiBoton ) { // Hace algo.int x.int y ) keyDown( Event evt. El siguiente trozo de código ilustra esta regla. La implementación del método handleEvent() proporcionada por la clase Component invoca a cada método de ayuda. Por esta razón.int x.Object obj ) mouseEnter( Event evt.int y ) mouseExit( Event evt.No hay métodos de ayuda para ciertos tipos de eventos.int key ) keyUp( Event evt.. } } return( super.handleEvent( evt ) ). es importante que las implementaciones redefinidas del método handleEvent() en clases derivadas.int y ) mouseUp( Event evt.int x. return true. 123 .Object obj ) gotFocus( Event evt.

default: return( false ). return( false ). cuando se produce este evento se llama al método action().ACTION_EVENT: // evt.arg contiene la etiqueta del botón pulsado // o el item del menú que se ha seleccionado if( ( "Pulsado "+n+" veces" ).equals( evt. etc. } Como se puede comprobar. que es el método general de manejo de eventos: public boolean handleEvent( Event evt ) { switch( evt. } } Pero en este caso. 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.ACTION_EVENT Algunos de los eventos que más frecuentemente tendremos que controlar son los siguientes: ACTION_EVENT MOUSE_DOWN KEY_PRESS WINDOW_DESTROY En la documentación de la clase Event se encuentra toda la lista de eventos que cualquier aplicación puede necesitar manejar y su documentación. incluso si las etiquetas cambian se puede recibir el evento.Object arg ) { if( ( "Pulsado "+n+" veces" ). que sería: public boolean action( Event evt.id ) { case Event.equals( arg ) ) return( true ). ACTION_EVENT. seleccionar un menú.arg ) ) return( true ). en que se controla este evento a través del método handleEvent(). Veamos el siguiente ejemplo. como ejemplo de uso vamos a detenernos en el primero de ellos. Los ejemplos anteriores corresponden al control de un evento producido por 124 . Como ejemplo del manejo de eventos vamos a ver este evento que se provoca al pulsar un botón.

target == miBoton ) En donde se comparan objetos en lugar de etiquetas. 125 . Es así como se presenta una forma de manipular los eventos en Java. Aunque esta no es la única forma de manejar eventos. de hecho se puede hacer: if( evt.un botón que cambia su etiqueta cada vez que se pulsa.

Sign up to vote on this title
UsefulNot useful