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 .

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

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

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

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

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

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

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

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

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

errores de ejecución y errores lógicos. Errores de Ejecución 14 . serán quienes proporcionen el conocimiento suficiente para llegar a depurar programas con éxito. Desgraciadamente los errores no siempre se detectan y los mensajes de error no siempre son fáciles de interpretar. 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. Cuando se detecta un error en Java. manual de instrucciones y sobre todo la experiencia del programador.Errores de Programación Los errores de programación son inevitables. • Estos errores los detecta el compilador. • Ejemplo: utilizar una variable que no se ha definido previamente. Existen tres tipos de errores: errores de compilación (sintaxis). Errores de Compilación • Este tipo de errores ocurren cuando el código viola un o más reglas gramaticales de Java. Una mezcla de las advertencias del compilador. El proceso de corregir un error (bug en inglés) se denomina depuración ( debugging) del programa. incluso para programadores experimentados. Editar y crear un nuevo archivo .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. se visualiza un mensaje de error que devuelve la posible causa del error.

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

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

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

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

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

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

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

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

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

case Esta bifurcación permite hacer selecciones de casos para hacer más rápido la bifurcación.o switch . 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.• Bucles o while El while tiene como traducción “mientras”. La estructura del for es la siguiente for (número . no permite realizar un ciclo gracias a que existe un condición que debe cumplirse. y que puede ir creciendo o disminuyendo. esta condición va de la mano de un número entero que se debe declarar dentro del for. condición . veamos este ejemplo a continuación. o for El ciclo for. Para entender de mejor manera el funcionamiento del bucle while. y funciona de la siguiente manera. el bloque se ejecuta. incremento o decremento){ Bloque… } 25 . Que tiene la siguiente salida.

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

27 . 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. El método main tendrá siempre una sintaxis similar a esta: static public void main (String [] args){ //… sentencias. la cual constituye una plantilla o modelo para fabricar objetos.out. Es un método que visualiza un mensaje en el monitor o consola.println(“Bienvenido a mi Ejemplo”). El método “main”: Cada aplicación de Java debe tener un método main declarado por el programador que defina don de comienza el flujo del programa. Métodos Un método es una colección de sentencias que realizan una serie de operaciones determinadas. Por ejemplo: System.Clases La clase es la construcción fundamental de Java. valores boléanos. caracteres y valores numéricos o de punto flotante. Cada archivo de clase se compila en un archivo de Bytecode con la extensión .class. 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. } NOTA: Los métodos se explicarán más adelante. A continuación se presentan los ocho tipos primitivos de variables.

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

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

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

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

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

• • •

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

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

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

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

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

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

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

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

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

MANUAL DE JAVA CAPITULO 6: PAQUETES DE JAVA 44 .

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

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

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

la verdad es que no es algo imprescindible. El asterisco indica que se importarán todas las clases del paquete. por eso se creó esta superclase. import java. Short. 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.lang es el más excepcional porque es el único con el que nunca habrá que importar los programas de forma explícita. El paquete java.lang contiene los siguientes tipos de clases. Long.lang. El paquete java. De todos los paquetes. Las clases Byte. Integer.*. Clases concretas pueden ser raíces locales de todas las subjerarquías. Float y Double tienen puntos en común.lang La mayoría de las clases de java. 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. que es la raíz de toda la jerarquía de la clase de Java. 48 .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. java. Number se declara como una clase abstracta (esto se suele hacer para concretar clases).java. Sin embargo. no se importarán las clases de los subpaquetes. • • • • • • Clases envolventes Clases que admiten cadenas Clases de bibliotecas matemáticas Clases que pueden trabajar multitarea Clases que permiten acceso de bajo nivel al sistema Clases de excepciones y errores.lang son una aplicación de la clase Object.

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

o El subárbol MenuComponent.awt El paquete java. o El subárbol Component que contiene a Container. 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.java. o Image o Color y SystemColor o Font o FontMetrics o AlphaComposite y Composite o BasicStroke y Stroke o GraphicsConfigTemplate.awt se divide en una serie de grupos principales. Graphics 2D y PrintGraphics. GraphicsEnvironment. o FlowLayout o BorderLayout o CardLayout o GridLayout o GridBagLayout y GridBagContraints o Instes Clases Gráficas o Graphics. GraphicsConfiguration. • • Dos dedicados a los componentes GUI.

border com.swing.java.java.sun.sun.plaf.swing.sun.sun.swing.swing se introdujeron con la versión 1.java.colorchooser com. se puede trabajar también con los siguientes: 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 .com.swing.sun.filechooser com.tree com.java.java.sun.java.table com.swing.swing.sun.java.sun.text.event com.2 de Java y suponen la segunda generación de los widget gráficos de Java.swing.java. Sus clases se pueden agrupar en las siguientes áreas.sun.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.* com.java.* com.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.java.swing Los paquetes com.swing.

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

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

etc. conducen los datos entre el programa y los dispositivos externos. o también denominado secuencia. listas. Los archivos son dispositivos externos. 54 . Que están en memoria interna y por lo tanto desaparecen al acabar la ejecución del programa. etc. Una vez que acaba la aplicación. archivos indexados. los datos almacenados están disponibles para que otra aplicación los utilice. en contraposición de los datos que se guardan en arreglos (arrays). de acceso directo. Los flujos pueden estar abiertos o cerrados.Introducción El manejo de archivos en Java se realiza mediante flujos (stream) o canal. 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. árboles.io) se pueden tratar archivos secuénciales.

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

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

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

