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

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

92
En primer lugar, Yahoo tiene registrado su nombre, permitiendo que se use
yahoo.com como su dirección IP, o lo que es lo mismo, cuando indicamos yahoo.com es
como si hubiésemos indicado 205.216.146.71, su dirección IP real.
Hay un servicio, el DNS (Domain Name Service), que traslada www.yahoo.com a
205.216.146.71, lo que nos permite teclear www.yahoo.com, en lugar de tener que
recordar su dirección IP.
Si queremos obtener la dirección IP real de la red en que estamos corriendo,
podemos realizar llamadas a los métodos getLocalHost() y getAddress(). Primero,
getLocalHost() nos devuelve un objeto iNetAddress, que si usamos con getAddress()
generará un array con los cuatro bytes de la dirección IP, por ejemplo:
InetAddress direccion = InetAddress.getLocalHost();
byte direccionIp[] = direccion.getAddress();
Si la dirección de la máquina en que estamos corriendo es 150.150.112.145,
entonces:
direccionIp[0] = 150
2.1.7.1.3 Apertura de sockets.
Si estamos programando un cliente, el socket se abre de la forma:
Socket miCliente;
miCliente = new Socket( "maquina",numeroPuerto );
Donde maquina es el nombre de la máquina en donde estamos intentando abrir la
conexión y numeroPuerto es el puerto (un número) del servidor que está corriendo
sobre el cual nos queremos conectar. Cuando se selecciona un número de puerto, se
debe tener en cuenta que los puertos en el rango 0-1023 están reservados para usuarios
con muchos privilegios (superusuarios o root). Estos puertos son los que utilizan los
servicios estándar del sistema como email, ftp o http. Para las aplicaciones que se
desarrollen, asegurarse de seleccionar un puerto por encima del 1023.
En el ejemplo anterior no se usan excepciones; sin embargo, es una gran idea la
captura de excepciones cuando se está trabajando con sockets. El mismo ejemplo
quedaría como:

93
Socket miCliente;
try {
miCliente = new Socket( "maquina",numeroPuerto );
} catch( IOException e ) {
System.out.println( e );
}
Si estamos programando un servidor, la forma de apertura del socket es la que
muestra el siguiente ejemplo:
Socket miServicio;
try {
miServicio = new ServerSocket( numeroPuerto );
}
A la hora de la implementación de un servidor también necesitamos crear un
objeto socket desde el ServerSocket para que esté atento a las conexiones que le puedan
realizar clientes potenciales y poder aceptar esas conexiones:
Socket socketServicio = null;
try {
socketServicio = miServicio.accept();
}
2.1.7.1.4 Cierre de sockets
Siempre deberemos cerrar los canales de entrada y salida que se hayan abierto
durante la ejecución de la aplicación. En la parte del cliente:
try {
salida.close();
entrada.close();
miCliente.close();
}
Y en la parte del servidor:
try {
salida.close();
entrada.close();
socketServicio.close();
miServicio.close();
}

94
2.1.7.1.5 Creacion de streams.
2.1.7.1.5.1 Creación de Streams de Entrada
En la parte cliente de la aplicación, se puede utilizar la clase DataInputStream para
crear un stream de entrada que esté listo a recibir todas las respuestas que el servidor le
envíe.
DataInputStream entrada;
try {
entrada = new DataInputStream( miCliente.getInputStream() );
}
La clase DataInputStream permite la lectura de líneas de texto y tipos de datos
primitivos de Java de un modo altamente portable; dispone de métodos para leer todos
esos tipos como: read(), readChar(), readInt(), readDouble() y readLine(). Deberemos
utilizar la función que creamos necesaria dependiendo del tipo de dato que esperemos
recibir del servidor.
En el lado del servidor, también usaremos DataInputStream, pero en este caso para
recibir las entradas que se produzcan de los clientes que se hayan conectado:
DataInputStream entrada;
try {
entrada =
new DataInputStream( socketServicio.getInputStream() );
}
2.1.7.1.5.2 Creación de Streams de Salida
En el lado del cliente, podemos crear un stream de salida para enviar información
al socket del servidor utilizando las clases PrintStream o DataOutputStream:
PrintStream salida;
try {
salida = new PrintStream( miCliente.getOutputStream() );
}
La clase PrintStream tiene métodos para la representación textual de todos los
datos primitivos de Java. Sus métodos write y println() tienen una especial importancia
en este aspecto. No obstante, para el envío de información al servidor también podemos
utilizar DataOutputStream:
DataOutputStream salida;

95
try {
salida = new DataOutputStream( miCliente.getOutputStream() );
}
La clase DataOutputStream permite escribir cualquiera de los tipos primitivos de
Java, muchos de sus métodos escriben un tipo de dato primitivo en el stream de salida.
De todos esos métodos, el más útil quizás sea writeBytes().
En el lado del servidor, podemos utilizar la clase PrintStream para enviar información al
cliente:
PrintStream salida;
try {
salida = new PrintStream( socketServicio.getOutputStream() );
}
Pero también podemos utilizar la clase DataOutputStream como en el caso de envío de
información desde el cliente.

96
2.1.7.2 Ejemplo.
2.1.7.2.1 URL
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
/**
*
* @author MARTHA
*/
public class EchoClient {
try{
Socket clientSocket = new Socket("192.68.1.2",1234);
PrintWriter out = new
PrintWriter(clientSocket.getOutputStream(),true);
BufferedReader bf = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
System.out.println("Enviando: Eco!!!");
System.out.println("Recibiendo: "+bf.readLine());
out.close();
bf.close();
clientSocket.close();
}
catch(UnknownError e){
}

97
catch(IOException ex){}
}
}
import java.io.PrintWriter;
import java.net.ServerSocket;
/**
*
* @author MARTHA
*/
public class EchoServer {
try{
ServerSocket serverSocket = new ServerSocket(1234);
Socket clientSocket = new Socket("192.68.1.2",1234);
PrintWriter out = new
PrintWriter(clientSocket.getOutputStream(),true);
InputStreamReader(clientSocket.getInputStream()));
String inputline=bf.readLine();
System.out.println("Recibiendo: "+bf.readLine());
String outputline=bf.readLine();
System.out.println("Enviando: Eco!!!"+outputline);
out.println(outputline);
out.close();
bf.close();
clientSocket.close();
serverSocket.close();

98
}
catch(IOException ex){}
}
}
import java.net.MalformedURLException;
import java.net.URL;
/**
*
* @author MARTHA
*/
public class LeerURLTest {
public static void main(String [] args) throws IOException{
try{
URL yahoo = new URL("http://www.yahoo.com");
InputStreamReader(yahoo.openStream()));
String aux;
while((aux=bf.readLine())!=null){
System.out.println(aux);
bf.close();
}
}
catch(MalformedURLException ex){
}
catch(IOException ex){
}

99
}
}
import java.net.MalformedURLException;
import java.net.URL;
/**
*
* @author MARTHA
*/
public class URLTest {
try{
URL aURL = new
URL("http://www.netbeans.org:80/netbeans/faq/netbeans-faq.html#about_8");
System.out.println("Protocol= "+aURL.getProtocol());
System.out.println("Host= "+aURL.getHost());
System.out.println("FileName= "+aURL.getFile());
System.out.println("Port= "+aURL.getPort());
System.out.println("Ref= "+aURL.getRef());
}
catch(MalformedURLException ex){
ex.printStackTrace();
}
}
}
2.1.7.2.2 Servidor

