PROYECTO MODULO CLIENTE SERVIDOR

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.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
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
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
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
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
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
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
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
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
*/
public class TestArrayList2 {
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(1, "Loja");
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.LinkedList;
/**
*
*/
public class TestLinkedList {
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
ciudades.add(1,"Loja");
}
}
}
import java.util.*;
/**
*
*/
public class TestVector {
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(1, "Loja");

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"));
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
/**
*
*/
public class TestHashTable {
Hashtable codigos = new Hashtable();
}
}
}
import java.util.*;
/**
*
*/
public class TestLinkedHashMap {

15
LinkedHashMap codigos = new LinkedHashMap();
}
}
}
import java.util.*;
/**
*
*/
public class TestTreeMap {
TreeMap codigos = new TreeMap();

16
}
}
}
2.1.1.2.3 Set
import java.util.*;
public class TestHashSet {
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("Loja");
ciudades.add("Machala");
System.out.println("Ciudad: "+it.next());// mediante el next va
acceder a los objetos q se han guardado en la lista

17
}
}
}
import java.util.*;
/**
*
*/
public class TestLinkHashSet {
LinkedHashSet ciudades = new LinkedHashSet();// nos permite acceder
a cada uno de los objetos en el orden q deseemos
}
}
}
import java.util.TreeSet;
/**

18
*
*/
public class TestTreeSet {
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
}
}
}
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
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
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 {
Archivador archivar = new Archivador();
Fichas fichas = new Fichas("Marthita","Rojas",22);
archivar.guardar(fichas);
archivar.listar();
fichas.toString();
}
}

21
2.1.2 AWT.
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
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
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
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
AdjustmentEvent: Un valor se ha ajustado.
ItemEvent: Un estado ha cambiado.
TextEvent: Un texto ha cambiado.

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
2.1.2.2 Ejemplos.
2.1.2.2.1 Button.
package AWT;
import java.awt.*;
/**
*
* @author MARTHA
*/
public class ButtonTest {
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
/**
*
*/
public class CheckBoxTest {
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
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.*;
/**
*
*/

30
public class CheckboxGroupTest {
public static void main(String []args){
formulario awt
frame.setTitle("CheckboxGroupTest");//setTitle nos permite añadir
un titulo al formulario
tipo de contenedor
CheckboxGroup cbg = new CheckboxGroup();
Checkbox cb1 = new Checkbox("Hombre",cbg,true);//instanciando un
//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
//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
formulario
}
}

31
2.1.2.2.4 Choise
import java.awt.*;
/**
*
*/
public class ChoiseTest {
formulario awt
frame.setTitle("ChoiseTest");//setTitle nos permite añadir un
frame.setSize(200,150);//setSIze es para colocar el tamaño del
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
formulario
}
}

32
2.1.2.2.5 Frame
import java.awt.Frame;
/**
*
* @author MARTHA
*/
public class FrameTest {
formulario awt
f.setTitle("Frame Test");//setTitle nos permite añadir un titulo al
formulario
formulario
}
}
2.1.2.2.6 Label
import java.awt.*;
/**
*
*/
public class LabelTest {
public static void main(String []args){

33
formulario awt
frame.setTitle("LabelTest");//setTitle nos permite añadir un titulo
al formulario
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
formulario
}
}
2.1.2.2.7 List
import java.awt.*;
/**
*
*/

34
public class ListTest {
public static void main (String [] args){
formulario awt
frame.setTitle("ListTest");//setTitle nos permite añadir un titulo al
formulario
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
formulario
}
}
2.1.2.2.8 Panel
import java.awt.*;
/**
*
*/

35
public class EjemploAWT {
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
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
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
panel.add(boton);//add nos permite añadir compnentes al panel
frame.add(panel);//add nos permite añadir compnentes al formulario
formulario
}
}

36
2.1.2.2.9 Scrollbar
import java.awt.*;
import javax.swing.plaf.ScrollBarUI;
/**
*
*/
public class ScrollbarTest {
formulario awt
frame.setTitle("Scrollbar Test");//setTitle nos permite añadir un
tipo de contenedor
Scrollbar sb = new Scrollbar(Scrollbar.HORIZONTAL,0,5,-100,300);
frame.add(sb);//add nos permite añadir compnentes al formulario
formulario
}
}

37
2.1.2.2.10 TextField
import java.awt.*;
public class TextFieldText {
formulario awt
f.setTitle("TextField Test");//setTitle nos permite añadir un
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
formulario
}
}

