P. 1
Manual+Java+UML+Básico

Manual+Java+UML+Básico

|Views: 5.613|Likes:
Publicado porAlejandra

More info:

Published by: Alejandra on May 05, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

05/20/2013

pdf

text

original

Sections

  • CAPITULO 1: INTRODUCCION
  • Aspectos Históricos
  • ¿Qué es Java?
  • Evolución de las Versiones de Java
  • CAPITULO 2: PROGRAMACION ORIENTADA A OBJETOS
  • Principios de la Orientación a Objetos
  • CAPITULO 3: ELEMENTOS DEL LENGUAJE JAVA
  • Errores de Programación
  • Edición, Compilación y Ejecución de Programas
  • Elementos Básicos
  • Control de Flujo
  • Control de Excepciones
  • Try – Throw – Throws - Catch - Finally
  • CAPITULO 4: PROGRAMACION ORIENTADA A OBJETOS CON JAVA
  • Abstracción (Aplicado)
  • Encapsulamiento (Aplicado)
  • Herencia (Aplicado)
  • Polimorfismo (Aplicado)
  • CAPITULO 5: INTRODUCCIÓN A UML
  • CAPITULO 6: PAQUETES DE JAVA
  • Introducción
  • Paquetes y Directorios
  • CAPITULO 7: MANEJO DE ARCHIVO EN JAVA
  • Flujos
  • Jerarquía de Clases
  • FileInputStream y FileOutputStream
  • Ejemplo Introductorio FileInputStream
  • Ejemplo Introductorio FileOutputStream
  • Ejemplo Introductorio FileReader
  • Ejemplo Introductorio FileWriter
  • CAPITULO 8: APPLETS
  • Introducción a los Applets de Java
  • Applets
  • CAPITULO 9: INTERFASES GRÁFICAS DE USUARIO EN JAVA
  • Eventos
  • La Clase Event

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. A continuación presentaremos la Historia y comenzaremos a entrar en profundidad en el lenguaje Java. el nivel sintáctico es muy similar a C y C++. 5 . Contiene clases que pueden manipular los tipos de variables de manera fácil.Introducción El lenguaje de programación que utiliza Java es netamente orientado a objeto.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

y funciona de la siguiente manera. 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.• Bucles o while El while tiene como traducción “mientras”. o for El ciclo for. Que tiene la siguiente salida. veamos este ejemplo a continuación. incremento o decremento){ Bloque… } 25 . y que puede ir creciendo o disminuyendo. mientras la condición se cumpla. condición . Para entender de mejor manera el funcionamiento del bucle while. el bloque se ejecuta. esta condición va de la mano de un número entero que se debe declarar dentro del for.

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

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

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

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

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

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