100
import java.io.BufferedWriter;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.net.UnknownHostException;
import javax.swing.BorderFactory;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
public class Cliente extends JFrame
{
//ATRIBUTOS .
private Socket cliente = null;
private BufferedReader br = null;
private BufferedWriter bw = null;
private JTextArea salida = null;
private JTextField entrada = null;
private static String ip = null;
private static int puerto = 0;
private static String nick = null;
private Tareadecliente tarea = null;
// CHEQUEAR ARGUMENTOS DE ENTRADA.

101
if (args.length < 6) {
mostrarAyuda();
}
for (int i = 0; i < 6; i++) {
switch (args[i]) {
case "-h":
ip = args[++i];
break;
case "-p":
puerto = Integer.parseInt(args[++i]);
break;
case "-n":
nick = args[++i];
break;
default:
mostrarAyuda();
break;
}
}
// Crear el cliente.
Cliente cliente = new Cliente();
cliente.setSize(300,200);
cliente.setVisible(true);
// Conectar el cliente.
cliente.conectar();
}
public static void mostrarAyuda()
{
System.out.println("Uso: java.exe Cliente -h %DirecciÃ³n_IP% -p
%Puerto% -n %Nick%");
System.out.println(" -h: DirecciÃ³n IP del Servidor");

102
System.out.println(" -p: Puerto del Servidor");
System.out.println(" -n: Nick a utilizar en esta sesiÃ³n");
System.out.println("Ejemplo: java.exe Cliente -h 127.0.0.1 -p 1234 -
n wezpo");
System.exit(-1);
}
// Constructor.
public Cliente()
{
this.setTitle("Chat - " + nick);
this.getContentPane().setLayout(new BorderLayout());
salida = new JTextArea();
salida.setEditable(false);
salida.setAutoscrolls(true);
salida.setBorder(BorderFactory.createEtchedBorder());
JScrollPane pane = new JScrollPane(salida);
this.getContentPane().add(pane,BorderLayout.CENTER);
entrada = new JTextField(18);
entrada.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent ev)
{
enviar();
}
});
JButton enviar = new JButton("Enviar");
enviar.setMnemonic('E');
enviar.setToolTipText("Pulsar para enviar el texto.");
enviar.addActionListener(new ActionListener()
{

103
@Override
public void actionPerformed(ActionEvent ev)
{
enviar();
}
});
JPanel tmp = new JPanel();
tmp.add(entrada);
tmp.add(enviar);
this.getContentPane().add(tmp,BorderLayout.SOUTH);
this.addWindowListener(new WindowAdapter()
{
@Override
public void windowClosing(WindowEvent ev)
{
tarea.stop(true);
System.exit(0);
}
});
}
// MÃ©todos.
private void conectar()
{
try
{
this.mostrar("#Conectando con el servidor",false);
cliente = new Socket(ip,puerto);

104
this.mostrar("#Abriendo streams",false);
br = new BufferedReader(new InputStreamReader(cliente.getInputStream()));
bw = new BufferedWriter(new
OutputStreamWriter(cliente.getOutputStream()));
this.mostrar("#Conectado",false);
bw.write("#Se ha conectado: " + nick + "n");
bw.flush();
tarea = new Tareadecliente(this);
tarea.start();
}
catch (UnknownHostException ex)
{
this.mostrar("Ha habido un problema -
UnknownHostException",false);
}
catch (IOException ex)
{
this.mostrar("Ha habido un problema - IOException",false);
}
}
private void enviar()
{
salida.append(nick + "> " + entrada.getText() + "n");
try
{
bw.write(nick + "> " + entrada.getText() + "n");
bw.flush();
}
catch (IOException ex)

105
{
}
entrada.setText("");
entrada.requestFocus();
}
private void mostrar(String texto, boolean sw)
{
if(sw)
salida.append(nick + "> " + texto + "n");
else
salida.append(texto + "n");
}
// Getters
public BufferedReader getBufferedReader()
{
return br;
}
public JTextArea getSalida()
{
return salida;
}
public JTextField getEntrada()
{
return entrada;

106
}
}
import java.net.BindException;
import java.net.ServerSocket;
import java.util.Calendar;
public class SERVIDOR {
// Atributos.
private ArrayList clientes = null;
private boolean sw = true;
private static int puerto = 0;
// Chequear argumentos de entrada.
if (args.length < 2) {
mostrarAyuda();
}
for (int i = 0; i < 2; i++) {
if (args[i].equals("-p")) {
puerto = Integer.parseInt(args[++i]);
} else {
mostrarAyuda();
}
}
// Crear y arrancar el servidor.
new SERVIDOR().arrancar();
}

107
public static void mostrarAyuda() {
System.out.println("Uso: java.exe Servidor -p %Puerto%");
System.out.println(" -p: Puerto del Servidor");
System.out.println("Ejemplo: java.exe Servidor -p 1234");
System.exit(-1);
}
// Constructor.
public SERVIDOR() {
clientes = new ArrayList();
}
// MÃ©todos.
private void arrancar() {
ServerSocket servidor = null;
while (sw) {
try {
if (servidor == null) {
servidor = new ServerSocket(puerto);
}
Socket cliente = servidor.accept();
Tareaservidor tarea = new Tareaservidor(cliente, clientes);
clientes.add(tarea);
tarea.start();
} catch (BindException ex) {
sw = false;
System.out.println(Calendar.getInstance().getTime() + " -
El puerto estÃ¡ en uso.");
sw = false;

108
}
}
}
private static class Tareaservidor {
public Tareaservidor() {
}
private Tareaservidor(Socket cliente, ArrayList clientes) {
throw new UnsupportedOperationException("Not supported yet.");
//To change body of generated methods, choose Tools | Templates.
}
private void start() {
throw new UnsupportedOperationException("Not supported yet.");
//To change body of generated methods, choose Tools | Templates.
}
}
}
import java.net.SocketException;
public class Tareadecliente extends Thread
{
// Atributos.
private Cliente cliente = null;

109
// Constructor.
public Tareadecliente(Cliente param) {
cliente = param;
}
// Métodos.
public void run() {
while (sw) {
try {
cliente.getSalida().append(cliente.getBufferedReader().readLine() + "n");
cliente.getEntrada().requestFocus();
} catch (SocketException ex) {
cliente.getSalida().append("#Se ha perdido la conexión
con el Servidorn");
sw = false;
}
}
}
public void stop(boolean param) {
sw = param;
}
}
import java.io.BufferedWriter;

110
import java.io.OutputStreamWriter;
import java.net.SocketException;
public class Tareaservidor extends Thread
{
// Atributos.
private Socket cliente = null;
private ArrayList clientes = null;
private BufferedReader br = null;
private BufferedWriter bw = null;
private String usuario = null;
// Constructor.
public Tareaservidor(Socket param1, ArrayList param2) {
cliente = param1;
clientes = param2;
try {
br = new BufferedReader(new
InputStreamReader(cliente.getInputStream()));
bw = new BufferedWriter(new
OutputStreamWriter(cliente.getOutputStream()));
sw = false;
}

111
}
// Métodos.
public void run() {
try {
// Recibir el nick del cliente recien conectado.
String tmp = this.recibir();
usuario = tmp.substring(tmp.indexOf(": ") + 2,
tmp.length());
// Reenviar al resto de clientes el nick del cliente recien
conectado.
this.broadcast("#Se ha conectado: " + usuario);
while (sw) {
// Reenviar al resto de clientes el mensaje recibido.
this.broadcast(this.recibir());
}
} catch (SocketException ex) {
try {
// Reenviar al resto de clientes el nick del cliente
recien desconectado.
this.broadcast("#Se ha desconectado: " + usuario);
} catch (IOException ex2) {
ex2.printStackTrace();
}
} finally {
try {
if (br != null) {
br.close();
}

112
}
try {
if (bw != null) {
bw.close();
}
}
try {
if (cliente != null) {
cliente.close();
}
}
}
clientes.remove(this);
}
private void broadcast(String param) throws IOException {
for (int i = 0; i < clientes.size(); i++) {
if (clientes.get(i) != this) {
((Tareaservidor) clientes.get(i)).enviar(param + "n");
}
}
}

113
private void enviar(String param) throws IOException {
bw.write(param);
bw.flush();
}
private String recibir() throws IOException {
return br.readLine();
}
}

114
2.2 MODULO BASE DE DATOS.
2.2.1 Acceso a la Base de Datos.
2.2.1.1.1 Definición
Una base de datos o banco de datos es un conjunto de datos pertenecientes a un
mismo contexto y almacenados sistemáticamente para su posterior uso. En este sentido;
una biblioteca puede considerarse una base de datos compuesta en su mayoría por
documentos y textos impresos en papel e indexados para su consulta. Actualmente, y
debido al desarrollo tecnológico de campos como la informática y la electrónica, la
mayoría de las bases de datos están en formato digital (electrónico), y por ende se ha
desarrollado y se ofrece un amplio rango de soluciones al problema del almacenamiento
de datos.
Existen programas denominados sistemas gestores de bases de datos, abreviado
DBMS, que permiten almacenar y posteriormente acceder a los datos de forma rápida y
estructurada. Las propiedades de estos DBMS, así como su utilización y administración,
se estudian dentro del ámbito de la informática.
Los principales objetivos de un DBMS son los siguientes:
1. Independencia lógica y física de los datos: se refiere a la capacidad de modificar
una definición de esquema en un nivel de la arquitectura sin que esta modificación
afecte al nivel inmediatamente superior. Para ello un registro externo en un esquema
externo no tiene por qué ser igual a su registro correspondiente en el esquema
conceptual.6
2. Redundancia mínima: se trata de usar la base de datos como repositorio común de
datos para distintas aplicaciones.
3. Acceso concurrente por parte de múltiples usuarios: control de concurrencia
mediante técnicas de bloqueo o cerrado de datos accedidos.
4. Distribución espacial de los datos: la independencia lógica y física facilita la
posibilidad de sistemas de bases de datos distribuidas. Los datos pueden encontrarse

115
en otra habitación, otro edificio e incluso otro país. El usuario no tiene por qué
preocuparse de la localización espacial de los datos a los que accede.
5. Integridad de los datos: se refiere a las medidas de seguridad que impiden que se
introduzcan datos erróneos. Esto puede suceder tanto por motivos físicos (defectos
de hardware, actualización incompleta debido a causas externas), como de operación
(introducción de datos incoherentes).
6. Consultas complejas optimizadas: la optimización de consultas permite la rápida
ejecución de las mismas.
7. Seguridad de acceso y auditoría: se refiere al derecho de acceso a los datos
contenidos en la base de datos por parte de personas y organismos. El sistema de
auditoría mantiene el control de acceso a la base de datos, con el objeto de saber qué
o quién realizó una determinada modificación y en qué momento.
8. Respaldo y recuperación: se refiere a la capacidad de un sistema de base de datos
de recuperar su estado en un momento previo a la pérdida de datos.
9. Acceso a través de lenguajes de programación estándar: se refiere a la
posibilidad ya mencionada de acceder a los datos de una base de datos mediante
lenguajes de programación ajenos al sistema de base de datos propiamente dicho.
Una base de datos típica conlleva la existencia de tres tipos de usuario con relación
a su diseño, desarrollo y uso:
1. El administrador de bases de datos (DBA: Database Administrator): diseña y
mantiene la DB.
2. El desarrollador de aplicaciones (programador): implementa las transacciones e
interfaces.
3. Los usuarios finales: consultan y editan los datos de la DB mediante un lenguaje de
consulta de alto nivel.
No cabe duda de que la parte más importante es la llevada a cabo por el DBA. A él
le corresponde la elección de un determinado modelo de datos y el diseño de la DB. La
etapa de diseño es la más importante, ya que es ahí donde se refleja la semántica7 de la
información contenida en la DB a través del denominado esquema conceptual. Nos
detendremos sobre este tema cuando estudiemos el modelado de datos.
En general, podemos decir que el propósito de una base de datos es doble:

116
a) responder a consultas sobre los datos que contiene, y
b) ejecutar transacciones
Una consulta (query) se expresa como una expresión lógica sobre los objetos y
relaciones definidos en el esquema conceptual; el resultado es la identificación de un
subconjunto lógico de la base de datos. Una transacción consiste en un número de
consultas y operaciones de modificación o actualización sobre un subesquema. Las
transacciones son atómicas8 por definición: todos los pasos de una transacción han de
ser debidamente ejecutados y confirmados como requisito previo para que la
transacción pueda ser llevada a cabo en su conjunto, en caso contrario ha de ser
invalidada.
Para llevar a cabo estas tareas, el DBA tiene a su disposición la principal
herramienta de una base de datos, el sistema gestor de bases de datos (DBMS). A través
de éste se realizan todas las operaciones con los datos (consultas y transacciones), de
forma que al DBA no le atañe la manera en que los datos se encuentran almacenados
físicamente, pudiéndose concentrar en los aspectos conceptuales en cuanto a diseño,
desarrollo y mantenimiento. Un DBMS típico integra los siguientes componentes:
 Un lenguaje de definición de datos (DDL: Data Definition Language).
 Un lenguaje de manipulación de datos (DML: Data Manipulation Language)
 Un lenguaje de consulta (QL: Query Language).
 De forma accesoria, pero ya casi obligada, los DBMS modernos añaden un interfaz de