38
2.1.3 Swing.
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
ScrollPaneLayout, ViewportLayout: utilizados internamente por Swing para
algunos de los componentes como el ScrollPane.

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.FlowLayout;
/**
*
* @author MARTHA
*/
public class BorderLayoutTest {

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);
}
}
/**
*
* @author MARTHA
*/
public class ButtonEventTest {

42
f.setTitle("Button Event Test");
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.CardLayout;
/**
*
* @author MARTHA
*/
public class CardLayoutTest {
f.setTitle("CardLayout Test");
CardLayout cl = new CardLayout();
f.setLayout(cl);
Button b1 = new Button("Button 1");

43
f.add(b1, "uno");
f.add(b2, "dos");
f.add(b3, "tres");
f.setVisible(true);
cl.show(f, "dos");
}
}
import java.awt.Cursor;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
/**
*
* @author MARTHA
*/
public class CursorTest {
Frame f = null;
new CursorTest();
}
public CursorTest() {
f = new Frame();
f.setTitle("CursorTest");

44
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 {
f.setTitle("Dialog Test");
f.setVisible(true);
Dialog d = new Dialog(f);

45
d.setTitle("Dialog Test");
d.setBounds(50, 50, 70, 50);
d.setVisible(true);
}
}
import java.awt.*;
public class FileDialogTest {
f.setTitle("Dialog Test");
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
f.setTitle("FlowLayout Test");
f.add(b1);
f.add(b2);
f.add(b3);
f.setVisible(true);
}
}
import java.awt.Font;
import java.awt.Label;
import javax.swing.JLabel;
/**
*
* @author MARTHA
*/
public class FontTest {
f.setTitle("Font Test");

47
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.Graphics;
/**
*
* @author MARTHA
*/
public class GraphicsTest extends Frame {
new GraphicsTest().setVisible(true);
}
public GraphicsTest() {

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
g.drawString("Arco", 250, 135);
}
}
import java.awt.GridLayout;
/**
*
* @author MARTHA
*/
public class GridLayoutTest {
f.setTitle("GridLayout Test");
f.setLayout(new GridLayout(2, 3, 2, 2));
f.add(new Button("Boton 1"));
f.setVisible(true);
}
}
import javax.swing.JColorChooser;
import javax.swing.JFileChooser;
import javax.swing.JFrame;

50
/**
*
* @author MARTHA
*/
public class JColorChooserTest {
JFrame f = new JFrame();
f.setTitle("JColorChooser Test");
f.setVisible(true);
JFileChooser fc = new JFileChooser();
int op = fc.showOpenDialog(fc);
if (op == JFileChooser.APPROVE_OPTION) {
System.out.println(fc.getSelectedFile());
}
}
}
import javax.swing.JComboBox;
/**
*
* @author MARTHA
*/
public class JComboBoxTest {

51
f.setTitle("JComboBox Test");
f.getContentPane().setLayout(new FlowLayout());
String[] lista= {"Martha","Carolina","Marianela"};
JComboBox jcb = new JComboBox(lista);
f.getContentPane().add(jcb);
f.setVisible(true);
}
}
import javax.swing.JColorChooser;
/**
*
* @author MARTHA
*/
public class JFileChooserTest {
f.setTitle("JFileChooser Test");
f.setVisible(true);
Color c = JColorChooser.showDialog(f, "Seleccione un color",
Color.RED);
System.out.println("El color seleccionado es: " + c);
}
}

52
/**
*
* @author MARTHA
*/
public class JFrameTest {
f.setTitle("JFrame Test");
f.setVisible(true);
}
}
import javax.swing.JInternalFrame;
/**
*
* @author MARTHA
*/
public class JInternalFrameTest {
f.setTitle("JInternalFrame Test");
f.getContentPane().setLayout(null);
JInternalFrame f1 = new JInternalFrame("Internal Frame 1");
f1.setBounds(10, 10, 150, 100);

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 javax.swing.JList;
/**
*
* @author MARTHA
*/
public class JListTest {
f.setTitle("JList Test");
String[] lista = {"Martha", "Carolina", "Marianela", "Steve"};
JList jl = new JList(lista);
f.getContentPane().add(jl);
f.setVisible(true);
}
}
import javax.swing.JCheckBoxMenuItem;

54
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
/**
*
* @author MARTHA
*/
public class JMenuBarTest {
f.setTitle("JMenuBar Test");
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);
}
}