println("Ejecución de bloque finally").Catch . class Error2{ static public void main (String [] args){ try{ lanzar_excepcion(). } } Compilemos y ejecutemos este código Explicaré a continuación cada una de las líneas del código para que se entienda que hacen las palabras reservadas que están involucradas en el control de excepciones.println("Excepcion capturada").Try – Throw – Throws .io.out. }catch (Exception e){ //hacemos algo si viene otro tipo de excepción }finally{ System.Finally Iniciemos la explicación con el siguiente código: Archivo Error2.*.java import java. } } static public void lanzar_excepcion()throws Exception{ //provocamos un lanzamiento con throw throw new IOException(). }catch(IOException provocado){ System.out. 32 .

• • •

Se importa import java.io.*; para poder utilizar el error de entrada y salida. Se crea un bloque try el cual puede capturar excepciones de cualquier tipo dentro de su bloque de declaración. Se emplea la palabra catch, la cual permite capturar las excepciones que se produzcan en el bloque try. Inicialmente programamos que se capturara una excepción de tipo IOException (excepción de entrada y salida). Posteriormente utilizamos otro catch para posibles excepciones de otro tipo que no tuviéramos previstas, esto lo hice más que nada para demostrar que uno puede utilizar cuantos bloques catch desee, según la cantidad de excepciones que uno espere obtener de un bloque. Se utiliza la cláusula finally para demostrar su uso, esta cláusula puede ser utilizada para volver a levantar o estabilizar el sistema después de una excepción. Como podemos apreciar, en el interprete de comandos, primero se capturo el excepción y luego se ejecutó el bloque finally. Por último escribimos un método lanzar_excepcion(), el cual levanta un nuevo error de tipo IOException.

33

MANUAL DE JAVA
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

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

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

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

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

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

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

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

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

MANUAL DE JAVA CAPITULO 6: PAQUETES DE JAVA 44 .

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. ya que ellos prestan a menudo una ayuda muy importante. además aprenderemos a crear nuevos paquetes. 45 .

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

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

*. que es la raíz de toda la jerarquía de la clase de Java. 48 . Aunque disponer de una clase principal (superclase) es algo bastante normal. El asterisco indica que se importarán todas las clases del paquete. Sin embargo. De todos los paquetes. Las clases Byte.lang contiene los siguientes tipos de clases. El paquete java.lang La mayoría de las clases de java. El compilador se encarga de agregar la siguiente línea al principio de los archivos fuentes. Number se declara como una clase abstracta (esto se suele hacer para concretar clases).lang es el más excepcional porque es el único con el que nunca habrá que importar los programas de forma explícita. la verdad es que no es algo imprescindible. import java.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. Clases concretas pueden ser raíces locales de todas las subjerarquías. Float y Double tienen puntos en común. Long. Integer.java. Short. El paquete java. • • • • • • 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. 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. no se importarán las clases de los subpaquetes.lang son una aplicación de la clase Object. por eso se creó esta superclase. java.

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

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

java.sun.sun.sun.sun.swing se introdujeron con la versión 1.java.* com.sun.com.java.filechooser com.table com.java.swing.tree com.colorchooser com.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.swing.sun.java.swing. se puede trabajar también con los siguientes: com.sun.event com.text.plaf.2 de Java y suponen la segunda generación de los widget gráficos de Java.java.java.* com.swing.swing.swing.java. Sus clases se pueden agrupar en las siguientes áreas.java.swing. • • Widget de Jcomponent Clases para la gestión del diseño o BoxLayout o OverlayLayout o ScrollPaneLayout o ViewportLayout o SizeRequirements Clases e interfaces de Model Clases Manager o DesktopManager y DefaultDesktopManager o FocusManager y DefaultFocusManager o MenuSelectionManager o RepaintManager o ToolTipManager o UIManager Clases de AbstractAction y KeyStroke y la interfaz Action Otras clases o BorderFactory o ImageIcon y la interfaz Icon o LookAndFeel o ProgressMonitor y ProgressMonitorInputStream o SwingUtilities o GrayFilter o Timer • • • • Además del paquete que hemos visto anteriormente.swing Los paquetes com.sun. incluyendo HTML y Rich Text Format(RTF) Clases que admiten componentes de árboles Clases que pueden trabajar con las implementación deshacer/rehacer 51 .border com.java.swing.sun.sun.sun.java.swing.

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

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

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

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

Además InputStream es la clase base de todas las clases definidas para Stream de entrada.Jerarquía de Clases En el paquete java. Los flujos de datos. y OutputStream es la clase base para todas las clases de Stream de salida. InputStream FileInputStream ByteArrayInputStream PipeInputStream SequenceInputStream StringBuffereInputStream FilterInputStream OutputStream FileOutputStream ByteArrayOutputStream PipeOutputStream FilterOutputStream 56 . de caracteres. Por ello Java declara dos clases que derivan directamente de la clase Object: InputStream y OutputStream. Ambas son clases abstractas que declaran métodos que deben de redefinirse en sus clases derivadas.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).

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

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

59 .

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

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

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

63 .

MANUAL DE JAVA CAPITULO 8: APPLETS 64 .

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

65

Applets
Arquitectura de lo Applets Los applets tienen una arquitectura bien definida, la cual permite reconocer los pasos de su inicialización de una manera simple: Cuando un applet se carga, comienza su ciclo de vida, que pasaría por las siguientes fases: • • • • Se crea una instancia de la clase que controla el Applet. El Applet se inicializa. El Applet comienza a ejecutarse. El Applet comienza a recibir llamadas de los métodos primarios de un Applet. o init() (inicializar) o star() (empezar) o paint() (pintar)

Jerarquía de un applet

Las características de las applets se pueden considerar desde el punto de vista del programador y desde el del usuario. En este manual lo más importante es el punto de vista del programador: Las applets no tienen un método main() con el que comience la ejecución. El papel central de su ejecución lo asumen otros métodos que se verán posteriormente. Todas las applets derivan de la clase java.applet.Applet. La Figura anterior muestra la jerarquía de clases de la que deriva la clase Applet. Las applets deben

