Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

PROYECTO MODULO CLIENTE SERVIDOR

534 views

Published on

Informe del proyecto final del módulo cliente servidor.... espero les sirva chicos si necesitan algo me lo piden en los comentarios :*
1. CONTENIDO
2. DESARROLLO. 7
2.1 MODULO CONCEPTOS AVANZADOS DEL LENGUAJE. 7
2.1.1 Colecciones Java. 7
2.1.1.1 Marco Teórico. 7
2.1.1.1.1 Concepto. 7
2.1.1.1.2 Clases. 7
2.1.1.1.2.1 Interfaces 7
2.1.1.1.2.2 Métodos: 8
2.1.1.1.2.3 Iterando Colecciones. 8
2.1.1.1.2.3.1 for-each 8
2.1.1.1.2.3.2 Iteradores 8
2.1.1.1.2.4 Operaciones entre colecciones y arreglos 9
2.1.1.2 Ejemplo. 10
2.1.1.2.1 List 10
2.1.1.2.2 Map 13
2.1.1.2.3 Set 16
2.1.1.2.4 Archivador 18
2.1.2 AWT. 21
2.1.2.1 Marco Teórico. 21
2.1.2.1.1 El paquete AWT. 21
2.1.2.1.2 Elementos. 21
2.1.2.1.3 Jerarquía de Clases. 21
2.1.2.1.4 Clases. 22
2.1.2.1.4.1 java.awt.Component 22
2.1.2.1.4.2 java.awt.Container 22
2.1.2.1.4.3 java.awt.LayoutManager 22
2.1.2.1.5 Coordenadas y Posicionamiento. 23
2.1.2.1.6 Pasos a seguir: 23
2.1.2.1.7 Layout Managers. 23
2.1.2.1.7.1 ¿Por qué usar Layout Managers? 23
2.1.2.1.8 Eventos. 24
2.1.2.1.8.1 Tipos de eventos: 24
2.1.2.1.8.1.1 Físicos: 24
2.1.2.1.8.1.2 Semánticos: 24
2.1.2.1.9 Adapters. 27
2.1.2.2 Ejemplos. 28
2.1.2.2.1 Button. 28
2.1.2.2.2 CheckBox 28
2.1.2.2.3 CheckBoxGroup 29
2.1.2.2.4 Choise 31
2.1.2.2.5 Frame 32
2.1.2.2.6 Label 32
2.1.2.2.7 List 33
2.1.2.2.8 Panel 34
2.1.2.2.9 Scrollbar 36
2.1.2.2.10 TextField 37
2.1.3 Swing. 38
2.1.3.1 Marco Teórico. 38
2.1.3.1.1 El paquete Swing. 38
2.1.3.1.2 Migrando de AWT a Swing 38
2.1.3.1.3 Layout Managers 38
2.1.3.2 Ejemplo. 40
2.1.4 Applet. 65
2.1.4.1 Marco Teórico. 65
2.1.4.1.1 Concepto. 65
2.1.4.1.2 Atributos 65
2.1.4.1.3 Etiqueta <object> 66
2.1.4.1.4 Ciclo de vida 67
2.1.4.2 Ejemplo. 69
2.1.4.2.1 Hola mundo 69
2.1.4.2.2 Convertidor de Monedas 69
2.1.5 Manejo de Excepciones. 74
2.1.5.1 Marco Teórico. 74
2.1.5.1.1 Manejo de Excepciones 74
2.1.5.1.2 Generación de Excepciones en Java 74
2.1.5.1.3 Jerarquía de Clases 75
2.1.5.1.4 Captura de Excepciones 75
2.1.5.1.4.1 Try. 76
2.1.5.1.4.2 Catch 76
2.1.5.1.4.3 Finally 77
2.1.5.1.5 Throw 77
2.1.5.1.6 Tipos de excepciones 78
2.1.5.1.6.1 Excepciones Predefinidas 78
2.1.5.2 Ejemplo. 79
2.1.6 Threads. 81
2.1.6.1 Marco Teórico. 81
2.1.6.1.1 Programación Multihilo. 81
2.1.6.1.2 Clases. 81
2.1.6.1.3 java.lang.Thread 81
2.1.6.1.4 java.lang.Runnable 81
2.1.6.1.5 Implementando un Thread 81
2.1.6.1.6 Sincronización de threads. 83
2.1.6.1.7 Uso de señales 83
2.1.6.2 Ejemplo. 84
2.1.6.2.1 Carrera 84
2.1.6.2.2 Cronometro 85
2.1.7 Tcp/Ip. 91
2.1.7.1 Marco Teórico. 91
2.1.7.1.1 Sockets. 91
2.1.7.1.1.1 Sockets Stream (TCP, Transport Control Protocol) 91
2.1.7.1.1.2 Sockets Datagrama (UDP, User Datagram Protocol) 91
2.1.7.1.1.3 Sockets Raw 91
2.1.7.1.2 La clase URL. 91
2.1.7.1.3 Apertura de sockets. 92
2.1.7.1.4 Cierre de sockets 93
2.1.7.1.5 Creacion de streams. 94
2.1.7.1.5.1 Creación de Streams de Entrada 94
2.1.7.1.5.2 Creaci

Published in: Technology
  • Be the first to comment