usuario gráfico (GUI: Graphical User Interface).
 consultas mediante ejemplo (posiblemente gráficas) ((G)QBE: (Graphical) Query By
Example)
2.2.1.1.2 Normalización
2.2.1.1.2.1 Definición
El proceso de normalización de bases de datos consiste en aplicar una serie de
reglas a las relaciones obtenidas tras el paso del modelo entidad-relación al modelo
relacional.
Las bases de datos relacionales se normalizan para:

117
 Evitar la redundancia de los datos.
 Evitar problemas de actualización de los datos en las tablas.
 Proteger la integridad de los datos.
En el modelo relacional es frecuente llamar tabla a una relación, aunque para que una
tabla sea considerada como una relación tiene que cumplir con algunas restricciones:
 Cada tabla debe tener su nombre único.
 No puede haber dos filas iguales. No se permiten los duplicados.
 Todos los datos en una columna deben ser del mismo tipo.
2.2.1.1.2.2 Claves
 Una clave primaria es aquella columna (o conjunto de columnas) que identifica únicamente
a una fila. La clave primaria es un identificador que va a ser siempre único para cada fila. Se
acostumbra a poner la clave primaria como la primera columna de la tabla pero es más una
conveniencia que una obligación. Muchas veces la clave primaria es numérica auto-
incrementada, es decir, generada mediante una secuencia numérica incrementada
automáticamente cada vez que se inserta una fila.
 En una tabla puede que tengamos más de una columna que puede ser clave primaria por sí
misma. En ese caso se puede escoger una para ser la clave primaria y las demás claves serán
claves candidatas.
 Una clave ajena (foreign key o clave foránea) es aquella columna que existiendo como
dependiente en una tabla, es a su vez clave primaria en otra tabla.
 Una clave alternativa es aquella clave candidata que no ha sido seleccionada como clave
primaria, pero que también puede identificar de forma única a una fila dentro de una tabla.
Ejemplo: Si en una tabla clientes definimos el número de documento (id_cliente) como clave
primaria, el número de seguro social de ese cliente podría ser una clave alternativa. En este
caso no se usó como clave primaria porque es posible que no se conozca ese dato en todos
los clientes.
 Una clave compuesta es una clave que está compuesta por más de una columna.
 La visualización de todas las posibles claves candidatas en una tabla ayuda a su
optimización. Por ejemplo, en una tabla PERSONA podemos identificar como claves su DNI, o
el conjunto de su nombre, apellidos, fecha de nacimiento y dirección. Podemos usar
cualquiera de las dos opciones o incluso todas a la vez como clave primaria, pero es mejor en
la mayoría de sistemas la elección del menor número de columnas como clave primaria.

118
2.2.1.1.2.3 FORMAS NORMALES
 Las formas normales son aplicadas a las tablas de una base de datos. Decir que una base de
datos está en la forma normal N es decir que todas sus tablas están en la forma normal N.
 Diagrama de inclusión de todas las formas normales.
 En general, las primeras tres formas normales son suficientes para cubrir las necesidades de
la mayoría de las bases de datos. El creador de estas 3 primeras formas normales (o reglas)
fue Edgar Alanis.
2.2.1.1.2.3.1 PRIMERA FORMA NORMAL (1FN)
Una tabla está en Primera Forma Normal si:
 Todos los atributos son atómicos. Un atributo es atómico si los elementos del dominio son
indivisibles, mínimos.
 La tabla contiene una clave primaria única.
 La clave primaria no contiene atributos nulos.
 No debe existir variación en el número de columnas.
 Los Campos no clave deben identificarse por la clave (Dependencia Funcional)
 Debe Existir una independencia del orden tanto de las filas como de las columnas, es decir, si
los datos cambian de orden no deben cambiar sus significados
 Una tabla no puede tener múltiples valores en cada columna.
 Los datos son atómicos (a cada valor de X le pertenece un valor de Y y viceversa).
Esta forma normal elimina los valores repetidos dentro de una BD
2.2.1.1.2.3.2 SEGUNDA FORMA NORMAL (2FN)
 Dependencia Funcional. Una relación está en 2FN si está en 1FN y si los atributos que no
forman parte de ninguna clave dependen de forma completa de la clave principal. Es decir
que no existen dependencias parciales. (Todos los atributos que no son clave principal deben
depender únicamente de la clave principal).
 En otras palabras podríamos decir que la segunda forma normal está basada en el concepto
de dependencia completamente funcional. Una dependencia funcional es
completamente funcional si al eliminar los atributos A de X significa que la dependencia no
es mantenida, esto es que . Una dependencia funcional
es una dependencia parcial si hay algunos atributos que pueden ser
eliminados de X y la dependencia todavía se mantiene, esto es .
 Porejemplo {DNI,ID_PROYECTO} HORAS_TRABAJO(con el DNI de un empleado y el ID de
un proyecto sabemos cuántas horas de trabajo por semana trabaja un empleado en dicho

119
proyecto) es completamente funcional dado que ni DNI HORAS_TRABAJO ni
ID_PROYECTO HORAS_TRABAJO mantienen la dependencia. Sin embargo {DNI,
ID_PROYECTO} NOMBRE_EMPLEADO es parcialmente dependiente dado que DNI
NOMBRE_EMPLEADO mantiene la dependencia.
2.2.1.1.2.3.3 TERCERA FORMA NORMAL (3FN)
 La tabla se encuentra en 3FN si es 2FN y si no existe ninguna dependencia funcional
transitiva entre los atributos que no son clave.
 Un ejemplo de este concepto sería que, una dependencia funcional X->Y en un esquema de
relación R es una dependencia transitiva si hay un conjunto de atributos Z que no es un
subconjunto de alguna clave de R, donde se mantiene X->Z y Z->Y.
 Por ejemplo, la dependencia SSN->DMGRSSN es una dependencia transitiva en EMP_DEPT
de la siguiente figura. Decimos que la dependencia de DMGRSSN el atributo clave SSN es
transitiva vía DNUMBER porque las dependencias SSN→DNUMBER y DNUMBER→DMGRSSN
son mantenidas, y DNUMBER no es un subconjunto de la clave de EMP_DEPT.
Intuitivamente, podemos ver que la dependencia de DMGRSSN sobre DNUMBER es
indeseable en EMP_DEPT dado que DNUMBER no es una clave de EMP_DEPT.
 Formalmente, un esquema de relación está en 3 Forma Normal Elmasri-Navathe, si para
toda dependencia funcional , se cumple al menos una de las siguientes
condiciones:
1. es superllave o clave.
2. es atributo primo de ; esto es, si es miembro de alguna clave en .
Además el esquema debe cumplir necesariamente, con las condiciones de segunda
forma normal.
2.2.1.1.2.3.4 FORMA NORMAL DE BOYCE-CODD (FNBC)
La tabla se encuentra en FNBC si cada determinante, atributo que determina
completamente a otro, es clave candidata. Deberá registrarse de forma anillada ante la
presencia de un intervalo seguido de una formalización perpetua, es decir las variantes
creadas, en una tabla no se llegaran a mostrar, si las ya planificadas, dejan de existir.
Formalmente, un esquema de relación está en FNBC, si y sólo si, para toda
dependencia funcional válida en , se cumple que
1. es superllave o clave.