a leerlo con la case derivada de InputStream Se crea un objeto FileInputStream. con el nombre del archivo. Ahora procederemos FileInputStream. La salida de este programa sería la siguiente. de nombre datos. 58 . con el siguiente contenido. Leer un archivo: Inicialmente vamos a crear un archivo de texto.Ejemplo Introductorio FileInputStream Vamos a leer un archivo con la clase derivada de InputStream y luego utilizaremos una clase derivada de Read y Writer. 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 la cual se facilita de manera considerada el manejo de archivos.

59 .

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

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

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

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

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

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

<html> <body> <applet code="Appletuno.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. basta con escribir los que necesitamos para ejecutar nuestro applet. Luego que escribimos nuestro código. realizamos los siguientes pasos para ejecutarlo 1. escribimos una página HTML simple y lo guardamos en el mismo directorio donde guardamos el Appletuno.java. en un notepad. pasaré a explicar como se realiza el proceso de carga del applet. Escribimos el código del applet (ya realizado) 2. Escribimos el Tag <APPLET> dentro de una página HTML Esto lo realizamos de la siguiente manera. el tag que acompaña al applet es <APPLET> y se debe especificar un applet de la siguiente manera: <APPLET CODE="miApplet. los applet son pequeñas aplicaciones que se ejecutan dentro de un navegador Web.class" width=300 height=100> </applet> </body> </HTML> 70 .Como podemos apreciar.java. no es necesario escribir todos los métodos de un applet. Como sabemos.

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

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

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

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

75 .

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

ni hWnds. 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. etc. que son los controles básicos • No se usan posiciones fijas de los Compone ntes. 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.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. 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. No se puede separar el código de lo que es propiamente interfase 77 . ni llamadas a X.) • La arquitectura de la aplicación es dependiente del entorno de ventanas.

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

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

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

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

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.

83 . éstos deben tener Componentes en su interior. no debe estar compuesta solamente por Contenedores. 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. 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. 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. La creación se realiza en el método init() porque éste siempre es llamado automáticamente al inicializarse el applet. En el código siguiente. incorporamos dos botones al código del último ejemplo. De todos modos. al iniciarse la ejecución se crean los botones.

en la actual versión. 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.Layouts Los Layout Managers o manejadores de composición. 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). codificamos a mano tal disposición. 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. etc. de forma transparente para nosotros. su repintado cuando sea cubierto por otra ventana. de todas esas cuitas de formatos. Bien. Java dispone de varios. ahora. que se ocupará. 84 . ayudan a adaptar los diversos Componentes que se desean incorporar a un Panel. deberemos prever el redimensionamiento del applet. es decir. 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. especifican la apariencia que tendrán los Componentes a la hora de colocarlos sobre un Contenedor. Sigamos imaginando. en traducción literal.. donde se muestran los diferentes tipos de Layouts que proporciona el AWT.

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

y se puede seleccionar el espaciado entre cada Componente La ventana del Applet del código anterior es la siguiente. La cadena es horizontal. 86 . de izquierda a derecha. 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.

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

88 . 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.La composición GridLayout proporciona gran flexibilidad para situar Componentes. Vista del Applet.

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

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

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

92 . 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. de tal modo que cada selección determina el panel (grupo de componentes) que se presentarán.

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

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

Continuación. 95 .

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