66

redefinir ciertos métodos heredados de Applet que controlan su ejecución: init(), start(), stop(), destroy(). Se heredan otros muchos métodos de las super-clases de Applet que tienen que ver con la generación de interfaces gráficas de usuario (AWT). Así, los métodos gráficos se heredan de Component, mientras que la capacidad de añadir componentes de interfase de usuario se hereda de Container y de Panel. Las applets también suelen redefinir ciertos métodos gráficos: los más importantes son paint() y update(), heredados de Component y de Container; y repaint() Heredado de Component. Las applets disponen de métodos relacionados con la obtención de información, como por ejemplo: getAppletInfo(), getAppletContext(), getParameterInfo(), getParameter(), getCodeBase(), getDocumentBase(), e isActive(). El método showStatus() se utiliza para mostrar información en la barra de estado del browser. Existen otros métodos relacionados con imágenes y sonido: getImage(), getAudioClip(), play(), etc. Métodos de un Applet Los métodos propios de la clase Applet. init() El método init() se llama cada vez que el applet carga por primera vez. Si el applet llamado no lo sobrecarga, init() no hace nada. Fundamentalmente en este método se debe fijar el tamaño del applet, aunque en el caso de Netscape el tamaño que vale es el que se indique en la línea del fichero HTML que cargue el applet. También se deben realizar en este método las cargas de imágenes y sonidos necesarios para la ejecución del applet. Y, por supuesto, la asignación de valores a las variables globales a la clase que se utilicen. En el caso de los applet, este método únicamente es llamado por el sistema al cargar el applet. start() start() es la llamada para arrancar el applet cada vez que es visitado. La clase Applet no hace nada en este método. Las clases derivadas deben sobrecargarlo para comenzar la animación, el sonido, etc. Esta función es llamada automáticamente cada vez que la zona de visualización en que está ubicado el applet se expone a la visión, a fin de optimizar en uso de los recursos del sistema y no ejecutar algo que no puede ser apreciado (aunque el programador puede variar este comportamiento y hacer que un applet siga activo aun cuando esté fuera del

67

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

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

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

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

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

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

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

75 .

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

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

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

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

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

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

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. pueden reemplazar al objeto Frame. 82 .Un objeto Window.

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.Añadir Componentes a un Contenedor Para que la interfase sea útil. En el código siguiente. Este método tiene tres formas de llamada que dependen del manejador de composición o layout manager que se vaya a utilizar sobre el Contenedor. Los Componentes se añaden al Contenedor invocando al método add() del Contenedor. incorporamos dos botones al código del último ejemplo. La creación se realiza en el método init() porque éste siempre es llamado automáticamente al inicializarse el applet. 83 . éstos deben tener Componentes en su interior. al iniciarse la ejecución se crean los botones. no debe estar compuesta solamente por Contenedores. De todos modos.

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

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

FlotLayout Es el más simple y el que se utiliza por defecto en todos los Paneles si no se fuerza el uso de alguno de los otros. Los Componentes añadidos a un Panel con FlowLayout se encadenan en forma de lista. y se puede seleccionar el espaciado entre cada Componente La ventana del Applet del código anterior es la siguiente. 86 . La cadena es horizontal. de izquierda a derecha.

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

Vista del Applet. El layout se crea con un número de filas y columnas y los Componentes van dentro de las celdas de la tabla así definida. 88 .La composición GridLayout proporciona gran flexibilidad para situar Componentes.

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

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

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

Este layout suele ir asociado con botones de lista (Choice). 92 . de tal modo que cada selección determina el panel (grupo de componentes) que se presentarán.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.

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. 93 .

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

Continuación. 95 .

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

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

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

Estados: Necesitamos ahora cambiar los Checkbox a botones de opción. Creación: Tenemos 2 maneras para crearlos. debemos únicamente crear un CheckboxGroup y entregárselos como parámetro a cada uno de los Checkbox que deseamos estén como botones de opción. Creación de Grupo: Creación de Elementos: 99 . para ello. El primero si se quiere establecer un valor inicial. y los métodos getState y setState para obtener y mostrar el estado. 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. los cuales pueden estar varios seleccionados a la vez. (por defecto están sin seleccionar).Cuadros de Chequeo (Checkbox) Las casillas de verificación son botones de opciones.

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

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

Lista Desplegable de Selección (Choice)

Las Listas de Selección (Choice), funcionan de la misma manera que una List, salvo que en su gráfica, aparece el valor seleccionado en una casilla, y si el usuario desea seleccionar otro valor, deberá desplegar la lista para seleccionarlo.
Creación:

Agregar Ítem:

Seleccionar Ítem:

Obtener el índice seleccionado:

Obtener el valor seleccionado:

102

Barra de Desplazamiento (Scrollbar)

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

CONSTANTE Scrollbar.VERTICAL Scrollbar.HORIZONTAL

DESCRIPCIÓN
Orientación vertical Orientación horizontal

Valores Mínimos y Máximos:

Establecer Valor:

Obtener Valor:

103

Panel (Panel)

Panel es una clase derivada de Container la cual nos va a servir para introducir controles en su interior, de la misma forma que una canva. La principal utilidad que se le puede dar es para colocar controles a una ventana en un punto que a nosotros nos interese a través de un objeto Panel.
Creación:

Tamaño y Posición:

Movimiento:

Añadir Elemento:

104

También debemos añadir la barra de menú a la ventana. Esta barra esta compuesta por menús Popup. los cuales están compuestos de menús ítem.Barra de Menú (MenuBar) Cada ventana de nivel superior puede tener una barra de menús. iremos creando los menús popup y cada uno de los ítems que contengan los popup. Lo primero es crear la barra de menús mediante la clase MenuBar. Los menús de tipo ítem también pueden comportarse como Popup con lo que podremos anidar submenús creando una jerarquía. 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 . Una vez creada. Y por último tendremos que ir añadiendo los ítem a los popup y los popup a la barra.

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

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

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

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

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

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

que se indicará en el miembro id de su estructura. • • • • • 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. 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. • • • • • • 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).Los eventos se catalogan por su naturaleza. • • • • • SCROLL_LINE_UP SCROLL_LINE_DOWN SCROLL_PAGE_UP SCROLL_PAGE_DOWN SCROLL_ABSOLUTE 112 .

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

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

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

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