120
De esta forma, todo esquema que cumple FNBC, está además en 3FN; sin
embargo, no todo esquema que cumple con 3FN, está en FNBC.
2.2.1.1.2.3.5 CUARTA FORMA NORMAL (4FN)
Una tabla se encuentra en 4FN si, y sólo si, para cada una de sus dependencias
múltiples no funcionales X->->Y, siendo X una super-clave que, X es o una clave
candidata o un conjunto de claves primarias.
2.2.1.1.2.3.6 QUINTA FORMA NORMAL (5FN)
Una tabla se encuentra en 5FN si:
 La tabla está en 4FN
 No existen relaciones de dependencias no triviales que no siguen los criterios de las claves.
Una tabla que se encuentra en la 4FN se dice que está en la 5FN si, y sólo si, cada relación de
dependencia se encuentra definida por las claves candidatas.
2.2.1.1.2.4 Reglas de CODD
2.2.1.1.2.4.1 Regla no. 1 - la regla de la información
 Toda la información en un RDBMS está explícitamente representada de una sola manera por
valores en una tabla.
 Cualquier cosa que no exista en una tabla no existe del todo. Toda la información, incluyendo
nombres de tablas, nombres de vistas, nombres de columnas, y los datos de las columnas
deben estar almacenados en tablas dentro de las bases de datos. Las tablas que contienen tal
información constituyen el Diccionario de Datos. Esto significa que todo tiene que estar
almacenado en las tablas.
 Toda la información en una base de datos relacional se representa explícitamente en el nivel
lógico exactamente de una manera: con valores en tablas. Por tanto los metadatos
(diccionario, catálogo) se representan exactamente igual que los datos de usuario. Y puede
usarse el mismo lenguaje (ej. SQL) para acceder a los datos y a los metadatos (regla 4)
2.2.1.1.2.4.2 Regla no. 2 - la regla del acceso garantizado
 Cada ítem de datos debe ser lógicamente accesible al ejecutar una búsqueda que combine el
nombre de la tabla, su clave primaria, y el nombre de la columna.

121
 Esto significa que dado un nombre de tabla, dado el valor de la clave primaria, y dado el
nombre de la columna requerida, deberá encontrarse uno y solamente un valor. Por esta
razón la definición de claves primarias para todas las tablas es prácticamente obligatoria.
2.2.1.1.2.4.3 REGLA NO. 3 - Tratamiento sistemático de los valores nulos
 La información inaplicable o faltante puede ser representada a través de valores nulos
 Un RDBMS (Sistema Gestor de Bases de Datos Relacionales) debe ser capaz de soportar el
uso de valores nulos en el lugar de columnas cuyos valores sean desconocidos.
2.2.1.1.2.4.4 Regla no. 4 - La regla de la descripción de la base de datos
 La descripción de la base de datos es almacenada de la misma manera que los datos
ordinarios, esto es, en tablas y columnas, y debe ser accesible a los usuarios autorizados.
 La información de tablas, vistas, permisos de acceso de usuarios autorizados, etc, debe ser
almacenada exactamente de la misma manera: En tablas. Estas tablas deben ser accesibles
igual que todas las tablas, a través de sentencias de SQL (o similar).
2.2.1.1.2.4.5 Regla no. 5 - La regla del sub-lenguaje integral
 Debe haber al menos un lenguaje que sea integral para soportar la definición de datos,
manipulación de datos, definición de vistas, restricciones de integridad, y control de
autorizaciones y transacciones.
 Esto significa que debe haber por lo menos un lenguaje con una sintaxis bien definida que
pueda ser usado para administrar completamente la base de datos.
2.2.1.1.2.4.6 Regla no. 6 - la regla de la actualización de vistas
 Todas las vistas que son teóricamente actualizables, deben ser actualizables por el sistema
mismo.
 La mayoría de las RDBMS permiten actualizar vistas simples, pero deshabilitan los intentos
de actualizar vistas complejas.
2.2.1.1.2.4.7 Regla no. 7 - la regla de insertar y actualizar
 La capacidad de manejar una base de datos con operandos simples aplica no sólo para la
recuperación o consulta de datos, sino también para la inserción, actualización y borrado de
datos'.
 Esto significa que las cláusulas para leer, escribir, eliminar y agregar registros (SELECT,
UPDATE, DELETE e INSERT en SQL) deben estar disponibles y operables,
independientemente del tipo de relaciones y restricciones que haya entre las tablas o no.

122
2.2.1.1.2.4.8 Regla no. 8 - la regla de independencia física
 El acceso de usuarios a la base de datos a través de terminales o programas de aplicación,
debe permanecer consistente lógicamente cuando quiera que haya cambios en los datos
almacenados, o sean cambiados los métodos de acceso a los datos.
 El comportamiento de los programas de aplicación y de la actividad de usuarios vía
terminales debería ser predecible basados en la definición lógica de la base de datos, y éste
comportamiento debería permanecer inalterado, independientemente de los cambios en la
definición física de ésta.
2.2.1.1.2.4.9 Regla no. 9 - la regla de independencia lógica
 Los programas de aplicación y las actividades de acceso por terminal deben permanecer
lógicamente inalteradas cuando quiera que se hagan cambios (según los permisos
asignados) en las tablas de la base de datos.
 La independencia lógica de los datos especifica que los programas de aplicación y las
actividades de terminal deben ser independientes de la estructura lógica, por lo tanto los
cambios en la estructura lógica no deben alterar o modificar estos programas de aplicación.
2.2.1.1.2.4.10 Regla no. 10 - la regla de la independencia de la integridad
Todas las restricciones de integridad deben ser definibles en los datos, y almacenables en
el catálogo, no en el programa de aplicación.
2.2.1.1.2.5 Las reglas de integridad.-
1. Ningún componente de una clave primaria puede tener valores en blanco o nulos (ésta es la
norma básica de integridad).
2. Para cada valor de clave foránea deberá existir un valor de clave primaria concordante. La
combinación de estas reglas aseguran que haya integridad referencial.
2.2.1.1.2.5.1 Regla no. 11 - la regla de la distribución
 El sistema debe poseer un lenguaje de datos que pueda soportar que la base de datos esté
distribuida físicamente en distintos lugares sin que esto afecte o altere a los programas de
aplicación.
 El soporte para bases de datos distribuidas significa que una colección arbitraria de
relaciones, bases de datos corriendo en una mezcla de distintas máquinas y distintos
sistemas operativos y que esté conectada por una variedad de redes, pueda funcionar como
si estuviera disponible como en una única base de datos en una sola máquina.

123
2.2.1.1.2.5.2 Regla no. 12 - regla de la no-subversión
 Si el sistema tiene lenguajes de bajo nivel, estos lenguajes de ninguna manera pueden ser
usados para violar la integridad de las reglas y restricciones expresadas en un lenguaje de
alto nivel (como SQL).
 Algunos productos solamente construyen una interfaz relacional para sus bases de datos No
relacionales, lo que hace posible la subversión (violación) de las restricciones de integridad.
Esto no debe ser permitido.
2.2.1.1.2.6 Modelo Entidad – Relación
2.2.1.1.2.6.1 Definición
Un diagrama o modelo entidad-relación (a veces denominado por sus siglas en inglés, E-R
"Entity relationship", o del español DER "Diagrama de Entidad Relación") es una herramienta
para el modelado de datos que permite representar las entidades relevantes de un sistema de
información así como sus interrelaciones y propiedades.
2.2.1.1.2.6.2 Modelado Entidad-Relación
1. Se elabora el diagrama (o diagramas) entidad-relación.
2. Se completa el modelo con listas de atributos y una descripción de otras restricciones que no
se pueden reflejar en el diagrama.
El modelado de datos no acaba con el uso de esta técnica. Son necesarias otras técnicas
para lograr un modelo directamente implementable en una base de datos. Brevemente:
 Transformación de relaciones múltiples en binarias.
 Normalización de una base de datos de relaciones (algunas relaciones pueden transformarse
en atributos y viceversa).
 Conversión en tablas (en caso de utilizar una base de datos relacional).
2.2.1.1.2.6.2.1 Base teórica y conceptual
El modelo de datos entidad-relación está basado en una percepción del mundo real que
consta de una colección de objetos básicos, llamados entidades, y de relaciones entre esos
objetos.

124
2.2.1.1.2.6.2.1.1 Entidad
Representa una “cosa” u "objeto" del mundo real con existencia independiente, es decir, se
diferencia unívocamente de otro objeto o cosa, incluso siendo del mismo tipo, o una misma
entidad.
Algunos Ejemplos:
 Una persona. (Se diferencia de cualquier otra persona, incluso siendo gemelos).
 Un automóvil. (Aunque sean de la misma marca, el mismo modelo,..., tendrán atributos
diferentes, por ejemplo, el número de chasis).
 Una casa (Aunque sea exactamente igual a otra, aún se diferenciará en su dirección).
Una entidad puede ser un objeto con existencia física como: una persona, un animal, una
casa, etc. (entidad concreta); o un objeto con existencia conceptual como: un puesto de trabajo,
una asignatura de clases, un nombre, etc. (entidad abstracta).
Una entidad está descrita y se representa por sus características o atributos. Por ejemplo,
la entidad Persona las características: Nombre, Apellido, Género, Estatura, Peso, Fecha de
nacimiento.
2.2.1.1.2.6.2.1.2 Atributos
Los atributos son las características que definen o identifican a una entidad. Estas pueden
ser muchas, y el diseñador solo utiliza o implementa las que considere más relevantes. Los
atributos son las propiedades que describen a cada entidad en un conjunto de entidades.
En un conjunto de entidades del mismo tipo, cada entidad tiene valores específicos
asignados para cada uno de sus atributos, de esta forma, es posible su identificación unívoca.
Ejemplos:
A la colección de entidades «alumnos», con el siguiente conjunto de atributos en común,
(id, nombre, edad, semestre), pertenecen las entidades:
 (1, Sofía, 38 años, 2)
 (2, Josefa, 19 años, 5)
 (3, Carlos, 20 años, 2)
 ...