55
import javax.swing.JPasswordField;
/**
*
* @author MARTHA
*/
public class JPasswordFieldTest {
f.setTitle("JPasswordField Test");
JPasswordField pf = new JPasswordField("Marthita");
f.getContentPane().add(pf);
f.setVisible(true);
}
}
import javax.swing.ButtonGroup;
import javax.swing.JRadioButton;
/**
*
* @author MARTHA
*/
public class JRadioButtonTest {

56
f.setTitle("Test");
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.setVisible(true);
}
}
import javax.swing.JSpinner;
import javax.swing.SpinnerListModel;
/**
*
* @author MARTHA
*/
public class JSpinnerTest {
f.setTitle("JSpinner Test");
String[] alumnos = {"Martha", "Carolina", "Marianela", "Steve"};

57
SpinnerListModel modelo = new SpinnerListModel(alumnos);
JSpinner js = new JSpinner(modelo);
f.getContentPane().add(js);
f.setVisible(true);
}
import javax.swing.JTextArea;
/**
*
* @author MARTHA
*/
public class JTextAreaTest {
f.setTitle("JText Area");
JTextArea txta = new JTextArea("Escribe aqui...", 5, 15);
f.getContentPane().add(txta);
f.setVisible(true);
}
}
import javax.swing.ButtonGroup;
import javax.swing.JToggleButton;
/**
*

58
* @author MARTHA
*/
public class JToggleButtonTest {
f.setTitle("JToggleButton");
ButtonGroup bg = new ButtonGroup();
JToggleButton b1 = new JToggleButton("Hombre", true);
bg.add(b1);
JToggleButton b2 = new JToggleButton("Hombre", true);
bg.add(b2);
f.setVisible(true);
}
}
import java.awt.*;
public class MenuTest {
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
m2.add(new CheckboxMenuItem("opcion 2"));
mb.add(m);
mb.add(m2);
f.setMenuBar(mb);
f.setVisible(true);
}
}
/**
*
* @author MARTHA
*/
public class NullLayoutTest {
f.setTitle("NullLayout Test");
f.setLayout(null);
b1.setBounds(50, 25, 100, 25);
f.add(b1);
b2.setBounds(125, 85, 100, 50);
f.add(b2);
f.setVisible(true);
}

60
}
import javax.swing.JButton;
/**
*
* @author MARTHA
*/
public class Test {
f.setTitle("Test");
JButton b1 = new JButton("Ok");
f.setVisible(true);
}
}
import java.awt.*;
/**
*
* @author MARTHA
*/
public class TextAreaTest {

61
f.setTitle("Text Area");
TextArea txta = new TextArea("Escribe aqui...", 5, 15);
f.add(txta);
f.setVisible(true);
}
}
import java.awt.*;
/**
*
* @author MARTHA
*/
public class WindowEventTest1 {
f.setTitle("Frame Test");
f.addWindowListener(new WindowListenerTest());
f.setVisible(true);
}
}
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
/**

62
*
* @author MARTHA
*/
public class WindowEventTest2 extends WindowAdapter {
WindowEventTest2 we = new WindowEventTest2();
}
public WindowEventTest2() {
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
}
public void windowIconified(WindowEvent ev) {
}
}
/**
*
* @author MARTHA
*/
public class WindowEventTest3 {
WindowEventTest3 we = new WindowEventTest3();
}
public WindowEventTest3() {
f.addWindowListener(new WindowAdapter() {
System.exit(0);
}
});
f.setVisible(true);
}
}

64
import java.awt.event.*;
/** @author MARTHA
*/
public class WindowListenerTest extends WindowAdapter{
System.exit(0);
}
}

65
2.1.4 Applet.
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
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
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
 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
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
import com.sun.xml.internal.messaging.saaj.soap.JpegDataContentHandler;
import java.applet.AudioClip;
import java.awt.BorderLayout;
import java.awt.MenuItem;
import javax.swing.JApplet;
import javax.swing.JComponent;
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
/**
*
* @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
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
@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")){
}
}
}

74
2.1.5 Manejo de Excepciones.
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
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
 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
}
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
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
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 {
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
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
2.1.6 Threads.
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
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
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
2.1.6.2 Ejemplo.
2.1.6.2.1 Carrera
public class Carrera {
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
*
* @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");
}
}
i++;
}
System.out.println("Termina la tortuga");
}
}
2.1.6.2.2 Cronometro
import java.awt.Dimension;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JPanel;

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
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
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");
}
}
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
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 {
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;

90
/**
*
* @author MARTHA
*/
public class testCronometro {
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
2.1.7 Tcp/Ip.
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

PROYECTO MODULO CLIENTE SERVIDOR

PROYECTO MODULO CLIENTE SERVIDOR

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Destacado

Destacado (17)

Similar a PROYECTO MODULO CLIENTE SERVIDOR

Similar a PROYECTO MODULO CLIENTE SERVIDOR (20)

Más de Laddy Mathita

Más de Laddy Mathita (6)

Último

Último (20)

PROYECTO MODULO CLIENTE SERVIDOR