117 .

118 .Configurar los TextFields sin edición.

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

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

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

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

aquí está la lista de los que están disponibles para los programadores: action( Event evt.int y ) keyDown( Event evt..int key ) false indicará que el método de ayuda no maneja el evento.handleEvent( evt ) ).int key ) keyUp( Event evt.Object obj ) mouseEnter( Event evt.int x. return true. } } return( super.int x. El siguiente trozo de código ilustra esta regla.handleEvent( evt ) ).int x.int y ) mouseDown( Event evt.int y ) mouseExit( Event evt.Object obj ) lostFocus( Event evt. siempre finalicen con la sentencia: return( super.int y ) mouseDrag( Event evt.int x.. 123 .target instanceof MiBoton ) { // Hace algo.int y ) mouseMove( Event evt.int x. Por esta razón.int x. public boolean handleEvent( Event evt ) { if( evt.No hay métodos de ayuda para ciertos tipos de eventos. es importante que las implementaciones redefinidas del método handleEvent() en clases derivadas. La implementación del método handleEvent() proporcionada por la clase Component invoca a cada método de ayuda. No seguir esta regla tan simple hará que no se invoquen adecuadamente los métodos de ayuda.int y ) mouseUp( Event evt.Object obj ) gotFocus( 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. incluso si las etiquetas cambian se puede recibir el evento. return( false ). 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.Object arg ) { if( ( "Pulsado "+n+" veces" ).id ) { case Event. Veamos el siguiente ejemplo. Para su control podemos manejarlo en el método handleEvent() o en el método action(). Los ejemplos anteriores corresponden al control de un evento producido por 124 . seleccionar un menú. default: return( false ). etc. } } Pero en este caso.equals( arg ) ) return( true ). } Como se puede comprobar. ACTION_EVENT.equals( evt.ACTION_EVENT: // evt. cuando se produce este evento se llama al método action().arg contiene la etiqueta del botón pulsado // o el item del menú que se ha seleccionado if( ( "Pulsado "+n+" veces" ). Como ejemplo del manejo de eventos vamos a ver este evento que se provoca al pulsar un botón. como ejemplo de uso vamos a detenernos en el primero de ellos.arg ) ) return( true ). que es el método general de manejo de eventos: public boolean handleEvent( Event evt ) { switch( evt. que sería: public boolean action( Event evt. en que se controla este evento a través del método handleEvent().

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

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->