Cada una de las entidades pertenecientes a este conjunto se diferencia de las demás por el
valor de sus atributos. Nótese que dos o más entidades diferentes pueden tener los mismos
valores para algunos de sus atributos, pero nunca para todos.

125
En particular, los atributos identificativos son aquellos que permiten diferenciar a una
instancia de la entidad de otra distinta. Por ejemplo, el atributo identificativo que distingue a un
alumno de otro es su número de id.
Para cada atributo, existe un dominio del mismo, este hace referencia al tipo de datos que
será almacenado o a restricciones en los valores que el atributo puede tomar (cadenas de
caracteres, números, solo dos letras, solo números mayores que cero, solo números enteros...).
Cuando algún atributo correspondiente a una entidad no tiene un valor determinado,
recibe el valor nulo, bien sea porque no se conoce, porque no existe o porque no se sabe nada al
respecto del mismo.
2.2.1.1.2.6.2.1.3 Relación
Describe cierta dependencia entre entidades o permite la asociación de las mismas.
Ejemplo:
Si tenemos dos entidades, "CLIENTE" y "HABITACION", podemos entender la relación
entre ambas al tomar un caso concreto (ocurrencia) de cada una de ellas. Entonces, podríamos
tener la ocurrencia "Habitación 502", de la entidad "HABITACION" y la ocurrencia "Henry
Jonshon Mcfly Bogard", de la entidad "CLIENTE", entre las que es posible relacionar que la
habitación 502 se encuentra ocupada por el huésped de nombre Henry Jonshon.
Una relación tiene sentido al expresar las entidades que relaciona. En el ejemplo anterior,
podemos decir que un huésped (entidad), se aloja (relación) en una habitación (entidad).
2.2.1.1.2.6.2.1.4 Conjunto de relaciones
Consiste en una colección, o conjunto, de relaciones de la misma naturaleza.
Ejemplo:
Dados los conjuntos de entidades "Habitación" y "Huésped", todas las relaciones de la
forma habitación-huésped, permiten obtener la información de los huéspedes y sus respectivas
habitaciones.
La dependencia o asociación entre los conjuntos de entidades es llamada participación. En
el ejemplo anterior los conjuntos de entidades "Habitación" y "Huésped" participan en el
conjunto de relaciones habitación-huésped.
Se llama grado del conjunto de relaciones a la cantidad de conjuntos de entidades
participantes en la relación.

126
2.2.1.1.2.7 Restricciones.-
Son reglas que deben mantener los datos almacenados en la base de datos.
2.2.1.1.2.7.1 Correspondencia de cardinalidades
Dado un conjunto de relaciones en el que participan dos o más conjuntos de entidades, la
correspondencia de cardinalidad indica el número de entidades con las que puede estar
relacionada una entidad dada.
Dado un conjunto de relaciones binarias y los conjuntos de entidades A y B, la
correspondencia de cardinalidades puede ser:
 Uno a Uno: (1:1) Una entidad de A se relaciona únicamente con una entidad en B y
viceversa (ejemplo relación vehículo - matrícula: cada vehículo tiene una única matrícula, y
cada matrícula está asociada a un único vehículo).
 Uno a varios: (1:N)Una entidad en A se relaciona con cero o muchas entidades en B. Pero
una entidad en B se relaciona con una única entidad en A (ejemplo vendedor - ventas).
 Varios a Uno: (N:1)Una entidad en A se relaciona exclusivamente con una entidad en B.
Pero una entidad en B se puede relacionar con 0 o muchas entidades en A (ejemplo
empleado-centro de trabajo).
 Varios a Varios: (N:M)Una entidad en A se puede relacionar con 0 o muchas entidades en B
y viceversa (ejemplo asociaciones- ciudadanos, donde muchos ciudadanos pueden
pertenecer a una misma asociación, y cada ciudadano puede pertenecer a muchas
asociaciones distintas).
2.2.1.1.2.7.2 Restricciones de participación
Dado un conjunto de relaciones R en el cual participa un conjunto de entidades A, dicha
participación puede ser de dos tipos:
 Total: Cuando cada entidad en A participa en al menos una relación de R.
 Parcial: Cuando al menos una entidad en A NO participa en alguna relación de R.
2.2.1.1.2.8 Claves
Es un subconjunto del conjunto de atributos comunes en una colección de entidades, que
permite identificar inequívocamente cada una de las entidades pertenecientes a dicha colección.
Asimismo, permiten distinguir entre sí las relaciones de un conjunto de relaciones.
Dentro de los conjuntos de entidades existen los siguientes tipos de claves:

127
 Superclave: Es un subconjunto de atributos que permite distinguir unívocamente cada una
de las entidades de un conjunto de entidades. Si se añade un atributo al anterior
subconjunto, el resultado seguirá siendo una superclave.
 Clave candidata: Dada una superclave, si ésta deja de serlo quitando únicamente uno de los
atributos que la componen, entonces ésta es una clave candidata.
 Clave primaria: Es una clave candidata, elegida por el diseñador de la base de datos, para
identificar unívocamente las entidades en un conjunto de entidades.
Los valores de los atributos de una clave, no pueden ser todos iguales para dos o más instancias.
Para poder distinguir unívocamente las relaciones en un conjunto de relaciones R, se
deben considerar dos casos:
 R NO tiene atributos asociados: En este caso, se usa como clave primaria de R la unión de
las claves primarias de todos los conjuntos de entidades participantes.
 R tiene atributos asociados: En este caso, se usa como clave primaria de R la unión de los
atributos asociados y las claves primarias de todos los conjuntos de entidades participantes.
Si el conjunto de relaciones, R, sobre las que se pretende determinar la clave primaria está
compuesto de relaciones binarias, con los conjuntos de entidades participantes A y B, se
consideran los siguientes casos, según sus cardinalidades:
 R es de muchos a uno de A a B entonces sólo se toma la clave primaria de A, como clave
primaria de R.
 R es de uno a muchos de A a B entonces se toma sólo la clave primaria de B, como clave
primaria de R.
 R es de uno a uno de A a B entonces se toma cualquiera de las dos claves primarias, como
clave primaria de R.
 R es de muchos a muchos de A a B entonces se toma la unión de los atributos que
conforman las claves primarias de A y de B, como clave primaria de R.
2.2.1.1.2.9 Diagrama Entidad-Relación
Anteriormente detallamos los conceptos relacionados al modelo ER, en esta sección
profundizaremos en como representarlos gráficamente. Cabe destacar que para todo proceso de
modelado, siempre hay que tener en claro los conceptos, estos nos brindan conocimiento
necesario y además fundamentan nuestro modelo al momento de presentarlo a terceros.

128
Formalmente, los diagramas ER son un lenguaje gráfico para describir conceptos.
Informalmente, son simples dibujos o gráficos que describen información que trata un sistema
de información y el software que lo automatiza.
2.2.1.1.2.9.1 Entidades
Las entidades son el fundamento del modelo entidad relación. Podemos adoptar como
definición de entidad cualquier cosa o parte del mundo que es distinguible del resto. Por
ejemplo, en un sistema bancario, las personas y las cuentas bancarias se podrían interpretar
como entidades. Las entidades pueden representar entes concretos, como una persona o un
avión, o abstractas, como por ejemplo un préstamo o una reserva. Se representan por medio de
un rectángulo que pueden ser de tipo: maestras, transaccionales, históricas y temporales
2.2.1.1.2.9.2 Atributos
Se representan mediante un círculo o elipse etiquetado mediante un nombre en su
interior. Cuando un atributo es identificativo de la entidad se suele subrayar dicha etiqueta.
Por motivos de legibilidad, los atributos suelen no aparecer representados en el diagrama
entidad-relación, sino descritos textualmente en otros documentos adjuntos.
2.2.1.1.2.9.3 Relaciones
Se representan mediante un rombo etiquetado en su interior con un verbo. Este rombo se
debe unir mediante líneas con las entidades (rectángulos) que relaciona, para así saber cuál es la
relación que lleva cada uno.
2.2.1.1.2.10 Diagramas Extendidos.-
Los diagramas Entidad-Relación no cumplen su propósito con eficacia debido a que tienen
limitaciones semánticas. Por ese motivo se suelen utilizar los diagramas Entidad-Relación
extendidos que incorporan algunos elementos más al lenguaje:

129
2.2.1.1.2.10.1 Entidades Fuertes y Débiles.-
Cuando una entidad participa en una relación puede adquirir un papel fuerte o débil. Una
entidad débil es aquella que no puede existir sin participar en la relación; es decir, aquella que
no puede ser unívocamente identificada solamente por sus atributos.
Una entidad fuerte (también conocida como entidad regular) es aquella que sí puede ser
identificada unívocamente. En los casos en que se requiera, se puede dar que una entidad fuerte
"preste" algunos de sus atributos a una entidad débil para que esta última se pueda identificar.
Las entidades débiles se representan- mediante un doble rectángulo; es decir, un
rectángulo con doble línea.
Se puede hablar de la existencia de 2 tipos de dependencias en las entidades débiles:
 Dependencia por existencia.
Las ocurrencias de la entidad débil pueden identificarse mediante un atributo
identificador clave sin necesidad de identificar la entidad fuerte relacionada.
 Dependencia por identidad.