PROYECTO MODULO CLIENTE SERVIDOR

  1. 1. 1 1. CONTENIDO 2. DESARROLLO................................................................................................................................... 7 2.1 MODULO CONCEPTOS AVANZADOS DEL LENGUAJE....................................................................... 7 2.1.1 Colecciones Java...................................................................................................................... 7 2.1.1.1 Marco Teórico. ........................................................................................................................ 7 2.1.1.1.1 Concepto............................................................................................................................. 7 2.1.1.1.2 Clases.................................................................................................................................. 7 2.1.1.1.2.1 Interfaces......................................................................................................................... 7 2.1.1.1.2.2 Métodos:......................................................................................................................... 8 2.1.1.1.2.3 Iterando Colecciones. ....................................................................................................... 8 2.1.1.1.2.3.1 for-each....................................................................................................................... 8 2.1.1.1.2.3.2 Iteradores .................................................................................................................... 8 2.1.1.1.2.4 Operaciones entre colecciones y arreglos........................................................................... 9 2.1.1.2 Ejemplo..................................................................................................................................10 2.1.1.2.1 List.....................................................................................................................................10 2.1.1.2.2 Map....................................................................................................................................13 2.1.1.2.3 Set......................................................................................................................................16 2.1.1.2.4 Archivador..........................................................................................................................18 2.1.2 AWT.......................................................................................................................................21 2.1.2.1 Marco Teórico. .......................................................................................................................21 2.1.2.1.1 El paquete AWT...................................................................................................................21 2.1.2.1.2 Elementos...........................................................................................................................21 2.1.2.1.3 Jerarquía de Clases..............................................................................................................21 2.1.2.1.4 Clases.................................................................................................................................22 2.1.2.1.4.1 java.awt.Component........................................................................................................22 2.1.2.1.4.2 java.awt.Container..........................................................................................................22 2.1.2.1.4.3 java.awt.LayoutManager..................................................................................................22 2.1.2.1.5 Coordenadas yPosicionamiento...........................................................................................23 2.1.2.1.6 Pasos a seguir:....................................................................................................................23 2.1.2.1.7 Layout Managers.................................................................................................................23 2.1.2.1.7.1 ¿Por qué usar Layout Managers?......................................................................................23 2.1.2.1.8 Eventos...............................................................................................................................24 2.1.2.1.8.1 Tipos de eventos:............................................................................................................24 2.1.2.1.8.1.1 Físicos:........................................................................................................................24
  2. 2. 2 2.1.2.1.8.1.2 Semánticos:.................................................................................................................24 2.1.2.1.9 Adapters.............................................................................................................................27 2.1.2.2 Ejemplos. ...............................................................................................................................28 2.1.2.2.1 Button................................................................................................................................28 2.1.2.2.2 CheckBox............................................................................................................................28 2.1.2.2.3 CheckBoxGroup...................................................................................................................29 2.1.2.2.4 Choise ................................................................................................................................31 2.1.2.2.5 Frame.................................................................................................................................32 2.1.2.2.6 Label ..................................................................................................................................32 2.1.2.2.7 List.....................................................................................................................................33 2.1.2.2.8 Panel..................................................................................................................................34 2.1.2.2.9 Scrollbar.............................................................................................................................36 2.1.2.2.10 TextField.........................................................................................................................37 2.1.3 Swing.....................................................................................................................................38 2.1.3.1 Marco Teórico. .......................................................................................................................38 2.1.3.1.1 El paquete Swing.................................................................................................................38 2.1.3.1.2 Migrando de AWT a Swing...................................................................................................38 2.1.3.1.3 Layout Managers.................................................................................................................38 2.1.3.2 Ejemplo..................................................................................................................................40 2.1.4 Applet....................................................................................................................................65 2.1.4.1 Marco Teórico. .......................................................................................................................65 2.1.4.1.1 Concepto............................................................................................................................65 2.1.4.1.2 Atributos............................................................................................................................65 2.1.4.1.3 Etiqueta <object>................................................................................................................66 2.1.4.1.4 Ciclo de vida........................................................................................................................67 2.1.4.2 Ejemplo..................................................................................................................................69 2.1.4.2.1 Hola mundo........................................................................................................................69 2.1.4.2.2 Convertidor de Monedas ....................................................................................................69 2.1.5 Manejo de Excepciones...........................................................................................................74 2.1.5.1 Marco Teórico. .......................................................................................................................74 2.1.5.1.1 Manejo de Excepciones .......................................................................................................74 2.1.5.1.2 Generación de Excepciones enJava......................................................................................74 2.1.5.1.3 Jerarquía de Clases..............................................................................................................75 2.1.5.1.4 Captura de Excepciones.......................................................................................................75 2.1.5.1.4.1 Try..................................................................................................................................76
  3. 3. 3 2.1.5.1.4.2 Catch..............................................................................................................................76 2.1.5.1.4.3 Finally.............................................................................................................................77 2.1.5.1.5 Throw.................................................................................................................................77 2.1.5.1.6 Tipos de excepciones...........................................................................................................78 2.1.5.1.6.1 Excepciones Predefinidas.................................................................................................78 2.1.5.2 Ejemplo..................................................................................................................................79 2.1.6 Threads..................................................................................................................................81 2.1.6.1 Marco Teórico. .......................................................................................................................81 2.1.6.1.1 Programación Multihilo. ......................................................................................................81 2.1.6.1.2 Clases.................................................................................................................................81 2.1.6.1.3 java.lang.Thread..................................................................................................................81 2.1.6.1.4 java.lang.Runnable..............................................................................................................81 2.1.6.1.5 Implementando un Thread ..................................................................................................81 2.1.6.1.6 Sincronización de threads....................................................................................................83 2.1.6.1.7 Uso de señales....................................................................................................................83 2.1.6.2 Ejemplo..................................................................................................................................84 2.1.6.2.1 Carrera...............................................................................................................................84 2.1.6.2.2 Cronometro........................................................................................................................85 2.1.7 Tcp/Ip. ...................................................................................................................................91 2.1.7.1 Marco Teórico. .......................................................................................................................91 2.1.7.1.1 Sockets...............................................................................................................................91 2.1.7.1.1.1 Sockets Stream (TCP, Transport Control Protocol) .............................................................91 2.1.7.1.1.2 Sockets Datagrama (UDP, User Datagram Protocol)...........................................................91 2.1.7.1.1.3 Sockets Raw....................................................................................................................91 2.1.7.1.2 La clase URL. .......................................................................................................................91 2.1.7.1.3 Apertura de sockets.............................................................................................................92 2.1.7.1.4 Cierre de sockets.................................................................................................................93 2.1.7.1.5 Creacion de streams............................................................................................................94 2.1.7.1.5.1 Creación de Streams de Entrada.......................................................................................94 2.1.7.1.5.2 Creación de Streams de Salida..........................................................................................94 2.1.7.2 Ejemplo..................................................................................................................................96 2.1.7.2.1 URL ....................................................................................................................................96 2.1.7.2.2 Servidor..............................................................................................................................99 2.2 MODULO BASE DE DATOS. ........................................................................................................114 2.2.1 Acceso a la Base de Datos......................................................................................................114
  4. 4. 4 2.2.1.1 Marco Teórico. .....................................................................................................................114 2.2.1.1.1 Definición.........................................................................................................................114 2.2.1.1.2 Normalización...................................................................................................................116 2.2.1.1.2.1 Definición......................................................................................................................116 2.2.1.1.2.2 Claves...........................................................................................................................117 2.2.1.1.2.3 FORMAS NORMALES......................................................................................................118 2.2.1.1.2.3.1 PRIMERA FORMA NORMAL (1FN) ...............................................................................118 2.2.1.1.2.3.2 SEGUNDA FORMA NORMAL (2FN) ..............................................................................118 2.2.1.1.2.3.3 TERCERA FORMA NORMAL (3FN)................................................................................119 2.2.1.1.2.3.4 FORMA NORMAL DE BOYCE-CODD (FNBC) ..................................................................119 2.2.1.1.2.3.5 CUARTA FORMA NORMAL (4FN).................................................................................120 2.2.1.1.2.3.6 QUINTA FORMA NORMAL (5FN) .................................................................................120 2.2.1.1.2.4 Reglas de CODD.............................................................................................................120 2.2.1.1.2.4.1 Regla no. 1 - la regla de la información........................................................................120 2.2.1.1.2.4.2 Regla no. 2 - la regla del acceso garantizado................................................................120 2.2.1.1.2.4.3 REGLA NO. 3 - Tratamiento sistemático de los valores nulos.........................................121 2.2.1.1.2.4.4 Regla no. 4 - La regla de la descripción de la base de datos...........................................121 2.2.1.1.2.4.5 Regla no. 5 - La regla del sub-lenguaje integral ............................................................121 2.2.1.1.2.4.6 Regla no. 6 - la regla de la actualización de vistas.........................................................121 2.2.1.1.2.4.7 Regla no. 7 - la regla de insertar y actualizar................................................................121 2.2.1.1.2.4.8 Regla no. 8 - la regla de independencia física...............................................................122 2.2.1.1.2.4.9 Regla no. 9 - la regla de independencia lógica..............................................................122 2.2.1.1.2.4.10 Regla no. 10 - la regla de la independencia de la integridad..........................................122 2.2.1.1.2.5 Las reglas de integridad.- ...............................................................................................122 2.2.1.1.2.5.1 Regla no. 11 - la regla de la distribución ......................................................................122 2.2.1.1.2.5.2 Regla no. 12 - regla de la no-subversión ......................................................................123 2.2.1.1.2.6 Modelo Entidad – Relación.............................................................................................123 2.2.1.1.2.6.1 Definición..................................................................................................................123 2.2.1.1.2.6.2 Modelado Entidad-Relación........................................................................................123 2.2.1.1.2.6.2.1 Base teórica y conceptual...........................................................................................123 2.2.1.1.2.6.2.1.1 Entidad..................................................................................................................124 2.2.1.1.2.6.2.1.2 Atributos ...............................................................................................................124 2.2.1.1.2.6.2.1.3 Relación.................................................................................................................125 2.2.1.1.2.6.2.1.4 Conjunto de relaciones...........................................................................................125 2.2.1.1.2.7 Restricciones.-...............................................................................................................126
  5. 5. 5 2.2.1.1.2.7.1 Correspondencia de cardinalidades.............................................................................126 2.2.1.1.2.7.2 Restricciones de participación ....................................................................................126 2.2.1.1.2.8 Claves...........................................................................................................................126 2.2.1.1.2.9 Diagrama Entidad-Relación............................................................................................127 2.2.1.1.2.9.1 Entidades..................................................................................................................128 2.2.1.1.2.9.2 Atributos...................................................................................................................128 2.2.1.1.2.9.3 Relaciones.................................................................................................................128 2.2.1.1.2.10 Diagramas Extendidos.-..................................................................................................128 2.2.1.1.2.10.1 Entidades Fuertes y Débiles.-......................................................................................129 2.2.1.1.2.10.2 Cardinalidad de las relaciones.....................................................................................129 2.2.1.1.2.10.3 Atributosen relaciones ..............................................................................................130 2.2.1.1.2.10.4 Herencia....................................................................................................................130 2.2.1.1.2.10.5 Agregación................................................................................................................130 2.2.1.2 Ejemplo................................................................................................................................131 2.3 MODULO ENTORNO WEB..........................................................................................................137 2.3.1 Java WEB..............................................................................................................................137 2.3.1.1 Marco Teórico. .....................................................................................................................137 2.3.1.1.1 Introducción. ....................................................................................................................137 2.3.1.1.1.1 Modelo cliente-servidor.................................................................................................138 2.3.1.1.1.2 Acceso a Datos..............................................................................................................139 2.3.1.1.1.3 Formas de seguir la trayectoria de los usuarios (clientes) .................................................140 2.3.1.1.2 EJBs..................................................................................................................................141 2.3.1.1.2.1 Beneficios .....................................................................................................................141 2.3.1.1.2.2 Componentes................................................................................................................141 2.3.1.1.2.3 Desarrollar EJBs.............................................................................................................142 2.3.1.1.2.4 EJBs contra Servlets.......................................................................................................142 2.3.1.1.2.5 ¿Cúando usar EJBs? .......................................................................................................142 2.3.2 Framework...........................................................................................................................143 2.3.2.1 Marco Teórico. .....................................................................................................................143 2.3.2.1.1 ¿Qué es un Framework?....................................................................................................143 2.3.2.1.2 Objetivos de Usar un Framework .......................................................................................143 2.3.2.1.3 Modelo – Vista – Controlador............................................................................................145 2.3.2.1.4 Frameworks parael Modelo MVC ......................................................................................145 2.3.2.1.5 Struts................................................................................................................................146 2.3.2.1.5.1 Archivos de Configuración:.............................................................................................146
  6. 6. 6 2.3.2.1.6 Spring Framework.............................................................................................................147 ...........................................................147 2.3.2.1.7 Hibernate .........................................................................................................................147 2.3.3 Java Server...........................................................................................................................148 2.3.3.1 Marco Teórico. .....................................................................................................................148 2.3.3.1.1 Introducción a JSP. ............................................................................................................148 2.3.3.1.1.1 Estructura de una página JSP..........................................................................................148 2.3.3.1.1.1.1 Directivas..................................................................................................................148 2.3.3.1.1.1.2 Declaraciones............................................................................................................149 2.3.3.1.1.1.3 Scriptlets...................................................................................................................149 2.3.3.1.1.1.4 Variables Predefinidas................................................................................................149 2.3.3.1.1.1.5 Expresiones...............................................................................................................150 2.3.3.1.1.1.6 Etiquetasespecíficas de JSP........................................................................................150 2.3.3.1.1.1.7 Procesamiento de la página JSP..................................................................................151 2.3.3.1.1.1.8 Objetosimplícitos......................................................................................................151 3. REFERENCIAS. ..............................................................................................................................153
  7. 7. 7 2. DESARROLLO. 2.1 MODULO CONCEPTOS AVANZADOS DEL LENGUAJE. 2.1.1 Colecciones Java. 2.1.1.1 Marco Teórico. 2.1.1.1.1 Concepto. Una colección es un objeto que permite agrupar otros objetos. Generalmente, los elementos en una colección representan datos de una agrupación específico de objetos, como una colección de personas, casas. En una colección se pueden realizar operaciones sobre los objetos que están almacenados en su interior, así podemos almacenar, manipular, obtener y comunicar entre estos objetos. 2.1.1.1.2 Clases. 2.1.1.1.2.1 Interfaces Las interfaces permiten a las colecciones ser manipuladas con un cierto comportamiento independiente o particular. A continuación se muestra su jerarquía: Interfaces principales para el Collection Framework Las interfaces Collection y Map son los padres de las interfaces en el Framework de colecciones de Java. Es notorio que la jerarquía consta de dos diferentes árboles. Hay que tomar en cuenta que las interfaces son genéricas, public interface Collection<E>... La sintaxis <E> indica que es una interfaz genérica. Cuando se declara una instancia de Collection, se puede especificar el tipo de objeto que esta va a contener. Esto
  8. 8. 8 permite que el compilador verifique el tipo de objeto que se va a poner dentro de la colección sea el indicado (compile-time), lo cual reduce el número de errores en tiempo de ejecución (runtime). 2.1.1.1.2.2 Métodos: Esta interfaz tiene métodos, entre ellos:  size: que permite saber cuántos elementos existen en la colección.  isEmpty: verifica si la colección se encuentra vacía.  contains: chequea si un elemento específico se encuentra en la colección.  add: para agregar un elemento a la colección.  remove: para eliminar un elemento de la colección.  iterator: para iterar sobre la colección. 2.1.1.1.2.3 Iterando Colecciones. Existen dos formas de recorrer una colección.  Mediante for-each  Usando iteradores 2.1.1.1.2.3.1 for-each Permite atravesar la colección o arreglo usando un bucle for. for(Object o: collection) System.out.println(o); 2.1.1.1.2.3.2 Iteradores Un iterador es un objeto que permite recorrer una colección y remover elementos de la misma selectivamente. Se obtiene un iterador de una colección llamando al método iterator. La interfaz Iterator se muestra a continuación: public interface Iterator<E> { boolean hasNext(); E next();
  9. 9. 9 void remove(); //optional } Los métodos hasNext retorna true si la iteración contiene más elementos, y el método next retorna el siguiente elemento en la iteración. El método remove, remueve el último elemento que fue retornado por next de la colección que está siendo iterada. El método remove solo puede ser llamado una vez por llamada de next y lanza una excepción si esta regla es violada. El siguiente método realiza una eliminación de elementos de la colección static void filter(Collection<String> c) { for (Iterator<String> it = c.iterator(); it.hasNext(); ) if (!cond(it.next())) it.remove(); } 2.1.1.1.2.4 Operaciones entre colecciones y arreglos El método toArray provee un puente entre las colecciones y los arreglos. Las operaciones de arreglos permiten al contenido de una colección ser transformada en un arreglo. La forma más simple sin argumentos crea un nuevo arreglo tipo Object. La otra forma de este método permite especificar el tipo de salida que tendrá el arreglo. Suponiendo que c es de tipo Collection, la siguiente expresión envía el contenido de esta hacia un arreglo de Object cuya longitud es igual al número de elementos en c. Object[] a = c.toArray(); Ahora suponiendo que c contiene solo elementos tipo String (Collection<String>), la siguiente sentencia manda el contenido de c hacia un arreglo de objetos tipo String. String[] a = c.toArray(new String[0]);
  10. 10. 10 2.1.1.2 Ejemplo. 2.1.1.2.1 List import java.util.ArrayList; import java.util.Iterator; /** * * @author laboratorio6 */ public class TestArrayList { public static void main(String[] args) { ArrayList ciudades = new ArrayList();// nos permite acceder a cada uno de los objetos en el orden q deseemos y los presenta en forma aleatoria ciudades.add("Machala");// al colocar el add te permite guardar los objetos que se presentaran en la lista ciudades.add("Guayaquil"); ciudades.add("Quito"); ciudades.add("Cuenca"); ciudades.add(1,"Loja"); ciudades.add("Machala");//si presenta los elementos repetidos Iterator it = ciudades.iterator();//devuelve la coleccion de la lista osea cada uno de los objetos q hemos guardado while (it.hasNext()) { System.out.println("Ciudad: " + it.next());// mediante el next va acceder a los objetos q se han guardado en la lista } } } import java.util.*; /** *
  11. 11. 11 * @author laboratorio6 */ public class TestArrayList2 { public static void main(String[] args) { ArrayList ciudades = new ArrayList();// nos permite acceder a cada uno de los objetos en el orden q deseemos y los presenta en forma aleatoria ciudades.add("Machala");// al colocar el add te permite guardar los objetos que se presentaran en la lista ciudades.add("Guayaquil"); ciudades.add("Quito"); ciudades.add("Cuenca"); ciudades.add(1, "Loja"); ciudades.add("Machala");//si presenta los elementos repetidos for(int i =ciudades.size()-1;i>=0;i--) {//accede a los elementos y los presenta desde el ultimo hacia el primero posición System.out.println("Ciudad: " +i + "es: " + ciudades.get(i));// mediante el next va acceder a los objetos q se han guardado en la lista } } } import java.util.Iterator; import java.util.LinkedList; /** * * @author laboratorio6 */ public class TestLinkedList { public static void main(String[] args) { LinkedList ciudades = new LinkedList();// nos permite acceder a cada uno de los objetos en el orden q deseemos y los presenta en forma aleatoria
  12. 12. 12 ciudades.add("Machala");// al colocar el add te permite guardar los objetos que se presentaran en la lista ciudades.add("Guayaquil"); ciudades.add("Quito"); ciudades.add("Cuenca"); ciudades.add(1,"Loja"); ciudades.add("Machala");//si presenta los elementos repetidos Iterator it = ciudades.iterator();//devuelve la coleccion de la lista osea cada uno de los objetos q hemos guardado while (it.hasNext()) { System.out.println("Ciudad: " + it.next());// mediante el next va acceder a los objetos q se han guardado en la lista } } } import java.util.*; /** * * @author laboratorio6 */ public class TestVector { public static void main(String[] args) { Vector ciudades = new Vector();// nos permite acceder a cada uno de los objetos en el orden q deseemos y los presenta en forma aleatoria ciudades.add("Machala");// al colocar el add te permite guardar los objetos que se presentaran en la lista ciudades.add("Guayaquil"); ciudades.add("Quito"); ciudades.add("Cuenca"); ciudades.add(1, "Loja"); ciudades.add("Machala");//si presenta los elementos repetidos
  13. 13. 13 for (int i = ciudades.size() - 1; i >= 0; i--) {//accede a los elementos y los presenta desde el ultimo hacia el primero posicion System.out.println("Ciudad: " + i + "es: " + ciudades.get(i));// mediante el next va acceder a los objetos q se han guardado en la lista } } } 2.1.1.2.2 Map import java.util.*; public class TestHashMap { public static void main(String [] args){ HashMap codigos = new HashMap(); codigos.put("01","urgente"); codigos.put("02", "importante"); codigos.put("03", "normal"); codigos.put("04", "baja prioridad"); System.out.println("Aleatorio 01: "+ codigos.get("04")); System.out.println("Aleatorio 02: "+ codigos.get("03")); Set s = codigos.keySet(); Iterator it = s.iterator(); while(it.hasNext()){ String aux = (String)it.next(); System.out.println(aux+":"+codigos.get(aux)); } } } import java.util.*;
  14. 14. 14 /** * * @author laboratorio6 */ public class TestHashTable { public static void main(String [] args){ Hashtable codigos = new Hashtable(); codigos.put("01","urgente"); codigos.put("02", "importante"); codigos.put("03", "normal"); codigos.put("04", "baja prioridad"); System.out.println("Aleatorio 01: "+ codigos.get("04")); System.out.println("Aleatorio 02: "+ codigos.get("03")); Set s = codigos.keySet(); Iterator it = s.iterator(); while(it.hasNext()){ String aux = (String)it.next(); System.out.println(aux+":"+codigos.get(aux)); } } } import java.util.*; /** * * @author laboratorio6 */ public class TestLinkedHashMap { public static void main(String [] args){
  15. 15. 15 LinkedHashMap codigos = new LinkedHashMap(); codigos.put("01","urgente"); codigos.put("02", "importante"); codigos.put("03", "normal"); codigos.put("04", "baja prioridad"); System.out.println("Aleatorio 01: "+ codigos.get("01")); System.out.println("Aleatorio 02: "+ codigos.get("02")); Set s = codigos.keySet(); Iterator it = s.iterator(); while(it.hasNext()){ String aux = (String)it.next(); System.out.println(aux+":"+codigos.get(aux)); } } } import java.util.*; /** * * @author laboratorio6 */ public class TestTreeMap { public static void main(String [] args){ TreeMap codigos = new TreeMap(); codigos.put("04", "baja prioridad"); codigos.put("01","urgente"); codigos.put("03", "normal"); codigos.put("02", "importante");
  16. 16. 16 System.out.println("Aleatorio 01: "+ codigos.get("04")); System.out.println("Aleatorio 02: "+ codigos.get("03")); Set s = codigos.keySet(); Iterator it = s.iterator(); while(it.hasNext()){ String aux = (String)it.next(); System.out.println(aux+":"+codigos.get(aux)); } } } 2.1.1.2.3 Set import java.util.*; public class TestHashSet { public static void main(String[] args) { HashSet ciudades = new HashSet();// es para crear una lista en la que no tenga importancia el orden retorna los elementos en forma aleatoria ciudades.add("Machala");// al colocar el add te permite guardar los objetos que se presentaran en la lista ciudades.add("Guayaquil"); ciudades.add("Quito"); ciudades.add("Cuenca"); ciudades.add("Loja"); ciudades.add("Machala"); Iterator it = ciudades.iterator();//devuelve la coleccion de la lista osea cada uno de los objetos q hemos guardado while(it.hasNext()){ System.out.println("Ciudad: "+it.next());// mediante el next va acceder a los objetos q se han guardado en la lista
  17. 17. 17 } } } import java.util.*; /** * * @author laboratorio6 */ public class TestLinkHashSet { public static void main(String[] args) { LinkedHashSet ciudades = new LinkedHashSet();// nos permite acceder a cada uno de los objetos en el orden q deseemos ciudades.add("Machala");// al colocar el add te permite guardar los objetos que se presentaran en la lista ciudades.add("Guayaquil"); ciudades.add("Quito"); ciudades.add("Cuenca"); ciudades.add("Loja"); ciudades.add("Machala"); Iterator it = ciudades.iterator();//devuelve la coleccion de la lista osea cada uno de los objetos q hemos guardado while (it.hasNext()) { System.out.println("Ciudad: " + it.next());// mediante el next va acceder a los objetos q se han guardado en la lista } } } import java.util.Iterator; import java.util.TreeSet; /**
  18. 18. 18 * * @author laboratorio6 */ public class TestTreeSet { public static void main(String[] args) { TreeSet ciudades = new TreeSet();// nos permite acceder a cada uno de los objetos en el orden q deseemos pero los presenta en orden alfabético ciudades.add("Machala");// al colocar el add te permite guardar los objetos que se presentaran en la lista ciudades.add("Guayaquil"); ciudades.add("Quito"); ciudades.add("Cuenca"); ciudades.add("Loja"); ciudades.add("Machala"); Iterator it = ciudades.iterator();//devuelve la coleccion de la lista osea cada uno de los objetos q hemos guardado while (it.hasNext()) { System.out.println("Ciudad: " + it.next());// mediante el next va acceder a los objetos q se han guardado en la lista } } } 2.1.1.2.4 Archivador import java.util.*; public class Archivador { private ArrayList pacientes = new ArrayList(); public void guardar(Fichas ficha) { pacientes.add(ficha); }
  19. 19. 19 public void eliminar(Fichas ficha) { pacientes.remove(ficha); } public void listar() { System.out.println("Numero de fichas de pacientes: " + pacientes.size()); Iterator iterator = pacientes.iterator(); while (iterator.hasNext()) { System.out.println((Fichas) iterator.next()); } } } public class Fichas { private String nombre = ""; private String apellido = ""; private int edad = 0; public Fichas(String nombre, String apellido, int edad) { this.nombre = nombre; this.apellido = apellido; this.edad = edad; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; }
  20. 20. 20 public String getApellido() { return apellido; } public void setApellido(String apellido) { this.apellido = apellido; } public int getEdad() { return edad; } public void setEdad(int edad) { this.edad = edad; } public String toString() { return "Nombre: " + nombre + " Apellido: " + apellido + " Edad: " + edad; } } public class testArchivador { public static void main(String[] args) { Archivador archivar = new Archivador(); Fichas fichas = new Fichas("Marthita","Rojas",22); archivar.guardar(fichas); archivar.listar(); fichas.toString(); } }
  21. 21. 21 2.1.2 AWT. 2.1.2.1 Marco Teórico. 2.1.2.1.1 El paquete AWT. Es una librería de clases Java para el desarrollo de interfaces de usuario gráficas (GUI). Por tratarse de código Java, las aplicaciones serán independientes de plataforma. No así su apariencia visual. Es la librería básica. Sobre ella se construyó a posteriori otra más flexible y potente: JFC/Swing. La AWT se encuentra en el paquete: java.awt.* Dispone de la mayoría de controles visuales estándar: Button, Canvas, Frame, Dialog, Label, List, Choice, ScrollBar, ScrollPane, TextField, TextArea, Menu. 2.1.2.1.2 Elementos. Los elementos básicos que componen esta librería son: Los componentes (java.awt.Component) como Buttons, Labels, TextFields, etc… Los contenedores (java.awt.Container) como los Frames, los Panels, etc… que pueden contener componentes. Los gestores de posición (java.awt.LayoutManager) que gestionan la disposición de los componentes dentro de los contenedores. Los eventos (java.awt.AWTEvent) que avisan de las acciones del usuario. 2.1.2.1.3 Jerarquía de Clases.
  22. 22. 22 2.1.2.1.4 Clases. 2.1.2.1.4.1 java.awt.Component Se trata de una clase abstracta que implementa toda la funcionalidad básica de las clases visuales, disponiendo de métodos para mostrar y esconder, habilitar, deshabilitar y atributos como el color del foreground y background, tamaño y posición. 2.1.2.1.4.2 java.awt.Container Se trata de una clase que implementa la funcionalidad de contener a otros componentes: Window, Dialog, FileDialog, Frame, Panel. 2.1.2.1.4.3 java.awt.LayoutManager Los contenedores sirven para agrupar componentes visuales. Pero, ¿cómo se distribuyen dichos componentes en su interior? Para ello, se utilizan implementaciones del interface java.awt.LayoutManager. Cada contenedor tiene asociado un LayoutManager que distribuye los componentes en el interior del contenedor. Por ejemplo, un Panel tiene asociado por defecto una instancia de java.awt.FlowLayout.
  23. 23. 23 2.1.2.1.5 Coordenadas y Posicionamiento. La posición de los componentes visuales es relativa al contenedor en el que se encuentra. La coordenada 0,0 es la esquina superior izquierda del contenedor. La clase java.awt.Component implementa varios métodos para la gestión del tamaño y posicionamiento como por ejemplo: Rectangle getBounds( ); Dimension getSize( ); void setLocation(int x, int y); void setSize(Dimension d); Point getLocation( ); Container getParent( ); void setBounds(int x, int y, int width, int height); La clase java.awt.Container posee varios métodos para acceder a los componentes que contienen como por ejemplo: add(Component c) Inserta el componente c en el contenedor que utiliza el método. remove(Component c) Elimina el componente c en el contenedor que utiliza el método. Component[] getComponents( ) Devuelve un array con los componentes del contenedor 2.1.2.1.6 Pasos a seguir: Crear el componente Button b=new Button( ); Añadir el componente al contenedor unContenedor.add(b); Invocar métodos sobre el componente y manejar sus eventos. b.setText(“Ok”); 2.1.2.1.7 Layout Managers. Todos los contenedores AWT tienen asociado un LayoutManager para coordinar el tamaño y la situación de sus componentes (Panel->FlowLayout, Frame->BorderLayout). Cada Layout se caracteriza por el estilo que emplea para situar los componentes en su interior: Alineación de izquierda a derecha, Alineación en rejilla, Alineación del frente a atrás. 2.1.2.1.7.1 ¿Por qué usar Layout Managers? Determinan el tamaño y la posición de los componentes en un contenedor. Tiene un API que permite al contenedor y al LayoutManager gestionar el cambio de tamaño de contenedor de manera transparente. Consiguen que la aplicación sea independiente de la resolución de las máquinas donde se ejecuta. Implementan el interface java.awt.LayoutManager.
  24. 24. 24 FlowLayout: sitúa los componentes de izquierda a derecha. Les modifica la posición pero no les modifica el tamaño. BorderLayout: se basa en los puntos cardinales. Modifica tanto la posición como el tamaño de los componentes. CardLayout: permite al desarrollador intercambiar distintas vistas como si se tratase de una baraja. Modifica tanto la posición como el tamaño de los componentes. GridLayout: usa una matriz en la que sitúa cada uno de los componentes. El tamaño de todas las celdas es igual. GridBagLayout: similar al anterior, pero no fuerza a que todos los componentes tengan el mismo tamaño. 2.1.2.1.8 Eventos. Un evento es una encapsulación de una información que puede ser enviada a la aplicación de manera asíncrona. Pueden corresponder a acciones físicas (ratón y teclado) y a acciones lógicas. java.util.EventObject es la clase padre de todos los eventos. Su subclase java.awt.AWTEvent es la clase padre de todos los eventos AWT. Los eventos contienen un id (int que describe el tipo de evento). También contiene información sobre el origen del evento (getSource( );). El manejo de eventos se consigue mediante el uso de interfaces definidos en el paquete java.awt.event: ActionListener, WindowListener, KeyListener, MouseListener,… 2.1.2.1.8.1 Tipos de eventos: 2.1.2.1.8.1.1 Físicos: ComponentEvent: Esconder, mover, redimensionar, mostrar. ContainerEvent: Añadir o eliminar un componente. FocusEvent: Obtener o perder foco. KeyEvent: Pulsar, liberar o teclear una tecla. MouseEvent: Entrar, salir, pulsar, soltar, clicar. 2.1.2.1.8.1.2 Semánticos: ActionEvent: Una acción se ha ejecutado.
  25. 25. 25 AdjustmentEvent: Un valor se ha ajustado. ItemEvent: Un estado ha cambiado. TextEvent: Un texto ha cambiado.
  26. 26. 26
  27. 27. 27 2.1.2.1.9 Adapters. Son clases que tienen definidos todos los métodos de un interface concreto. La implementación de dichos métodos está vacía. Heredando de un Adapter, y sobrescribiendo los métodos necesarios conseguimos el mismo interface. Problema: en Java no existe la herencia múltiple, por ello se suelen usar con las Clases Anónimas.
  28. 28. 28 2.1.2.2 Ejemplos. 2.1.2.2.1 Button. package AWT; import java.awt.*; /** * * @author MARTHA */ public class ButtonTest { public static void main(String [] args){ Frame f = new Frame();//instanciando un objeto de la clase formulario awt f.setTitle("Button Test");//setTitle nos permite añadir un titulo al formulario f.setSize(200, 150);//setSIze es para colocar el tamaño del formulario tanto largo como ancho f.setLayout(new FlowLayout());//setLayout es para defirnir el tipo de contenedor Button button = new Button("OK");//instanciamiento de un objeto de la clase boton awt f.add(button);//add nos permite añadir compnentes al formulario en este caso un boton f.setVisible(true);//setVisible es para poder visualizar el formulario } } 2.1.2.2.2 CheckBox import java.awt.*;
  29. 29. 29 /** * * @author laboratorio6 */ public class CheckBoxTest { public static void main(String [] args){ Frame frame = new Frame();//instanciando un objeto de la clase formulario awt frame.setTitle("CheckBoxTest");//setTitle nos permite añadir un titulo al formulario frame.setSize(200, 150);//setSIze es para colocar el tamaño del formulario tanto largo como ancho frame.setLayout(new FlowLayout());//setLayout es para defirnir el tipo de contenedor Checkbox cb = new Checkbox("Mayor de 18 años");//instanciando un objeto de la clase checkbox awt //y en () se coloca el titulo frame.add(cb);//add nos permite añadir compnentes al formulario frame.setVisible(true);//setVisible es para poder visualizar el formulario } } 2.1.2.2.3 CheckBoxGroup import java.awt.*; /** * * @author laboratorio6 */
  30. 30. 30 public class CheckboxGroupTest { public static void main(String []args){ Frame frame = new Frame();//instanciando un objeto de la clase formulario awt frame.setTitle("CheckboxGroupTest");//setTitle nos permite añadir un titulo al formulario frame.setSize(200, 150);//setSIze es para colocar el tamaño del formulario tanto largo como ancho frame.setLayout(new FlowLayout());//setLayout es para defirnir el tipo de contenedor CheckboxGroup cbg = new CheckboxGroup(); Checkbox cb1 = new Checkbox("Hombre",cbg,true);//instanciando un objeto de la clase checkbox awt //y en () se coloca el titulo //cbg es el objeto del checkboxgroyp, //true para mostrar seleccionado el cb Checkbox cb2 = new Checkbox("Mujer",cbg,false);//instanciando un objeto de la clase checkbox awt //y en () se coloca el titulo //cbg es el objeto del checkboxgroyp, //false para no mostrar seleccionado el cbo frame.add(cb1);//add nos permite añadir compnentes al formulario frame.add(cb2);//add nos permite añadir compnentes al formulario frame.setVisible(true);//setVisible es para poder visualizar el formulario } }
  31. 31. 31 2.1.2.2.4 Choise import java.awt.*; /** * * @author laboratorio6 */ public class ChoiseTest { public static void main(String [] args){ Frame frame = new Frame();//instanciando un objeto de la clase formulario awt frame.setTitle("ChoiseTest");//setTitle nos permite añadir un titulo al formulario frame.setSize(200,150);//setSIze es para colocar el tamaño del formulario tanto largo como ancho frame.setLayout(new FlowLayout());//setLayout es para defirnir el tipo de contenedor Choice ch = new Choice();//instanciando un objeto de la clase choise awt ch.add("Rojo");//add nos permite añadir compnentes a la lista choice ch.add("Amarillo");//add nos permite añadir compnentes a la lista choice ch.add("Blanco");//add nos permite añadir compnentes a la lista choice frame.add(ch);//add nos permite añadir compnentes al formulario frame.setVisible(true);//setVisible es para poder visualizar el formulario } }
  32. 32. 32 2.1.2.2.5 Frame import java.awt.Frame; /** * * @author MARTHA */ public class FrameTest { public static void main(String [] args){ Frame f = new Frame();//instanciando un objeto de la clase formulario awt f.setTitle("Frame Test");//setTitle nos permite añadir un titulo al formulario f.setSize(200, 150);//setSIze es para colocar el tamaño del formulario tanto largo como ancho f.setVisible(true);//setVisible es para poder visualizar el formulario } } 2.1.2.2.6 Label import java.awt.*; /** * * @author laboratorio6 */ public class LabelTest { public static void main(String []args){
  33. 33. 33 Frame frame = new Frame();//instanciando un objeto de la clase formulario awt frame.setTitle("LabelTest");//setTitle nos permite añadir un titulo al formulario frame.setSize(200, 150);//setSIze es para colocar el tamaño del formulario tanto largo como ancho frame.setLayout(new FlowLayout());//setLayout es para defirnir el tipo de contenedor Label lbl1 = new Label("Una etiqueta");//instanciando un objeto de la clase formulario awt //en () se coloca el título del label Label lbl2 = new Label();//instanciando un objeto de la clase formulario awt lbl2.setText("Otra Etiqueta");//setText nos permite colocar el título del label frame.add(lbl1);//add nos permite añadir compnentes al formulario frame.add(lbl2);//add nos permite añadir compnentes al formulario frame.setVisible(true);//setVisible es para poder visualizar el formulario } } 2.1.2.2.7 List import java.awt.*; /** * * @author laboratorio6 */
  34. 34. 34 public class ListTest { public static void main (String [] args){ Frame frame = new Frame();//instanciando un objeto de la clase formulario awt frame.setTitle("ListTest");//setTitle nos permite añadir un titulo al formulario frame.setSize(200, 150);//setSIze es para colocar el tamaño del formulario tanto largo como ancho frame.setLayout(new FlowLayout());//setLayout es para defirnir el tipo de contenedor List l = new List();//instanciando un objeto de la clase list awt l.add("Primero");//add nos permite añadir compnentes a la lista l.add("Segundo");//add nos permite añadir compnentes a la lista l.add("Tercero");//add nos permite añadir compnentes a la lista l.add("Cuarto");//add nos permite añadir compnentes a la lista frame.add(l);//add nos permite añadir compnentes al formulario frame.setVisible(true);//setVisible es para poder visualizar el formulario } } 2.1.2.2.8 Panel import java.awt.*; /** * * @author laboratorio6 */
  35. 35. 35 public class EjemploAWT { public static void main(String [] args){ Frame frame = new Frame();//instanciando un objeto de la clase formulario awt frame.setLayout(null);//setLayout es para defirnir el tipo de contenedor frame.setBounds(0, 0, 400, 300);//setBounds es para colocar el tamaño de un componente frame.setTitle("Ejemplo AWT");//setTitle nos permite añadir un titulo al formulario Panel panel = new Panel();//instanciando un objeto de la clase panel awt panel.setLayout(null);//setLayout es para defirnir el tipo de contenedor panel.setBounds(50, 40, 250, 220);//setBounds es para colocar el tamaño de un componente panel.setBackground(Color.PINK); Button boton = new Button();//instanciando un objeto de la clase button awt boton.setBounds(100, 80, 100, 20);//setBounds es para colocar el tamaño de un componente panel.add(boton);//add nos permite añadir compnentes al panel frame.add(panel);//add nos permite añadir compnentes al formulario frame.setVisible(true);//setVisible es para poder visualizar el formulario } }
  36. 36. 36 2.1.2.2.9 Scrollbar import java.awt.*; import javax.swing.plaf.ScrollBarUI; /** * * @author laboratorio6 */ public class ScrollbarTest { public static void main(String[] args) { Frame frame = new Frame();//instanciando un objeto de la clase formulario awt frame.setTitle("Scrollbar Test");//setTitle nos permite añadir un titulo al formulario frame.setSize(200, 150);//setSIze es para colocar el tamaño del formulario tanto largo como ancho frame.setLayout(new FlowLayout());//setLayout es para defirnir el tipo de contenedor Scrollbar sb = new Scrollbar(Scrollbar.HORIZONTAL,0,5,-100,300); frame.add(sb);//add nos permite añadir compnentes al formulario frame.setVisible(true);//setVisible es para poder visualizar el formulario } }
  37. 37. 37 2.1.2.2.10 TextField import java.awt.*; public class TextFieldText { public static void main(String[] args) { Frame f = new Frame();//instanciando un objeto de la clase formulario awt f.setTitle("TextField Test");//setTitle nos permite añadir un titulo al formulario f.setSize(200, 150);//setSIze es para colocar el tamaño del formulario tanto largo como ancho f.setLayout(new FlowLayout());//setLayout es para defirnir el tipo de contenedor TextField txt = new TextField("Escribe aqui...");//instanciando un objeto de la clase textfield awt //en () se coloca el título del textfield f.add(txt);//add nos permite añadir compnentes al formulario f.setVisible(true);//setVisible es para poder visualizar el formulario } }
  38. 38. 38 2.1.3 Swing. 2.1.3.1 Marco Teórico. 2.1.3.1.1 El paquete Swing. Hereda de la clase java.awt.Container. Se trata de una clase abstracta que implementa toda la funcionalidad básica de las clases visuales: Ayudas emergentes, bordes, gestión del Look & Feel, gestión de la accesibilidad, gestión de teclas asociadas, soporte de Drag & Drop. 2.1.3.1.2 Migrando de AWT a Swing Se eliminan todos los import de paquetes java.awt.*. Se importa el paquete javax.swing.*. Se cambia cada componente AWT por el Swing más parecido. Frame->JFrame, Button->JButton NOTA: No se pueden añadir componentes o establecer LayoutManagers directamente sobre JWindow, JFrame, JDialog o JApplet. Esto hay que hacerlo sobre el Container que devuelve el método: public Container getContentPane( ). 2.1.3.1.3 Layout Managers Todos los contenedores Swing tienen asociado un LayoutManager para coordinar el tamaño y la situación de sus componentes. JPanel->FlowLayout, JFrame->BorderLayout. Cada Layout se caracteriza por el estilo que emplea para situar los componentes en su interior:  Alineación de izquierda a derecha.  Alineación en rejilla.  Alineación del frente a atrás. BoxLayout: sitúa los componentes en línea vertical u horizontal, respetando sus tamaños. La clase javax.swing.Box tiene métodos para crear zonas con espacio como createVerticalStrut(int) y zonas que absorban los espacios como createVerticalGlue(int). SpringLayout: permite definir la relación (distancia) entre los límites de los distintos controles.
  39. 39. 39 ScrollPaneLayout, ViewportLayout: utilizados internamente por Swing para algunos de los componentes como el ScrollPane.
  40. 40. 40 2.1.3.2 Ejemplo. import java.awt.Button; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; /** * * @author MARTHA */ public class ActionListenerTest implements ActionListener { public void actionPerformed(ActionEvent ev) { if (((Button) ev.getSource()).getLabel().equals("Aceptar")) { System.out.println("Has pulsado Aceptar"); } else { System.out.println("Has pulsado Cancelar"); } } } import java.awt.BorderLayout; import java.awt.Button; import java.awt.FlowLayout; import java.awt.Frame; /** * * @author MARTHA */ public class BorderLayoutTest { public static void main(String[] args) {
  41. 41. 41 Frame f = new Frame(); f.setTitle("FlowLayout Test"); f.setSize(200, 150); f.setLayout(new BorderLayout()); Button b1 = new Button("Button 1 (Norte)"); f.add(b1, BorderLayout.NORTH); Button b2 = new Button("Button 2 (Este)"); f.add(b2, BorderLayout.WEST); Button b3 = new Button("Button 3 (centro)"); f.add(b3, BorderLayout.CENTER); Button b4 = new Button("Button 4 (este)"); f.add(b4, BorderLayout.EAST); Button b5 = new Button("Button 5 (sur)"); f.add(b5, BorderLayout.SOUTH); f.setVisible(true); } } import java.awt.Button; import java.awt.FlowLayout; import java.awt.Frame; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; /** * * @author MARTHA */ public class ButtonEventTest { public static void main(String[] args) { Frame f = new Frame();
  42. 42. 42 f.setTitle("Button Event Test"); f.setSize(200, 150); f.setLayout(new FlowLayout()); Button b1 = new Button("Aceptar"); b1.addActionListener(new ActionListenerTest()); f.add(b1); Button b2 = new Button("Cancelar"); b2.addActionListener(new ActionListenerTest()); f.add(b2); f.setVisible(true); } } import java.awt.Button; import java.awt.CardLayout; import java.awt.FlowLayout; import java.awt.Frame; /** * * @author MARTHA */ public class CardLayoutTest { public static void main(String[] args) { Frame f = new Frame(); f.setTitle("CardLayout Test"); f.setSize(200, 150); CardLayout cl = new CardLayout(); f.setLayout(cl); Button b1 = new Button("Button 1");
  43. 43. 43 f.add(b1, "uno"); Button b2 = new Button("Button 2"); f.add(b2, "dos"); Button b3 = new Button("Button 3"); f.add(b3, "tres"); f.setVisible(true); cl.show(f, "dos"); } } import java.awt.Button; import java.awt.Cursor; import java.awt.FlowLayout; import java.awt.Frame; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; /** * * @author MARTHA */ public class CursorTest { Frame f = null; public static void main(String[] args) { new CursorTest(); } public CursorTest() { f = new Frame(); f.setTitle("CursorTest");
  44. 44. 44 f.setSize(300, 150); f.setLayout(new FlowLayout()); Button b1 = new Button("Aceptar"); b1.addMouseListener(new MouseAdapter() { public void mouseEntered(MouseEvent ev) { f.setCursor(Cursor.HAND_CURSOR); } public void mouseExited(MouseEvent ev) { f.setCursor(Cursor.DEFAULT_CURSOR); } }); f.add(b1); f.setVisible(true); } } import java.awt.*; /** * * @author MARTHA */ public class DialogTest { public static void main(String[] args) { Frame f = new Frame(); f.setTitle("Dialog Test"); f.setSize(200, 150); f.setVisible(true); Dialog d = new Dialog(f);
  45. 45. 45 d.setTitle("Dialog Test"); d.setBounds(50, 50, 70, 50); d.setVisible(true); } } import java.awt.*; public class FileDialogTest { public static void main(String[] args) { Frame f = new Frame(); f.setTitle("Dialog Test"); f.setSize(200, 150); f.setVisible(true); FileDialog d = new FileDialog(f); d.setTitle("FileDialog Test"); d.setBounds(50, 50, 70, 50); d.setVisible(true); System.out.println(d.getFile()); } } import java.awt.*; /** * * @author MARTHA */ public class FlowLAyoutTest {
  46. 46. 46 public static void main(String[] args) { Frame f = new Frame(); f.setTitle("FlowLayout Test"); f.setSize(200, 150); f.setLayout(new FlowLayout()); Button b1 = new Button("Button 1"); f.add(b1); Button b2 = new Button("Button 2"); f.add(b2); Button b3 = new Button("Button 3"); f.add(b3); f.setVisible(true); } } import java.awt.Button; import java.awt.FlowLayout; import java.awt.Font; import java.awt.Frame; import java.awt.Label; import javax.swing.JLabel; /** * * @author MARTHA */ public class FontTest { public static void main(String[] args) { Frame f = new Frame(); f.setTitle("Font Test"); f.setSize(200, 200);
  47. 47. 47 f.setLayout(new FlowLayout()); Label l1 = new Label("Marthita"); l1.setFont(new Font("Marthita",Font.BOLD,20)); Label l2 = new Label("Carolina"); l2.setFont(new Font("Carolina",Font.BOLD,20)); Label l3 = new Label("David"); l3.setFont(new Font("David",Font.PLAIN,20)); Label l4 = new Label("Marianela"); l4.setFont(new Font("Marianela",Font.BOLD,20)); Label l5 = new Label("Danilo"); l5.setFont(new Font("Danilo",Font.PLAIN,20)); f.add(l1); f.add(l2);f.add(l3);f.add(l4);f.add(l5); f.setVisible(true); } } import java.awt.Color; import java.awt.Font; import java.awt.Frame; import java.awt.Graphics; /** * * @author MARTHA */ public class GraphicsTest extends Frame { public static void main(String[] args) { new GraphicsTest().setVisible(true); } public GraphicsTest() {
  48. 48. 48 this.setTitle("Graphics Test"); this.setBackground(Color.LIGHT_GRAY); this.setSize(300, 150); } public void paint(Graphics g) { g.setColor(Color.LIGHT_GRAY); g.draw3DRect(10, 30, this.getWidth() - 20, this.getWidth() - 40, true); g.setColor(Color.BLACK); g.drawLine(15, 35, 65, 65); g.drawRect(70, 35, 50, 30); g.drawRoundRect(125, 35, 50, 30, 10, 10); g.drawOval(180, 35, 50, 30); g.drawArc(235, 35, 50, 30, 25, 200); int[] x = {15, 65, 15, 65}; int[] y = {90, 90, 120, 120}; g.drawPolygon(x, y, x.length); g.setColor(Color.red); g.fillRect(70, 90, 50, 30); g.fillRoundRect(125, 90, 50, 30, 10, 10); g.fillOval(180, 90, 50, 30); g.fillArc(235, 90, 50, 30, 25, 200); g.setColor(Color.BLACK); g.setFont(new Font("Marthita", Font.ITALIC, 9)); g.drawString("Linea", 30, 80); g.drawString("Rectangulo", 90, 80); g.drawString("Ovalo", 192, 80); g.drawString("Arco", 250, 80); g.drawString("Poligono", 22, 135); g.drawString("Rectangulos", 95, 135); g.drawString("Ovalo", 192, 135);
  49. 49. 49 g.drawString("Arco", 250, 135); } } import java.awt.Button; import java.awt.Frame; import java.awt.GridLayout; /** * * @author MARTHA */ public class GridLayoutTest { public static void main(String[] args) { Frame f = new Frame(); f.setTitle("GridLayout Test"); f.setSize(200, 150); f.setLayout(new GridLayout(2, 3, 2, 2)); f.add(new Button("Boton 1")); f.add(new Button("Boton 2")); f.add(new Button("Boton 3")); f.add(new Button("Boton 4")); f.add(new Button("Boton 5")); f.setVisible(true); } } import java.awt.Color; import javax.swing.JColorChooser; import javax.swing.JFileChooser; import javax.swing.JFrame;
  50. 50. 50 /** * * @author MARTHA */ public class JColorChooserTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JColorChooser Test"); f.setSize(200, 150); f.setVisible(true); JFileChooser fc = new JFileChooser(); int op = fc.showOpenDialog(fc); if (op == JFileChooser.APPROVE_OPTION) { System.out.println(fc.getSelectedFile()); } } } import java.awt.FlowLayout; import javax.swing.JComboBox; import javax.swing.JFrame; /** * * @author MARTHA */ public class JComboBoxTest { public static void main(String[] args) {
  51. 51. 51 JFrame f = new JFrame(); f.setTitle("JComboBox Test"); f.setSize(200, 150); f.getContentPane().setLayout(new FlowLayout()); String[] lista= {"Martha","Carolina","Marianela"}; JComboBox jcb = new JComboBox(lista); f.getContentPane().add(jcb); f.setVisible(true); } } import java.awt.Color; import javax.swing.JColorChooser; import javax.swing.JFrame; /** * * @author MARTHA */ public class JFileChooserTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JFileChooser Test"); f.setSize(200, 150); f.setVisible(true); Color c = JColorChooser.showDialog(f, "Seleccione un color", Color.RED); System.out.println("El color seleccionado es: " + c); } }
  52. 52. 52 import javax.swing.JFrame; /** * * @author MARTHA */ public class JFrameTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JFrame Test"); f.setSize(200, 150); f.setVisible(true); } } import javax.swing.JFrame; import javax.swing.JInternalFrame; /** * * @author MARTHA */ public class JInternalFrameTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JInternalFrame Test"); f.setSize(230, 200); f.getContentPane().setLayout(null); JInternalFrame f1 = new JInternalFrame("Internal Frame 1"); f1.setBounds(10, 10, 150, 100);
  53. 53. 53 f1.setVisible(true); JInternalFrame f2 = new JInternalFrame("Internal Frame 2"); f2.setBounds(50, 50, 150, 100); f2.setVisible(true); f.getContentPane().add(f1); f.getContentPane().add(f2); f.setVisible(true); } } import java.awt.FlowLayout; import javax.swing.JFrame; import javax.swing.JList; /** * * @author MARTHA */ public class JListTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JList Test"); f.setSize(200, 150); f.getContentPane().setLayout(new FlowLayout()); String[] lista = {"Martha", "Carolina", "Marianela", "Steve"}; JList jl = new JList(lista); f.getContentPane().add(jl); f.setVisible(true); } } import javax.swing.JCheckBoxMenuItem;
  54. 54. 54 import javax.swing.JFrame; import javax.swing.JMenu; import javax.swing.JMenuBar; import javax.swing.JMenuItem; /** * * @author MARTHA */ public class JMenuBarTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JMenuBar Test"); f.setSize(200, 150); JMenuBar jmb = new JMenuBar(); JMenu m1 = new JMenu("Menu 1"); m1.add(new JMenuItem("Opcion 1")); m1.add(new JMenuItem("Opcion 2")); JMenu m2 = new JMenu("Menu 2"); m2.add(new JCheckBoxMenuItem("Opcion 1")); m2.add(new JCheckBoxMenuItem("Opcion 2", true)); m2.addSeparator(); m2.add(new JCheckBoxMenuItem("Opcion 3", true)); jmb.add(m1); jmb.add(m2); f.setJMenuBar(jmb); f.setVisible(true); } } import java.awt.FlowLayout;
  55. 55. 55 import javax.swing.JFrame; import javax.swing.JPasswordField; /** * * @author MARTHA */ public class JPasswordFieldTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JPasswordField Test"); f.setSize(200, 150); f.getContentPane().setLayout(new FlowLayout()); JPasswordField pf = new JPasswordField("Marthita"); f.getContentPane().add(pf); f.setVisible(true); } } import java.awt.FlowLayout; import javax.swing.ButtonGroup; import javax.swing.JFrame; import javax.swing.JRadioButton; /** * * @author MARTHA */ public class JRadioButtonTest { public static void main(String[] args) {
  56. 56. 56 JFrame f = new JFrame(); f.setTitle("Test"); f.setSize(200, 150); f.getContentPane().setLayout(new FlowLayout()); ButtonGroup bg = new ButtonGroup(); JRadioButton b1 = new JRadioButton("Hombre", true); bg.add(b1); JRadioButton b2 = new JRadioButton("Mujer", false); bg.add(b2); f.getContentPane().add(b1); f.getContentPane().add(b2); f.setVisible(true); } } import java.awt.FlowLayout; import javax.swing.JFrame; import javax.swing.JSpinner; import javax.swing.SpinnerListModel; /** * * @author MARTHA */ public class JSpinnerTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JSpinner Test"); f.setSize(200, 150); f.getContentPane().setLayout(new FlowLayout()); String[] alumnos = {"Martha", "Carolina", "Marianela", "Steve"};
  57. 57. 57 SpinnerListModel modelo = new SpinnerListModel(alumnos); JSpinner js = new JSpinner(modelo); f.getContentPane().add(js); f.setVisible(true); } import java.awt.FlowLayout; import javax.swing.JFrame; import javax.swing.JTextArea; /** * * @author MARTHA */ public class JTextAreaTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JText Area"); f.setSize(200, 150); f.getContentPane().setLayout(new FlowLayout()); JTextArea txta = new JTextArea("Escribe aqui...", 5, 15); f.getContentPane().add(txta); f.setVisible(true); } } import java.awt.FlowLayout; import javax.swing.ButtonGroup; import javax.swing.JFrame; import javax.swing.JToggleButton; /** *
  58. 58. 58 * @author MARTHA */ public class JToggleButtonTest { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("JToggleButton"); f.setSize(200, 150); f.getContentPane().setLayout(new FlowLayout()); ButtonGroup bg = new ButtonGroup(); JToggleButton b1 = new JToggleButton("Hombre", true); bg.add(b1); JToggleButton b2 = new JToggleButton("Hombre", true); bg.add(b2); f.getContentPane().add(b1); f.getContentPane().add(b2); f.setVisible(true); } } import java.awt.*; public class MenuTest { public static void main(String[] args) { Frame f = new Frame(); f.setTitle("Menu Test"); MenuBar mb = new MenuBar(); Menu m = new Menu("Menu 1"); m.add(new MenuItem("opcion 1")); m.add(new MenuItem("opcion 2")); Menu m2 = new Menu("Menu 2"); m2.add(new CheckboxMenuItem("opcion 1", true));
  59. 59. 59 m2.add(new CheckboxMenuItem("opcion 2")); mb.add(m); mb.add(m2); f.setMenuBar(mb); f.setSize(200, 150); f.setVisible(true); } } import java.awt.Button; import java.awt.FlowLayout; import java.awt.Frame; /** * * @author MARTHA */ public class NullLayoutTest { public static void main(String[] args) { Frame f = new Frame(); f.setTitle("NullLayout Test"); f.setSize(300, 150); f.setLayout(null); Button b1 = new Button("Button 1"); b1.setBounds(50, 25, 100, 25); f.add(b1); Button b2 = new Button("Button 2"); b2.setBounds(125, 85, 100, 50); f.add(b2); f.setVisible(true); }
  60. 60. 60 } import java.awt.FlowLayout; import javax.swing.JButton; import javax.swing.JFrame; /** * * @author MARTHA */ public class Test { public static void main(String[] args) { JFrame f = new JFrame(); f.setTitle("Test"); f.setSize(200, 150); f.getContentPane().setLayout(new FlowLayout()); JButton b1 = new JButton("Ok"); f.getContentPane().add(b1); f.setVisible(true); } } import java.awt.*; /** * * @author MARTHA */ public class TextAreaTest { public static void main(String[] args) { Frame f = new Frame();
  61. 61. 61 f.setTitle("Text Area"); f.setSize(200, 100); f.setLayout(new FlowLayout()); TextArea txta = new TextArea("Escribe aqui...", 5, 15); f.add(txta); f.setVisible(true); } } import java.awt.*; /** * * @author MARTHA */ public class WindowEventTest1 { public static void main(String[] args) { Frame f = new Frame(); f.setTitle("Frame Test"); f.setSize(200, 150); f.addWindowListener(new WindowListenerTest()); f.setVisible(true); } } import java.awt.Frame; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; /**
  62. 62. 62 * * @author MARTHA */ public class WindowEventTest2 extends WindowAdapter { public static void main(String[] args) { WindowEventTest2 we = new WindowEventTest2(); } public WindowEventTest2() { Frame f = new Frame(); f.setTitle("Frame Test"); f.setSize(200, 150); f.addWindowListener(this); f.setVisible(true); } public void windowActived(WindowEvent ev) { } public void windowClosed(WindowEvent ev) { } public void windowClosing(WindowEvent ev) { System.exit(0); } public void windowDeactived(WindowEvent ev) { } public void windowDeiconified(WindowEvent ev) {
  63. 63. 63 } public void windowIconified(WindowEvent ev) { } } import java.awt.Frame; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; /** * * @author MARTHA */ public class WindowEventTest3 { public static void main(String[] args) { WindowEventTest3 we = new WindowEventTest3(); } public WindowEventTest3() { Frame f = new Frame(); f.setTitle("Frame Test"); f.setSize(200, 150); f.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent ev) { System.exit(0); } }); f.setVisible(true); } }
  64. 64. 64 import java.awt.Frame; import java.awt.event.*; /** @author MARTHA */ public class WindowListenerTest extends WindowAdapter{ public void windowClosing(WindowEvent ev) { System.exit(0); } }
  65. 65. 65 2.1.4 Applet. 2.1.4.1 Marco Teórico. 2.1.4.1.1 Concepto. Un applet Java es un applet escrito en el lenguaje de programación Java. Los applets de Java pueden ejecutarse en un navegador web utilizando la Java Virtual Machine (JVM), o en el AppletViewer de Sun. Entre sus características podemos mencionar un esquema de seguridad que permite que los applets que se ejecutan en el equipo no tengan acceso a partes sensibles (por ej. no pueden escribir archivos), a menos que uno mismo le dé los permisos necesarios en el sistema; la desventaja de este enfoque es que la entrega de permisos es engorrosa para el usuario común, lo cual juega en contra de uno de los objetivos de los Java applets: proporcionar una forma fácil de ejecutar aplicaciones desde el navegador web. En Java, un applet es un programa que puede incrustarse en un documento HTML, es decir en una página web. Cuando un navegador carga una página web que contiene un applet, este se descarga en el navegador web y comienza a ejecutarse. Esto permite crear programas que cualquier usuario puede ejecutar con tan solo cargar la página web en su navegador. 2.1.4.1.2 Atributos Atributo Descripción Ejemplo codebase Dirección desde donde se puede descargar la clase de Java que va a cargar el applet, el URL de la clase. Si no se especifica, será la ubicación actual de la página HTML. codebase="http://www.pagina.com/applet/" code Nombre de la clase que se quiere cargar en el applet. La dirección donde se encuentra es relativa al codebase. Si no se ha especificado codebase, es la code="NombreClase.class"
  66. 66. 66 misma carpeta donde está la página HTML que carga el applet. width Tamaño en píxels de la anchura. width=100 height Tamaño en píxels de la altura. height=100 alt Texto que se muestra donde debería cargarse el applet si el navegador no permite su carga. alt="Su navegador no permite cargar este Applet" name Establece un nombré único para el applet. name="MiApplet" archive Es un listado de clases separados por comas que deben ser cargados en la caché del usuario local antes de poder ejecutarse. archive="Clase1.class, Clase2.class, Clase3.class" hspace Establece los márgenes laterales en píxels. hspace=25 vspace Establece el margen superior e inferior en píxels. vspace=25 align Alineación respecto a otros elementos. Valores: left, center, rigth, top, middle y botton align="center" mayscript Permite especificar si el applet puede tener acceso al código JavaScript No tiene valor asociado. Si aparece se aplica. Dentro de la etiqueta <applet> puede aparecer la etiqueta <param> que contiene pares clave/valor, que son leídos por el programa Java, tantas veces como se quiera. 2.1.4.1.3 Etiqueta <object> A partir de la versión 4.0 de HTML se consideró obsoleto el uso de la etiqueta <applet>, siendo sustituida por <object>.
  67. 67. 67 Esta etiqueta es compatible con los navegadores Microsoft Internet Explorer, Netscape 6 (y versiones superiores) y Mozilla Firefox. Comparte muchos de los atributos con <applet>, siendo los únicos para esta etiqueta: Atributo Descripción Ejemplo classid Identificador del tipo de objeto. Para Java es: classid="clsid:CAFEEFAC-0014-0001- 0000-ABCDEFFEDCBA" codebase URL que apunta a un fichero .cab en la red del plugin necesario para poder ejecutar el contenido. codebase="Dirección_del_instalador_de_la_Máquin a_Virtual_Java" type Tipo de archivo que va a reproducirse mediante el objeto. <param name="type" value="application/x-java- applet;jpi-version=1.5.0"> 2.1.4.1.4 Ciclo de vida Cuando un applet se inicia, se llaman en este orden a los siguientes métodos:  init: suele contener instrucciones para inicializar el applet.  start: como init, se suele usar para inicializar, pero con la diferencia de que este método también se llama cuando se reinicia un applet.
  68. 68. 68  paint: se encarga de mostrar el contenido del applet. Se ejecuta cada vez que se tenga que redibujar. Para terminar o pausar la ejecución se llama a los siguientes métodos:  stop: suspende la ejecución del programa. Se llama cuando el applet se vuelve temporalmente invisible.  destroy: cuando no se va a necesitar más el applet. Se usa para liberar recursos.
  69. 69. 69 2.1.4.2 Ejemplo. 2.1.4.2.1 Hola mundo import javax.swing.*; /** * * @author MARTHA */ public class HelloWorld2 extends JApplet{ public void init(){ JLabel l = new JLabel("Hola Mundo!"); this.getContentPane().add(l); } } 2.1.4.2.2 Convertidor de Monedas public class Constantes { public static final String AUDIO =""; public static final String AYUDA =""; }
  70. 70. 70 import com.sun.xml.internal.messaging.saaj.soap.JpegDataContentHandler; import java.applet.AudioClip; import java.awt.BorderLayout; import java.awt.GridLayout; import java.awt.MenuItem; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JApplet; import javax.swing.JButton; import javax.swing.JComponent; import javax.swing.JLabel; import javax.swing.JMenu; import javax.swing.JMenuBar; import javax.swing.JMenuItem; import javax.swing.JOptionPane; import javax.swing.JPanel; import javax.swing.JTextField; import javax.swing.SwingConstants;
  71. 71. 71 /** * * @author MARTHA */ public class ConvertidorMoneda extends JApplet implements ActionListener { private JTextField moneda1 = null; private JTextField moneda2 = null; private AudioClip clip = null; @Override public void init() { JMenuBar barra = new JMenuBar(); JMenu menu1 = new JMenu("Menu"); JMenuItem menuitem1 = new JMenuItem("Ayuda"); menuitem1.setMnemonic('A'); menuitem1.setName("Menu Item 1"); menuitem1.addActionListener(this); menu1.add(menuitem1); barra.add(menu1); this.setJMenuBar(barra); this.getContentPane().setLayout(new BorderLayout()); moneda1 = new JTextField(); moneda1.setHorizontalAlignment(SwingConstants.RIGHT); moneda2 = new JTextField(); moneda2.setHorizontalAlignment(SwingConstants.RIGHT); JPanel aux = new JPanel(); aux.setLayout(new GridLayout(4, 2));
  72. 72. 72 aux.add(new JLabel(this.getParameter("Texto1"))); aux.add(moneda1); aux.add(new JLabel(this.getParameter("Texto2"))); aux.add(moneda2); this.getContentPane().add(aux, BorderLayout.NORTH); aux = new JPanel(); JButton convertir = new JButton(this.getParameter("Texto3")); convertir.setName("convertir"); convertir.addActionListener(this); aux.add(convertir); JButton limpiar = new JButton(this.getParameter("Texto4")); limpiar.setName("limpiar"); limpiar.addActionListener(this); aux.add(limpiar); this.getContentPane().add(aux, BorderLayout.SOUTH); clip = this.getAudioClip(this.getDocumentBase(), "audio1"); } @Override public void start() { //clip.loop(); } @Override public void stop() { //clip.stop(); }
  73. 73. 73 @Override public void actionPerformed(ActionEvent ev){ String temp = ((JComponent)ev.getSource()).getName(); if(temp.equals("convertir")){ try{ float tmp = Float.parseFloat(moneda1.getText()); tmp*=38.5F; moneda2.setText(Float.toString(tmp)); } catch(NumberFormatException ex){ JOptionPane.showMessageDialog(this,"Solo puede introducir numeros", "Mensaje de Eror", JOptionPane.ERROR_MESSAGE); moneda1.setText(""); } } else if(temp.equals("limpiar")){ moneda1.setText(""); moneda2.setText(""); } } }
  74. 74. 74 2.1.5 Manejo de Excepciones. 2.1.5.1 Marco Teórico. 2.1.5.1.1 Manejo de Excepciones Cuando un programa Java viola las restricciones semánticas del lenguaje (se produce un error), la máquina virtual Java comunica este hecho al programa mediante una excepción. La aplicación Java no debe morir y generar un core (o un crash en caso del DOS), al contrario, se lanza (throw) una excepción y se captura (catch) para resolver esa situación de error. 2.1.5.1.2 Generación de Excepciones en Java Para que se pueda lanzar una excepción es necesario crear un objeto de tipo Exception o alguna de sus subclases como ArithmeticException y lanzarlo mediante la instrucción throw como se muestra en el siguiente ejemplo: class LanzaExcepcion { public static void main(String argumentos[]) throws ArithmeticException { int i=1, j=2; if (i/j< 1) throw new ArithmeticException(); else System.out.println(i/j); } }
  75. 75. 75 2.1.5.1.3 Jerarquía de Clases 2.1.5.1.4 Captura de Excepciones Un manejador de excepciones es una porción de código que se va a encargar de tratar las posibles excepciones que se puedan generar. En Java, de forma similar a C++ se pueden tratar las excepciones previstas por el programador utilizando unos mecanismos, los manejadores de excepciones, que se estructuran en tres bloques:  El bloque try
  76. 76. 76  El bloque catch  El bloque finally (no existente en C++) 2.1.5.1.4.1 Try. Define un bloque de código donde se puede generar una excepción. El bloque try va seguido inmediatamente de uno o más bloques catch y opcionalmente de una cláusula finally. Cuando se lanza una excepción el control sale del bloque try actual y pasa a un manejador catch apropiado. La sintaxis general del bloque try consiste en la palabra clave try y una o más sentencias entre llaves. try { // Sentencias Java } Se pueden presentar dos situaciones diferentes a la hora de definir el bloque try:  Podemos tener más de una sentencia que generen excepciones, en cuyo caso podemos definir bloques individuales para tratarlos.  Podemos tener agrupadas en un mismo bloque try varias sentencias que puedan lanzar excepciones, con lo que habría que asociar múltiples controladores a ese bloque. 2.1.5.1.4.2 Catch Define el bloque de sentencias que se ejecutarán cuando se haya producido una excepción en un bloque try. La sintaxis general de la sentencia catch en Java es la siguiente: catch( TipoExcepcion nombreVariable ) { // sentencias Java
  77. 77. 77 } Se pueden colocar sentencias catch sucesivas, cada una controlando una excepción diferente. No debería intentarse capturar todas las excepciones con una sola cláusula ya que representa un uso demasiado general y podrían llegar muchas excepciones. catch( Exception e ) { … } //captura genérica 2.1.5.1.4.3 Finally El bloque finally se utiliza para ejecutar un bloque de instrucciones sea cual sea la excepción que se produzca. Este bloque se ejecutará en cualquier caso, incluso si no se produce ninguna excepción. Sirve para no tener que repetir código en el bloque try y en los bloques catch ... try { Bloque de Instrucciones del try } catch (TipoExcepción nombreVariable) { Bloque de Instrucciones del primer catch } catch (TipoExcepción nombreVariable) { Bloque de Instrucciones del segundo catch } ..... }finally { Bloque de Instrucciones de finally 2.1.5.1.5 Throw La sentencia throw se ejecuta para indicar que ha ocurrido una excepción, o lanzamiento de una excepción. La sentencia throw específica el objeto que se lanzará. La forma general de la sentencia throw es: throw ObjetoThrowable; El flujo de la ejecución se detiene inmediatamente después de la sentencia throw, y nunca se llega a la sentencia siguiente, ya que el control sale del bloque try y pasa a un manejador catch cuyo tipo coincide con el del objeto. Si se encuentra, el control se transfiere a esa sentencia. Si no, se inspeccionan los siguientes bloques hasta que el gestor de excepciones más externo detiene el programa.
  78. 78. 78 2.1.5.1.6 Tipos de excepciones 2.1.5.1.6.1 Excepciones Predefinidas Excepciones predefinidas más comunes:  ArithmeticException: Las excepciones aritméticas son típicamente el resultado de una división por 0: int i = 12 / 0;  NullPointerException: Se produce cuando se intenta acceder a una variable o método antes de ser definido.  ClassCastException: El intento de convertir un objeto a otra clase que no es válida. y = (Prueba)x; // donde x no es de tipo Prueba  NegativeArraySizeException: Puede ocurrir si se intenta definir el tamaño de un array con un número negativo.  ArrayIndexOutOfBoundsException: Se intenta acceder a un elemento de un array que está fuera de sus límites.  NoClassDefFoundException: Se referenció una clase que el sistema es incapaz de encontrar.
  79. 79. 79 2.1.5.2 Ejemplo. import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; /** * * @author MARTHA */ public class ExceptionTest { public static void main(String[] args) { File f = new File("d:test.txt"); FileInputStream fis = null; try { fis = new FileInputStream(f); } catch (FileNotFoundException ex) { System.out.println("Fichero no encontrado"); } finally { try { fis.close(); } catch (IOException ex) { System.out.println("Error al cerrar el fichero"); } } } } public class MiClase {
  80. 80. 80 public int miMetodo() throws MiException{ int num=(int)Math.rint(Math.random()); if(num==0){ throw new MiException("Salio un cero :("); } return num; } } public class MiException extends Exception{ public MiException(String parametro){ super(parametro); } } public class testException { public static void main (String [] args){ MiClase clasetest = new MiClase(); for(int i=0; i<20; i++){ try{ System.out.println(clasetest.miMetodo()); } catch(MiException ex){ System.out.println(ex.getMessage()); } } } }
  81. 81. 81 2.1.6 Threads. 2.1.6.1 Marco Teórico. 2.1.6.1.1 Programación Multihilo. Los threads son flujos de ejecución secuencial dentro de un proceso. Un mismo proceso Java puede tener un único thread (monotarea) o varios threads (por ejemplo el thread principal y otros secundarios, multitarea). 2.1.6.1.2 Clases. Casi todas las clases referentes al manejo de threads se encuentran en el paquete java.lang.*. 2.1.6.1.3 java.lang.Thread Nos ofrece el API genérico de los threads así como la implementación de su comportamiento incluyendo: arrancar, dormirse, parar, ejecutarse, esperar, gestión de prioridades. La lógica que va a ejecutar un thread se introduce en el método: public void run( ). Cuando termina la ejecución del método run ( ) se termina el thread. La clase java.lang.Thread contiene un método run( ) vacío. 2.1.6.1.4 java.lang.Runnable Se trata de una interfaz. Simplemente fuerza la implementación de un método: public void run( ). 2.1.6.1.5 Implementando un Thread Existen dos técnicas: Heredar de la clase java.lang.Thread y sobrescribir el método run( ). Implementar el interfaz java.lang.Runnable (por tanto tenemos que implementar el método run( )) y crear una instancia de la clase java.lang.Thread pasándole el objeto que implementa java.lang.Runnable como parámetro.
  82. 82. 82 Normalmente se usará la opción de Runnable cuando la clase que va a contener la lógica del thread ya herede de otra clase (Swing, Applets, …). Un thread puede pasar por varios estados durante su vida: ejecutándose, pausado o parado, muerto. Existen distintos métodos que provocan las transiciones entre estos estados. Para crear un thread hay que instanciarlo llamando al constructor como con el resto de clases Java. Dependiendo de cómo hayamos implementado el thread se actuará de una forma u otra: Si hereda de la clase java.lang.Thread, simplemente se instancia nuestra clase. Si implementa el interfaz java.lang.Runnable, se instancia la clase java.lang.Thread pasándole como parámetro del constructor una instancia de nuestra clase. Para arrancar un thread hay que llamar al método start( ). Este método registra al thread en el planificador de tareas del sistema y llama al método run( ) del thread. Pueden existir distintos motivos por los que un thread puede detener temporalmente su ejecución, o pasar a un estado de pausa. Se llama a su método sleep. Recibe un long con el número de milisegundos de la pausa. Se llama al método wait, y espera hasta recibir una señal (notify) o cumplirse un timeout definido por un long con el número de milisegundos. Se realiza alguna acción de entrada/salida. Se llama al método yield( ), que saca del procesador al thread hasta que el Sistema Operativo le vuelva a meter. Existen distintos motivos por los que un thread puede reanudar su ejecución: Se consumen los milisegundos establecidos en una llamada al método sleep. Se recibe una señal (notify) o se consumen los milisegundos en una llamada al método wait. Se termina alguna acción de entrada/salida.
  83. 83. 83 2.1.6.1.6 Sincronización de threads. Para poder bloquear un objeto e impedir que otro thread lo utilice mientras está este, se emplea la palabra synchronized en la definición de los métodos susceptibles de tener problemas de sincronización: public synchronized int getNumero( ). Cuando un thread está ejecutando un método synchronized en un objeto, se establece un bloqueo en dicho objeto. Cualquier otro thread que quiera ejecutar un método marcado como synchronized en un objeto bloqueado, tendrá que esperar a que se desbloquee. El objeto se desbloquea cuando el thread actual termina la ejecución del método synchronized. Se creará una lista de espera y se irán ejecutando por orden de llegada. El sistema de bloqueo/desbloqueo es algo gestionado de forma automática por la JVM. 2.1.6.1.7 Uso de señales Este es un sistema mediante el cual un thread puede detener su ejecución a la espera de una señal lanzada por otro thread. Para detener la ejecución y esperar a que otro thread nos envié una señal se utiliza el método: public void wait( ) o public void wait(long timeout). Para enviar una señal a los threads que están esperando en el objeto desde donde enviamos la señal se utiliza el método: public void notify o public void notifyAll( ).
  84. 84. 84 2.1.6.2 Ejemplo. 2.1.6.2.1 Carrera public class Carrera { public static void main(String [] args){ TortugaThreads tortuga = new TortugaThreads(); Thread liebre = new Thread(new LiebreThreads()); tortuga.start(); liebre.start(); } } public class LiebreThreads implements Runnable{ public void run(){ int i=0; System.out.println("Comienza la libre"); while(i<5){ try{ Thread.sleep(2000); System.out.println("liebre"); } catch(InterruptedException ex){ } i++; } System.out.println("Termina la liebre"); } } import sun.awt.windows.ThemeReader; /**
  85. 85. 85 * * @author MARTHA */ public class TortugaThreads extends Thread{ public void run(){ int i=0; System.out.println("Comienza la tortuga"); while(i<5){ try{ Thread.sleep(5000); System.out.println("tortuga"); } catch(InterruptedException ex){ } i++; } System.out.println("Termina la tortuga"); } } 2.1.6.2.2 Cronometro import java.awt.Color; import java.awt.Dimension; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.Box; import javax.swing.BoxLayout; import javax.swing.ImageIcon; import javax.swing.JButton; import javax.swing.JLabel; import javax.swing.JPanel;
  86. 86. 86 import javax.swing.border.BevelBorder; import javax.swing.border.LineBorder; /** * * @author MARTHA */ public class Cronometro extends JPanel implements Runnable { private JLabel label[] = new JLabel[8]; private ImageIcon digitos[] = new ImageIcon[11]; private int horas = 0; private int minutos = 0; private int segundos = 0; private boolean sw = false; private Cronometro c = null; public Cronometro() { c = this; for (int i = 0; i < 10; i++) { digitos[i] = new ImageIcon("imagenes/" + i + ".gif"); digitos[10] = new ImageIcon("imagenes/marthita.gif"); } this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS)); this.setBorder(new LineBorder(Color.BLACK, 2)); this.add(Box.createVerticalStrut(5)); JPanel aux = new JPanel(); aux.setMaximumSize(new Dimension(108, 23)); aux.setBorder(new BevelBorder(1));
  87. 87. 87 aux.setLayout(new GridLayout(1, 8)); for (int i = 0; i < 8; i++) { label[i] = new JLabel(); aux.add(label[i]); } this.add(aux); aux = new JPanel(); JButton arrancar = new JButton("Arrancar/Parar"); arrancar.setMnemonic('A'); arrancar.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { if (sw) { sw = false; } else { sw = true; new Thread(c).start(); } } }); JButton reiniciar = new JButton("Reiniciar"); reiniciar.setMnemonic('R'); reiniciar.addActionListener(new ActionListener() { @Override public void actionPerformed(ActionEvent e) { sw = false; horas = 0;
  88. 88. 88 minutos = 0; segundos = 0; mostrarHora(); } }); aux.add(reiniciar); this.add(aux); this.mostrarHora(); } public void run(){ int i=0; // System.out.println("Comienza la libre"); while(i<5){ try{ Thread.sleep(2000); // System.out.println("liebre"); } catch(InterruptedException ex){ } i++; } // System.out.println("Termina la liebre"); } private void mostrarHora() { label[0].setIcon(digitos[horas/10]); label[1].setIcon(digitos[horas%10]); label[2].setIcon(digitos[10]); label[3].setIcon(digitos[minutos/10]);
  89. 89. 89 label[4].setIcon(digitos[minutos%10]); label[5].setIcon(digitos[10]); label[6].setIcon(digitos[segundos/10]); label[7].setIcon(digitos[segundos%10]); } } public class MiThread extends Thread{ public void run(){ int i=0; while(i<5){ System.out.println(this.getName()); i++; } } } public class test { public static void main(String [] args){ MiThread t1= new MiThread(); t1.setName("Thread1"); t1.setPriority(Thread.MIN_PRIORITY); MiThread t2= new MiThread(); t2.setName("Thread2"); t2.setPriority(Thread.MAX_PRIORITY); t1.start(); t2.start(); } } import java.awt.Component; import java.awt.FlowLayout;
  90. 90. 90 import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import javax.swing.JFrame; /** * * @author MARTHA */ public class testCronometro { public static void main(String[] args) { JFrame frame = new JFrame("Prueba del componente cronometro"); frame.setBounds(10, 10, 290, 120); frame.getContentPane().setLayout(new FlowLayout()); frame.getContentPane().add(new Cronometro()); frame.setVisible(true); frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent ev){ System.exit(0); } }); } }
  91. 91. 91 2.1.7 Tcp/Ip. 2.1.7.1 Marco Teórico. 2.1.7.1.1 Sockets. Los sockets son puntos finales de enlaces de comunicaciones entre procesos. Los procesos los tratan como descriptores de ficheros, de forma que se pueden intercambiar datos con otros procesos transmitiendo y recibiendo a través de sockets. 2.1.7.1.1.1 Sockets Stream (TCP, Transport Control Protocol) El protocolo de comunicaciones con streams es un protocolo orientado a conexión, ya que para establecer una comunicación utilizando el protocolo TCP, hay que establecer en primer lugar una conexión entre un par de sockets. Mientras uno de los sockets atiende peticiones de conexión (servidor), el otro solicita una conexión (cliente). Una vez que los dos sockets estén conectados, se pueden utilizar para transmitir datos en ambas direcciones. 2.1.7.1.1.2 Sockets Datagrama (UDP, User Datagram Protocol) El protocolo de comunicaciones con datagramas es un protocolo sin conexión, es decir, cada vez que se envíen datagramas es necesario enviar el descriptor del socket local y la dirección del socket que debe recibir el datagrama. Como se puede ver, hay que enviar datos adicionales cada vez que se realice una comunicación. 2.1.7.1.1.3 Sockets Raw Son sockets que dan acceso directo a la capa de software de red subyacente o a protocolos de más bajo nivel. Se utilizan sobre todo para la depuración del código de los protocolos. 2.1.7.1.2 La clase URL. La clase URL contiene constructores y métodos para la manipulación de URL (Universal Resource Locator): un objeto o servicio en Internet. El protocolo TCP necesita dos tipos de información: la dirección IP y el número de puerto. Vamos a ver cómo podemos recibir pues la página Web principal de nuestro buscador favorito al teclear: http://www.yahoo.com

×