CENTER 97 . Derecha.LEFT Label. Lo primero que hacemos es crearla y luego la posicionamos dentro de la applet. Muchos de estos controles comparten métodos y eventos. listas. Nosotros seremos los encargados de añadir esos controles y asignarles las acciones que van a realizar. etc. Creación: ALINEACIÓN DESCRIPCIÓN Izquierda. Centrado.RIGHT Label. cajas de texto. Label. Etiqueta (Label) Se utilizan para dibujar una cadena de texto en una posición y con una alineación (dentro del componente). etiquetas. es que el usuario interactué con el entorno y pueda realizar las operaciones que desee.Controles y Componentes La finalidad de añadir controles como botones.

Creación: Guardar Texto: (valido para etiquetas) Mostrar Texto: (valido para etiquetas) 98 . 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.

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

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

Creación: Áreas de Texto (TextArea) A veces no es suficiente una entrada de texto de una única línea. La clase que se utiliza es Button. Creación: Insertar Texto: Al Final: Posición Aleatorio: Reemplazar: 101 . seguido del número de columnas y filas que se desean visualizar. TextArea es una caja de texto multilínea. Además del método constructor existen otros de gran importancia. es decir. admite varias líneas. 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. El texto que aparece en los botones siempre va en el centro.

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

Lo primero es crear la barra de menús mediante la clase MenuBar. Y por último tendremos que ir añadiendo los ítem a los popup y los popup a la barra. 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.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 . También debemos añadir la barra de menú a la ventana. iremos creando los menús popup y cada uno de los ítems que contengan los popup. Esta barra esta compuesta por menús Popup.

. que nos permite implementar cualquier otro tipo de control en su interior y capturar sus eventos a través de la canva. otra clase donde crearemos el objeto de la subclase e implementaremos todo el código del programa. Como por ejemplo los métodos para establecer color.. Es muy útil cuando el control que implementamos no responde a eventos. tipo de letra. 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. 106 . hay un componente (Canvas). etc. 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.Cuadro de Dibujos (Canvas) Además de los componentes estándar. Creación de la Subclase: Creación del Objeto Canvas: Debe ser una clase distinta a la anterior.

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

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

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

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

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

Los grandes grupos de eventos son: Eventos de Ventana Son los que se generan en respuesta a los cambios de una ventana un frame o un dialogo. • • • • • WINDOW_DESTROY WINDOW_EXPOSE WINDOW_ICONIFY WINDOW_DEICONIFY WINDOW_MOVED Eventos de Teclado Son generados en respuesta a cuando el usuario pulsa y suelta una tecla mientras un Componente tiene el foco de entrada. • • • • KEY_PRESS KEY_RELEASE KEY_ACTION KEY_ACTION_RELEASE Eventos de Ratón Son los eventos generados por acciones sobre el ratón dentro de los límites de un Componente. que se indicará en el miembro id de su estructura. • • • • • SCROLL_LINE_UP SCROLL_LINE_DOWN SCROLL_PAGE_UP SCROLL_PAGE_DOWN SCROLL_ABSOLUTE 112 .Los eventos se catalogan por su naturaleza. • • • • • • 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).

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

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

Comenzamos por inicializar los objetos que van a estar en la pantalla. 4. 1.awt con todas sus clases. 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. 2.Vamos inicialmente a importar el paquete java. 3. Deberá lucir más o menos así: 115 . Luego generamos la estructura que tendrá nuestro archivo.

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

117 .

118 .Configurar los TextFields sin edición.

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

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

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

hasta que alcanza al Contenedor de la raíz del árbol. 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. 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. En estos casos. Durante este camino. el botón que ha sido pulsado) y se desplaza hacia arriba en el árbol de Componentes. 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. en lugar de colocarlo en el método handleEvent(). Este control comienza por el Componente que recibe inicialmente el evento (por ejemplo.Cuando un usuario interactúa con el applet. Un valor false indica que el evento ha sido ignorado. el programador puede colocar el código en un método de ayuda. 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. sin embargo. componente a componente. eventos del ratón). A veces. Indica al sistema Java si el evento ha sido o no completamente controlado por el controlador. 122 . Es en ese momento cuando el sistema Java permite al applet controlar el evento. o que no ha sido controlado en su totalidad y debe continuar su propagación hacia arriba en el árbol de Componentes. un Componente solamente estará interesado en eventos de un cierto tipo (por ejemplo. El método handleEvent() es un lugar para que el programador pueda insertar código para controlar los eventos.

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

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

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

Sign up to vote on this title
UsefulNot useful