La entidad débil no puede ser identificada sin la entidad fuerte relacionada. (Ejemplo:
si tenemos una entidad LIBRO y otra relacionada EDICIÓN, para identificar una edición
necesitamos conocer el identificador del libro).
2.2.1.1.2.10.2 Cardinalidad de las relaciones
El tipo de cardinalidad se representa mediante una etiqueta en el exterior de la relación,
respectivamente: "1:1", "1:N" y "N:M", aunque la notación depende del lenguaje utilizado, la que
más se usa actualmente es el unificado. Otra forma de expresar la cardinalidad es situando un
símbolo cerca de la línea que conecta una entidad con una relación:
 "0" si cada instancia de la entidad no está obligada a participar en la relación.
 "1" si toda instancia de la entidad está obligada a participar en la relación y, además,
solamente participa una vez.
 "N" , "M", o "*" si cada instancia de la entidad no está obligada a participar en la relación
y puede hacerlo cualquier número de veces.
Ejemplos de relaciones que expresan cardinalidad:
 Cada esposo (entidad) está casado (relación) con una única esposa (entidad) y viceversa.
Es una relación 1:1.

130
 Una factura (entidad) se emite (relación) a una persona (entidad) y sólo una, pero una
persona puede tener varias facturas emitidas a su nombre. Todas las facturas se emiten a
nombre de alguien. Es una relación 1:N.
 Un cliente (entidad) puede comprar (relación) varios servicios (entidad) y un servicio
puede ser comprado por varios clientes distintos. Es una relación N:M.
2.2.1.1.2.10.3 Atributos en relaciones
Las relaciones también pueden tener atributos asociados. Se representan igual que los
atributos de las entidades. Un ejemplo típico son las relaciones de tipo "histórico" donde debe
constar una fecha o una hora. Por ejemplo, supongamos que es necesario hacer constar la fecha
de emisión de una factura a un cliente, y que es posible emitir duplicados de la factura (con
distinta fecha). En tal caso, el atributo "Fecha de emisión" de la factura debería colocarse en la
relación "se emite".
2.2.1.1.2.10.4 Herencia
La herencia es un intento de adaptación de estos diagramas al paradigma orientado a
objetos. La herencia es un tipo de relación entre una entidad "padre" y una entidad "hijo". La
entidad "hijo" hereda todos los atributos y relaciones de la entidad "padre". Por tanto, no
necesitan ser representadas dos veces en el diagrama. La relación de herencia se representa
mediante un triángulo interconectado por líneas a las entidades. La entidad conectada por el
vértice superior del triángulo es la entidad "padre". Solamente puede existir una entidad "padre"
(herencia simple). Las entidades "hijo" se conectan por la base del triángulo.
2.2.1.1.2.10.5 Agregación
Es una abstracción a través de la cual las relaciones se tratan como entidades de un nivel
más alto. Se utiliza para expresar relaciones entre relaciones o entre entidades y relaciones. Se
representa englobando la relación abstraída y las entidades que participan en ella en un
rectángulo. En la figura se muestra un ejemplo de agregación en el que se representa la situación

131
en la que un profesor, cuando está impartiendo una clase, puede poner una incidencia ocurrida a
lo largo de ésta (se fue la luz, falta la configuración de un determinado software, etc.).
2.2.1.2 Ejemplo.
PostGre SQL
Pasos para agregar una librería en NetBeans.-
1. Nos dirigimos al Menú Herramientas y damos clic en Bibliotecas.

132
2. Luego en Administrador de Bibliotecas damos clic en Nueva Biblioteca.
3. En Nombre de biblioteca ponemos PostgreSQL y damos clic en Aceptar.

133
4. En esta ventana damos clic en .
5. Elegimos el archivo y damos clic en .

134
6. Por último damos clic en Aceptar.
NetBeans
Codificación para conectar y guardar en la base de datos desde un formulario de NetBeans
String driver = "org.postgresql.Driver";
String connectionString =
"jdbc:postgresql://localhost:5432/veterinaria/";//muestra DB
String user = "postgres";//usuario DB
String password = "12345";//contraseña
try {
Class.forName(driver);//hacemos la conexion
Connection conn = DriverManager.getConnection(connectionString, user, password);
PreparedStatement stm = conn.prepareStatement("INSERT INTO
veterinaria.cliente(cli_codigo, cli_nombre, cli_telefono, cli_direccion) VALUES
(?,?,?,?)");
stm.setString(1, txtCodigo.getText());
stm.setString(2, txtNombre.getText());
stm.setString(3, txtTelefono.getText());

135
stm.setString(4, txtDireccion.getText());
stm.executeUpdate();
JOptionPane.showMessageDialog(this, "insertado...!");
} catch (Exception e) {
JOptionPane.showMessageDialog(this, e.toString());
}.
Codificación para conectar y guardar en la base de datos desde un formulario de NetBeans
btnNuevoActionPerformed(java.awt.event.ActionEvent evt) {
String driver = "org.postgresql.Driver";
String connectionString =
"jdbc:postgresql://localhost:5432/veterinaria/";//muestra DB
String user = "postgres";//usuario DB
String password = "12345";//contraseña
try {
Class.forName(driver);//hacemos la conexion
Connection conn = DriverManager.getConnection(connectionString,
user, password);
PreparedStatement stm = conn.prepareStatement("INSERT INTO
veterinaria.medico(med_codigo, med_nombre, med_telefono, med_direccion) VALUES
(?,?,?,?)");
stm.setString(1, txtCodigo.getText());
stm.setString(2, txtNombre.getText());
stm.setString(3, txtTelefono.getText());

136
stm.setString(4, txtDireccion.getText());
stm.executeUpdate();
JOptionPane.showMessageDialog(this, "insertado...!");
} catch (Exception e) {
JOptionPane.showMessageDialog(this, e.toString());
}
}

137
2.3 MODULO ENTORNO WEB.
2.3.1 Java WEB.
2.3.1.1.1 Introducción.
La Web dinámica se ha desarrollado desde un sistema de información distribuido
hipermedia (HTML) basado en red que ofrecía información estática hasta un conjunto de
portales y aplicaciones en Internet que ofrecen un conjunto variado de servicios.
Las soluciones de primera generación incluyeron CGI, que es un mecanismo para
ejecutar programas externos en un servidor web. El problema con los scripts CGI es la
escalabilidad; se crea un nuevo proceso para cada petición.
Las soluciones de segunda generación incluyeron vendedores de servidores Web
que proporcionaban plug-ins y APIs para sus servidores. El problema es que sus
soluciones eran específicas a sus productos servidores. Microsoft proporcionó las
páginas activas del servidor (ASP) que hicieron más fácil crear el contenido dinámico.
Sin embargo, su solución sólo trabajaba con Microsoft IIS o Personal Web Server. Otra
tecnología de segunda generación son los Servlets. Los Servlets hacen más fácil escribir
aplicaciones del lado del servidor usando la tecnología Java. El problema con los CGI o
los Servlets, sin embargo, es que tenemos que seguir el ciclo de vida de escribir, compilar
y desplegar.
Las páginas JSP son una solución de tercera generación que se pueden combinar
fácilmente con algunas soluciones de la segunda generación, creando el contenido
dinámico, y haciendo más fácil y más rápido construir las aplicaciones basadas en Web
que trabajan con una variedad de otras tecnologías: servidores Web, navegadores Web,
servidores de aplicación y otras herramientas de desarrollo.
La tecnología Java Server Pages™ (JSP) nos permite poner segmentos de código
servlet directamente dentro de una página HTML estática. Cuando el navegador carga
una página JSP, se ejecuta el código del servlet y el servidor de aplicaciones crea,
compila, carga y ejecuta un servlet en segundo plano para ejecutar los segmentos de
código servlet y devolver una página HTML o imprimir un informe XML.

138
2.3.1.1.1.1 Modelo cliente-servidor.
Cuando se utiliza un servicio en Internet, como consultar una base de datos,
transferir un fichero o participar en un foro de discusión, se establece un proceso en el
que entran en juego dos partes. Por un lado, el usuario, quien ejecuta una aplicación en
el ordenador local: el denominado programa cliente. Este programa cliente se encarga
de ponerse en contacto con el ordenador remoto para solicitar el servicio deseado. El
ordenador remoto por su parte responderá a lo solicitado mediante un programa que
está ejecutando. Este último se denomina programa servidor. Los términos cliente y
servidor se utilizan tanto para referirse a los programas que cumplen estas funciones,
como a los ordenadores donde son ejecutados esos programas.
El programa o los programas cliente que el usuario utiliza para acceder a los
servicios de Internet realizan dos funciones distintas. Por una parte, se encargan de
gestionar la comunicación con el ordenador servidor, de solicitar un servicio concreto y
de recibir los datos enviados por éste; y por otra, es la herramienta que presenta al
usuario los datos en pantalla y que le ofrece los comandos necesarios para utilizar las
prestaciones que ofrece el servidor.
El navegador es una especie de aplicación capaz de interpretar las órdenes
recibidas en forma de código HTML fundamentalmente y convertirlas en las páginas que
son el resultado de dicha orden.
Fig. Lenguajes del lado cliente y del lado servidor

139
Fig. Ejecución en el modelo web cliente-servidor
En resumen, los programadores de aplicaciones JAVA mediante la especificación
J2EE escriben componentes de aplicación J2EE. Un componente J2EE es una unidad de
software funcional auto-contenida que se ensambla dentro de una aplicación J2EE y que
se comunica con otros componentes de aplicación. La especificación J2EE define los
siguientes componentes de aplicación:
 Componentes de Aplicación Cliente: Navegador y páginas jsp renderizadas
 Componentes JavaBeans Enterprise: clases de negocio (EJBs)
 Componentes Servlets y JavaServer Pages (también llamados componentes
Web): clases controladoras.
 Applets: pequeñas aplicaciones que se ejecutan en el cliente
2.3.1.1.1.2 Acceso a Datos
Una de las tareas más importantes y más frecuentemente realizadas por los
servlets es la conexión a bases de datos mediante JDBC. Esto es debido a que los servlets
son un componente ideal para hacer las funciones de capa media en un sistema con una
arquitectura de tres capas como la mostrada en la Figura:

140
2.3.1.1.1.3 Formas de seguir la trayectoria de los usuarios (clientes)
Los servlets permiten seguir la trayectoria de un cliente, es decir, obtener y
mantener una determinada información acerca del cliente. De esta forma se puede tener
identificado a un cliente (usuario que está utilizando un browser) durante un
determinado tiempo. Esto es muy importante si se quiere disponer de aplicaciones que
impliquen la ejecución de varios servlets o la ejecución repetida de un mismo servlet. Un
claro ejemplo de aplicación de esta técnica es el de los comercios vía Internet que
permiten llevar un carrito de la compra en el que se van guardando aquellos productos
solicitados por el cliente. El cliente puede ir navegando por las distintas secciones del
comercio virtual, es decir realizando distintas conexiones HTTP y ejecutando diversos
servlets, y a pesar de ello no se pierde la información contenida en el carrito de la
compra y se sabe en todo momento que es un mismo cliente quien está haciendo esas
conexiones diferentes.
El mantener información sobre un cliente a lo largo de un proceso que implica
múltiples conexiones se puede realizar de tres formas distintas:
 Mediante cookies
 Mediante seguimiento de sesiones (Session Tracking)

141
 Mediante la reescritura de URLs y paso de parámetros en formulario (Request)
2.3.1.1.2 EJBs
Un EJB es un componente del lado del servidor que encapsula la lógica del negocio
de una aplicación. En cualquier aplicación, los beans enterprise implementan los
métodos de la lógica del negocio, que pueden ser invocados por clientes remotos para
acceder a los servicios importantes proporcionados por la aplicación.
2.3.1.1.2.1 Beneficios
Los EJBs simplifican el desarrollo de grandes aplicaciones empresariales seguras y
distribuidas por las siguientes razones:
 Los desarrolladores pueden concentrarse en solventar la lógica del
negocio: el contenedor EJB proporciona servicios a nivel del sistema como el
control de transaciones y las autorizaciones de seguridad. Por lo tanto, los
desarrolladores o tienen que preocuparse de estos problemas.
 Clientes pequeños: Los desarrolladores no tienen que desarrollar código para
las reglas de negocio o accesos a bases de datos; pueden concentrarse en la
presentación del cliente. El resultado final es que los clientes son pequeños, y
esto es especialmente importante para clientes que se ejecutan en pequeños
dispositivos con recursos limitados.
 Desarrollo rápido: Los EJBs son componentes portables, y por lo tanto los
ensambladores de aplicaciones pueden construir nuevas aplicaciones desde
beans existentes. Las aplicaciones resultantes se pueden ejecutar en cualquier
servidor compatible J2EE.
2.3.1.1.2.2 Componentes
Hay dos tipos principales de componentes EJB : session y entity. Un EJB de sesión
se usa para realizar una tarea para un cliente, y un EJB de entidad es específico del
dominio y se usa para representar un objeto de entidad del negocio que existe en un
almacenamiento persistente. Sin embargo, los beans de entidad y de sesión tienen
algunas diferencias que podemos ver en la siguiente tabla:

142
EJB de Sesión EJB de Entidad
 Transitorio
 Puede ser usado por un sólo
cliente.
 No tiene identidad
 Persistente
 Puede ser usado por muchos
clientes.
 Tiene una identidad (como una
clave primaria)
2.3.1.1.2.3 Desarrollar EJBs
Para desarrollar EJBs, todo bean enterprise necesita:
 Un interface remoto que exponga los métodos que soporta bean enterprise.
 Un interface home que proporciona los métodos del ciclo de vida del bean
enterprise.
 Una clase de implementación, incluyendo la lógica de negocio que necesite.
2.3.1.1.2.4 EJBs contra Servlets
A primera vista, los EJBs y los Servlets son tecnologías similares porque ambos son
componentes distribuidos del lado del servidor. Sin embargo, hay una diferencia
importante entre los dos en el tipo de solución que ofrecen; los EJBs no pueden aceptar
peticiones HTTP.
En otras palabras, los EJBs no peuden servir peticiones que vienen directamente
desde un navegador Web, y los servlets si pueden. Servlets y JSPs se pueden usar para
implementar presentación y control web, pero al contrario que los EJBs, no pueden
manejar transacciones distribuidas. Los EJBs pueden ser llamados desde cualquier
cliente basado en Java.
2.3.1.1.2.5 ¿Cúando usar EJBs?
Los EJBs son buenos para las aplicaciones que tienen alguno de estos requerimientos:
 Escalabilidad: si tenemos un número creciente de usuarios, los EJBs nos
permitirán distribuir los componentes de nuestra aplicación entre varias
máquinas con su localización transparente para los usuarios.

143
 Integridad de Datos: los EJBs nos facilitan el uso de transacciones distribuidas.
 Variedad de clientes: si nuestra aplicación va a ser accedida por una variedad
de clientes (como navegadores tradicionales o navegadores WAP), se pueden
usar los EJBs para almacenar el modelo del negocio, y se puede usar una
variedad de clientes para acceder a la misma información.
2.3.2 Framework.
2.3.2.1.1 ¿Qué es un Framework?
Un Framework es una abstracción de un componente de software para resolver un
problema en un contexto.
 No hay que limitarlo a aplicaciones Web.
 Existen también para desarrollar juegos, aplicaciones médicas, aplicaciones
empresariales, aplicaciones de escritorio, dispositivos móviles, etc.
 Aplicación genérica que interactúa con nuestro desarrollo y que a la vez es
configurable.
2.3.2.1.2 Objetivos de Usar un Framework
Los objetivos principales que persigue un Framework son:
 Acelerar el proceso de desarrollo.
 Reutilizar código ya existente.

144
 Promover buenas prácticas de desarrollo como el uso de patrones.

145
2.3.2.1.3 Modelo – Vista – Controlador
Guía para el diseño de arquitecturas de aplicaciones que interactúen con muchos
usuarios.
2.3.2.1.4 Frameworks para el Modelo MVC
 Para la vista o Presentación:
o Struts Versiones 1 (1.1 – 1.2 – 1.3) y 2.
o JSF (Java Server Faces)
 Para el controlador o lógica de negocio:
o Spring
 Para el acceso a datos o persistencia de datos:
o Hibernate
o Ibatis
o Symbian
o EJB

146
2.3.2.1.5 Struts
2.3.2.1.5.1 Archivos de Configuración:
 struts-config.xml
 ApplicationResources.properties
 struts-html.tld
 struts-bean.tld
 struts-logic.tld

147
2.3.2.1.6 Spring Framework
 Object/relational mapping integration module: spring no implementa su propio orm
(objet relational mapping), incluye implementaciones para ibatis, hibernate, JDO, etc.
 Spring’s web module: Orientado a tareas Web, integración y soporte con struts.
 The Spring MVC framework: 100 % modelo vista controlador para separar el
controlador de los objetos de negocio.
2.3.2.1.7 Hibernate
Framework para la persistencia de objetos hacia bases de datos (orm = OBJECT
RELATIONAL MAPPING)
 Se basa en SessionFactory y Transacciones hacia bases de datos.
 Soporta el uso de Annotations
 Las consultas se pueden realizar a nivel de objetos (HSQL) y a nivel de SQL.

148
2.3.3 Java Server.
2.3.3.1.1 Introducción a JSP.
La tecnología JSP (Java Server Pages) es una especificación abierta desarrollada
por Sun Microsystems como un alternativa a Active Server Pages (ASP) de Microsoft, y
son un componente dominante de la especificación de Java 2 Enterprise Edition (J2EE).
Muchos delos servidores de aplicaciones comercialmente disponibles (como BEA
WebLogic, IBM WebSphere, Live JRun, Orion, etcétera) ya utilizan tecnología JSP.
Esta tecnología permite desarrollar páginas web con contenido dinámico y supone
una evolución frente a la tecnología CGI, y los Servlets. Un fichero JSP puede contener
etiquetas HTML normales, y elementos especiales para generar el contenido dinámico.
Al mismo tiempo permite una separación en n capas de la arquitectura de la
aplicación web y se integra perfectamente con todas las API's empresariales de Java:
JDBC, RMI (y CORBA), JNDI, EJB, JMS, JTA, ...
2.3.3.1.1.1 Estructura de una página JSP
Una página JSP es básicamente una página Web con HTML tradicional y código
Java. La extensión de fichero de una página JSP es ".jsp" en vez de ".html" o".htm", y eso
le dice al servidor que esta página requiere un manejo especial que se conseguirá con
una extensión del servidor o un plug-in.
Un ejemplo sencillo:
<%@ page language="java" contentType="text/html" %>
<html>
<head>
<title>Hola, mundo!!</title>
</head>
<body>
<h1>Hola, mundo!</h1>
Hoy es <%= new java.util.Date() %>.
</body>
</html>
2.3.3.1.1.1.1 Directivas
Las directivas JSP son instrucciones procesadas por el motor JSP cuando la página
JSP se traduce a un servlet. Las directivas usadas en este ejemplo le dicen al motor JSP

149
que incluya ciertos paquetes y clases. Las directivas están encerradas entre etiquetas de
directiva <%@ y %>.
<%@ page import="javax.naming.*" %>
<%@ page import="javax.rmi.PortableRemoteObject" %>
<%@ page import="Beans.*" %>
2.3.3.1.1.1.2 Declaraciones
Las declaraciones JSP nos permiten configurar variables para su uso posterior en
expresiones o scriptlets. También podemos declarar variables dentro de expresiones o
scriptlets en el momento de usarlas. El ámbito es toda la página JSP, no hay concepto de
variables de ejemplar. Es decir, no tenemos que declarar variables de ejemplar para usar
en más de una expresión o scriptlet. Las declaraciones van encerradas entre etiquetas de
declaración <%! y %>. Podemos tener varias declaraciones. Por ejemplo,
<%! double bonus; String text; %> .
<%! String strMult, socsec; %>
<%! Integer integerMult; %>
<%! int multiplier; %>
<%! double bonus; %>
2.3.3.1.1.1.3 Scriptlets
Los scriptlets JSP nos permiten embeber segmentos de código java dentro de una página
JSP. El código embebido se inserta directamente en el servlet generado que se ejecuta
cuando se pide la página. Este scriptlet usa las variables declaradas en las directivas
descritas arriba. Los Scriptlets van encerradas entre etiquetas <% y %>.
<%
strMult = request.getParameter("MULTIPLIER");
socsec = request.getParameter("SOCSEC");
integerMult = new Integer(strMult);
multiplier = integerMult.intValue();
bonus = 100.00;
%>
2.3.3.1.1.1.4 Variables Predefinidas
Un scriptlet puede usar las siguientes variables predefinidas: session, request,
response, out, e in. Este ejemplo usa la variable predefinida request, que es un objeto
HttpServletRequest. De igual forma, response es un objeto HttpServletResponse, out es
un objeto PrintWriter, e in es un objeto BufferedReader. Las variables predefinidas se
usan en los scriptlets de la misma forma que se usan en los servelts, excepto que no las
declaramos.

150
<%
strMult = request.getParameter("MULTIPLIER");
socsec = request.getParameter("SOCSEC");
integerMult = new Integer(strMult);
multiplier = integerMult.intValue();
bonus = 100.00;
%>
2.3.3.1.1.1.5 Expresiones
Las expresiones JSP nos permiten recuperar dinámicamente o calcular valores a
insertar directamente en la página JSP. En este ejemplo, una expresión recupera el
número de la seguridad social desde el bean de entidad Bonus y lo pone en la página JSP.
<H1>Bonus Calculation</H1>
Social security number retrieved:
<%= record.getSocSec() %>
<P>
Bonus Amount retrieved: <%= record.getBonus() %>
<P>
2.3.3.1.1.1.6 Etiquetas específicas de JSP
La especificación JavaServer Pages 1.1 define etiquetas específicas de JSP que nos
permiten extender la implementación JSP con nuevas características y ocultar mucha
complejidad a los diseñadores visuales que necesitan buscar la página JSP y modificarla.
Fig. Estructura de una página JSP

151
2.3.3.1.1.1.7 Procesamiento de la página JSP
Cuando se llame a ésta página (date.jsp), será compilada (por el motor JSP) en un
Servlet Java. En este momento el Servlet es manejado por el motor Servlet como
cualquier otro Servlet. El motor Servlet carga la clase Servlet (usando un cargador de
clases) y lo ejecuta para crear HTML dinámico para enviarlo al navegador, como se ve en
la Figura 2. Para este ejemplo, el Servelt crea un objeto Date y lo escribe como un String
en el objeto out, que es el stream de salida hacia el navegador.
2.3.3.1.1.1.8 Objetos implícitos
El motor JSP nos ofrece instancias de un conjunto de clases. Son objetos ya
establecidos, que no tenemos más que usar (no hay que instanciarlos). Deben utilizarse
dentro del código Java.
Algunos objetos implícitos:
 page (javax.servlet.jsp.HttpJspPage.): Instancia del servlet de la página. Esto es
sólo un sinónimo de this, y no es muy útil en Java. Fue creado como situación
para el día que el los lenguajes de script puedan incluir otros lenguajes distintos
de Java.
 config (javax.servlet.ServletConfig): Datos de configuración del servlet.
 request (javax.servlet.http.HttpServletRequest): Datos de la petición, incluyendo
los parámetros. Este es el HttpServletRequest asociado con la petición, y nos
permite mirar los parámetros de la petición (mediante getParameter), el tipo de
petición (GET, POST, HEAD, etc.), y las cabeceras HTTP entrantes (cookies,
Referer, etc.). Estrictamente hablando, se permite que la petición sea una
subclase de ServletRequest distinta de HttpServletRequest, si el protocolo de la

152
petición es distinto del HTTP. Esto casi nunca se lleva a la práctica. response
(javax.servlet.http.HttpServletResponse): Datos de la respuesta. Este es el
HttpServletResponse asociado con la respuesta al cliente. Como el stream de
salida tiene un buffer, es legal seleccionar los códigos de estado y cabeceras de
respuesta, aunque no está permitido en los servlets normales una vez que la
salida ha sido enviada al cliente.
 out (javax.servlet.jsp.JspWriter): Flujo de salida para el contenido de la
página. Este es el PrintWriter usado para enviar la salida al cliente. Sin embargo,
para poder hacer útil el objeto response esta es una versión con buffer de
PrintWriter llamada JspWriter. Podemos ajustar el tamaño del buffer, o incluso
desactivar el buffer, usando el atributo buffer de la directiva page. Se usa casi
exclusivamente en scriptlets ya que las expresiones JSP obtienen un lugar en el
stream de salida, y por eso raramente se refieren explícitamente a out.
 session (javax.servlet.http.HttpSession): Datos específicos de la sesión de un
usuario. Este es el objeto HttpSession asociado con la petición. Las sesiones se
crean automáticamente, por esto esta variable se une incluso si no hubiera una
sesión de referencia entrante. La única excepción es usar el atributo session de la
directiva page para desactivar las sesiones, en cuyo caso los intentos de
referenciar la variable sesión causarán un error en el momento de traducir la
página JSP a un servlet.
 application (javax.servlet.ServletContext): Datos compartidos por todas las
páginas de una aplicación. El ServletContext obtenido mediante
getServletConfig().getContext().
 pageContext (javax.servlet.jsp.PageContext): Datos de contexto para la
ejecución de la página. JSP presenta una nueva clase llamada PageContext para
encapsular características de uso específicas del servidor como JspWriters de
alto rendimiento. La idea es que, si tenemos acceso a ellas a través de esta clase
en vez directamente, nuestro código seguirá funcionando en motores servlet/JSP
"normales".
 exception (java.lang.Throwable): Errores o excepciones no capturadas.
Ejemplo:
<%
String strParam = request.getParameter("nombre_del_parametro");
out.println( strParam );
%>

153
3. REFERENCIAS.
 “Java – Paso a Paso”; Lopez Atienza; Lunes 06/01/11, 11:00; Blog Educativo.
http://www.lopezatienza.es/java/java-paso-a-paso-tema-11/
 “Sintaxis del lenguaje Java”; SeviaSoft; Lunes 06/01/11, 11:00; Blog Educativo.
http://tutorial.saviasoft.com/java-basico/html/collections-intro.html
 “Applet Java”; Deitel, Harvey, Paul & Asociados (2004); Lunes 06/01/11, 11:00;Wikipedia.
http://es.wikipedia.org/wiki/Applet_Java
 “LA CLASE APPLET”; Zarza; Lunes 06/01/11, 11:00; Blog Educativo.
http://zarza.usal.es/~fgarcia/doc/tuto2/VI_2.htm
 “Tutorial de Java”; Proton; Lunes 06/01/11, 11:00; Blog Educativo.
http://proton.ucting.udg.mx/tutorial/java/Cap9/cierre.html
 “Programación orientada a objetos con java -Capítulo 4: Excepciones en java”; Lunes
06/01/11, 11:00; Documento PDF.
 “Curso de Java”; Jesús Cáceres Tello; Lunes 06/01/11, 11:00; Documento PDF.
 “Introducción a las aplicaciones Web con JAVA”; Macario Polo,Daniel Villafranca;
Ingeniería del Software II. Curso 07-08. ESI-UCLM; Lunes 06/01/11, 11:00; Documento
PDF.
 “Frameworks en JAVA”; Juan Bugarin; slideshare; Lunes 06/01/11, 11:00.
http://www.slideshare.net/jlbugarin/frameworks-java-1456835
 http://es.wikipedia.org/wiki/Modelo_entidad-relaci%C3%B3n
 http://elies.rediris.es/elies9/4-1-2.htm
 http://es.wikipedia.org/wiki/Base_de_datos

PROYECTO MODULO CLIENTE SERVIDOR

Más contenido relacionado

La actualidad más candente (18)

Destacado (17)

Similar a PROYECTO MODULO CLIENTE SERVIDOR (20)

Último (20)

PROYECTO MODULO CLIENTE SERVIDOR