Manual Java

Este curso tiene por objetivo brindar el conocimiento sobre la programacin orientada a
objetos (OOP) en Java, esto incluye, clases, objetos, herencia, polimorfismo, ligadura
dinmica, constructores, sobre escritura de mtodos, relacin entre objetos, clases amigas,
entre otros, as como el manejo de interfaces graficas.
POO EN JAVA
JG TECNOLOGIAS

JG Tecnol ogas
CONTENIDO
JG TECNOLOGIAS

PRESENTACIN DEL CURSO ................................
POO EN JAVA ................................
UNIDAD I ................................................................
INTRODUCCIN A LA POO Y JAVA
Programacin orientada a objetos
El Lenguaje Java ................................
Compilacin, ByteCode y JVMs
Entornos de desarrollo Java ................................
Java vs otros lenguajes OO ................................
UNIDAD II ................................................................
POO EN JAVA ................................
Clases de Objetos ................................
Instanciacin de la clase ................................
Mtodos o atributos estticos
Proteccin de miembros de la clase
Clases amigas................................
Proteccin de Clases ................................
Inicializacin y finalizacin ................................
Sobrecarga de Operaciones................................
Creacin de objetos ................................
Trabajando con objetos ................................
Autoreferencias (this) ................................
Aplicaciones orientadas a objetos
Entrada y salida ................................
UNIDAD III ................................................................
RELACIN ENTRE OBJETOS
Relacin entre objetos ................................
La dependencia entre objetos
La asociacin entre objetos ................................
JG Tecnol ogas MANUAL JAVA jgtecnol ogias. com
CONTENIDO

................................................................................................
................................................................................................
................................................................................................
INTRODUCCIN A LA POO Y JAVA ................................................................
a objetos ................................................................
................................................................................................
Compilacin, ByteCode y JVMs ................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
Mtodos o atributos estticos ................................................................................................
Proteccin de miembros de la clase ................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
Aplicaciones orientadas a objetos ................................................................
................................................................................................
................................................................................................
................................................................................................
................................................................................................
dependencia entre objetos ................................................................................................
................................................................................................
CONTENIDO
PROGRAMATICO
Bsico

1

jgtecnol ogias. com
........................................ 4
............................................................... 4
.......................................... 5
............................................................ 5
.............................................................. 6
........................................................ 7
................................................................. 9
..................................... 10
..................................... 11
....................................... 13
............................................................. 13
.................................................... 14
.......................................... 15
................................... 17
......................................................... 18
.......................................................... 19
............................................... 22
....................................... 23
..................................... 24
................................................. 27
............................................ 29
............................................... 31
............................................................ 33
....................................................... 35
...................................... 40
.................................... 40
.............................................. 41
.................................. 41
...................................... 42
CONTENIDO
PROGRAMATICO
Bsico-Intermedio

2

La agregacin entre objetos ..................................................................................................... 44
La composicin entre objetos ................................................................................................... 44
Clases anidadas e interiores .................................................................................................... 46
UNIDAD IV ...................................................................................................................................... 48
HERENCIA .................................................................................................................................. 48
La herencia .............................................................................................................................. 49
Mtodo Super() ........................................................................................................................ 56
Anular la herencia .................................................................................................................... 58
Adicin, redefinicin y anulacin de la herencia ....................................................................... 58
La redifinicin ........................................................................................................................... 59
La anulacin ............................................................................................................................. 63
Proteccin y herencia ............................................................................................................... 64
Clases abstractas ..................................................................................................................... 65
Herencia mltiple ..................................................................................................................... 70
Polimorfismo ............................................................................................................................ 72
Ligadura dinmica .................................................................................................................... 76
UNIDAD V ....................................................................................................................................... 84
MULTI TAREA ............................................................................................................................. 84
UNIDAD VI ...................................................................................................................................... 87
ESTRUCTURAS DE DATOS EN JAVA ....................................................................................... 87
ArrayList ................................................................................................................................. 101
HashSet ................................................................................................................................. 111
HashMap ................................................................................................................................ 112
TreeSet .................................................................................................................................. 125
Resumen de Colecciones ...................................................................................................... 128
UNIDAD VII ................................................................................................................................... 133
INTERFACES GRFICAS ......................................................................................................... 133
Introduccin ........................................................................................................................... 134
Caractersticas de la programacin en GUIs .......................................................................... 134
Gestin de eventos ................................................................................................................ 137
Arquitectura de una aplicacin con GUI ................................................................................. 139
La capa de presentacin o interfaz......................................................................................... 139
La capa de aplicacin............................................................................................................. 139
La capa de persistencia ......................................................................................................... 139
Programacin de GUIs en Java ............................................................................................. 140
Componentes de swing .......................................................................................................... 144

3

UNIDAD VIII .................................................................................................................................. 148
EJERCICIOS ............................................................................................................................. 148
Orientacin a Objetos............................................................................................................. 149
Herencia................................................................................................................................. 149
Concurrencia. Hilos ................................................................................................................ 149
Ejercicios resueltos ................................................................................................................ 152

4

PRESENTACIN DEL CURSO
POO EN JAVA

Objetivo:
Este curso tiene como objetivo introducir a los
participantes en los conocimientos terico- prcticos de
la programacin orientada a objetos tales como:
clases, objetos, herencia, polimorfismo, templates,
entre otros utilizando como lenguaje de programacin
Java
Al concluir este curso el participante deber desarrollar
aplicaciones cliente- servidor bajo modo consola y bajo
interfaces grficas utilizando para ello la librera Swing.

Dirigido a:
Estudiantes, desarrolladores, profesionales con carrera
a fin, con slidos conocimientos de programacin
estructurada que quieran desarrollar aplicaciones
cliente-servidor bajo el paradigma de programacin
orientado a objetos.

POO EN JAVA
0

5


UNIDAD I

OBJETIVO:
El objetivo de esta unidad es ofrecer un conjunto de
saberes relacionados el entorno de desarrollo de Java,
esto incluye: la compilacin del cdigo fuente, las
maquinas virtuales, caractersticas, y las ventajas de
este lenguaje con otros.

PUNTOS A TRATAR:
1. Programacin orientada a objetos
2. El Lenguaje Java
3. Compilacin, ByteCode y JVMs
4. Entornos de desarrollo Java
5. Java vs otros lenguajes OO
1

6

PROGRAMACIN ORIENTADA A OBJETOS
1. Aparece a finales de los 60, pero es a principios de los 80 cuando con el lenguaje Smalltalk
comienza un inters claro hacia este paradigma
2. La programacin orientada a objetos es el paradigma de programacin y anlisis y diseo de
aplicaciones claramente dominante en la actualidad
3. Hoy prcticamente no se concibe un lenguaje de programacin sin caractersticas de
orientacin a objetos: Eiffel, C++, Java, C#, etc.

Las ventajas del paradigma OO son mltiples:
1. Es intuitiva, describe un problema en trminos similares a los que utiliza la mente humana
2. Permite construir soluciones ms seguras y con un mantenimiento ms sencillo
3. Fomenta la reutilizacin y el trabajo en equipo. Escalabilidad de las aplicaciones

Las caractersticas principales del paradigma OO:
1. Incorpora los conceptos de abstraccin, ocultacin de informacin y encapsulacin
heredados de los tipos de datos abstractos
2. Incorpora mecanismos especficos y extremadamente poderosos como son la herencia, el
polimorfismo y la ligadura dinmica
3. Admite de manera muy natural en algunos lenguajes el soporte de genericidad (patrones) y
la definicin de operadores. No soportados por Java

El desarrollo siguiendo el enfoque orientado a objetos es un proceso integral que incluye mtodos
especficos de anlisis y diseo, notacin grfica (UML) y lenguajes de programacin orientados a
objetos Las soluciones obtenidas durante la fase de anlisis y diseo no son especficos para
ningn lenguaje de programacin orientado a objetos

7

EL LENGUAJE JAVA
Java, es un lenguaje de programacin desarrollado por Sun
Microsystems (actualmente pertenece a Oracle). Es un lenguaje
orientado a objetos, diseado para la ejecucin en mltiples
plataformas sin requerir la recompilacin del cdigo fuente para
cada plataforma. Aunque Java puede ser compilado como un
programa nativo, se le puede atribuir una buena parte de su
popularidad a su portabilidad y a otras caractersticas como la
recoleccin de basura.
1. Basado en C++ pero simplificado, mucho ms fcil de usar,
de ms alto nivel y menos propenso a errores
2. Amplsima biblioteca estndar de clases predefinidas
3. Las aplicaciones Java pueden ser ejecutadas indistintamente
en cualquier plataforma sin necesidad de recompilacin
4. Amplio espectro: programacin tradicional, distribuida, GUI, Web, dispositivos mviles, etc.
5. Gestin avanzada de memoria mediante el uso de un recolector de basura
6. Gestin avanzada de errores, tanto en tiempo de compilacin como de ejecucin
7. Soporte sencillo de mltiples hebras de ejecucin
8. Pueden integrarse mdulos escritos en C/C++
9. Lenguaje abierto. Kits de desarrollo y documentacin gratuitos en la red
10. Las imgenes vectoriales se pueden escalar. Los grficos vectoriales son independientes de
la resolucin, pues no estn definidos por un nmero fijo de pixeles y, por lo tanto, se
escalan automticamente para que aparezcan ntidos en cualquier dispositivo de salida y en
cualquier resolucin.

Existen distintas ediciones de Java para el desarrollo de aplicaciones en distintos mbitos:
1. Aplicaciones de propsito general (J2SE)
2. Aplicaciones de gestin en entornos empresariales (J2EE)
3. Aplicaciones para telfonos mviles, PDAs y otros dispositivos electrnicos que permitan
aplicaciones empotradas (J2ME)
4. La ms utilizada es sin duda la edicin estndar (J2SE).

8


Existen dos kits diferentes que pueden ser descargados de la pgina oficial de Sun:
1. El Java Development Kit (JDK) permite desarrollar y ejecutar aplicaciones Java
2. El Java Runtime Environment (JRE) permite nicamente la ejecucin

J2SE incluye bibliotecas muy extensas y completas, que permiten la implementacin de casi
cualquier tipo de aplicacin:
1. Seguridad
2. EEDDs
3. Componentes (JavaBeans)
4. Internacionalizacin
5. E/S
6. XML
7. Redes y acceso a Internet
8. Programacin distribuida (RMI, CORBA)
9. Matemtica de precisin arbitraria
10. Sonido
11. Interfaz de usuario (AWT, SWING)
12. Grficos 2D
13. Manipulacin, carga y descarga de
14. imgenes
15. Impresin
16. Acceso a bases de datos (JDBC)
17. Gestin de preferencias y
18. Configuraciones

JG Tecnol ogas
COMPILACIN, BYTECODE
1. Java sigue un esquema no tradicional de compilacin/ejecucin:
2. La compilacin genera un ejecutable en bytecode o cdigo intermedio independiente
3. Para su ejecucin se requiere un JRE especfico de la
una mquina virtual java (JVM) y las libreras de clases.
4. La JVM interpreta el bytecode o realiza su compilacin justintime
ms eficiente

En resumen, EL bytecode Java
Java compila el cdigo Java a una representacin intermedia denominada "bytecode Java" el cual
se ejecuta en un JRE (Java Runtime Environment, Entorno de Ejecucin Java) y no directamente en
el Sistema Operativo.

OMPILACIN, BYTECODE Y JVMS
Java sigue un esquema no tradicional de compilacin/ejecucin:
La compilacin genera un ejecutable en bytecode o cdigo intermedio independiente
Para su ejecucin se requiere un JRE especfico de la plataforma. El JRE est
una mquina virtual java (JVM) y las libreras de clases.
La JVM interpreta el bytecode o realiza su compilacin justintime para que su

bytecode Java, hace posible la independencia de plataforma, el compilador de
9

jgtecnol ogias. com
La compilacin genera un ejecutable en bytecode o cdigo intermedio independiente
plataforma. El JRE est formado por
para que su ejecucin sea

endencia de plataforma, el compilador de

1
0

Ventajas de este sistema:
1. Se compila la aplicacin una nica vez y los ejecutables en bytecode obtenidos son vlidos
para cualquier plataforma.
2. El cdigo fuente queda a salvo
3. Es muy robusto. La mquina virtual Java es capaz de detectar y notificar gran cantidad de
errores durante la ejecucin de la aplicacin (como accesos a elementos fuera de un vector)
4. El recolector de basura no ocupa espacio en el ejecutable, ya que viene integrado en la JVM
5. Los ejecutables son pequeos porque las libreras de clases vienen proporcionadas junto a
la JVM en el JRE de la plataforma concreta

Inconvenientes:
1. Velocidad. Evidentemente la interpretacin o incluso compilacin justintime del bytecode
produce aplicaciones ms lentas que en el caso de la ejecucin directa de un binario. El
recolector de basura puede suponer una sobrecarga adicional al procesador
2. La generalidad tiene como inconveniente que no se aprovecha totalmente la potencia de la
mquina y del sistema operativo. Por ejemplo, el aspecto de una aplicacin Java puede
resultar simple y poco atractivo en comparacin con las aplicaciones nativas
ENTORNOS DE DESARROLLO JAVA
JDK. El kit de desarrollo bsico proporcionado por Sun. Es lo mnimo que se necesita para
desarrollar. til si se necesita compilar aplicaciones Java de manera espordica o en general para
programadores con espiritu espartano. Puede bajarse gratuitamente para cualquier plataforma de
java.sun.com

netBeans. El IDE Java ms popular, realizado ntegramente en Java (y por tanto multiplataforma).
Consume bastantes recursos. Tiene una arquitectura extensible con mdulos especficos para
desarrollo web, aplicaciones mviles, diseo UML, etc. Puede obtenerse gratuitamente de
www.netbeans.org

Eclipse. Junto a netBeans, el entorno de desarrollo Java gratuito ms utilizado. Tambin permite el
desarrollo en C++ y otros lenguajes de programacin. Puede descargarse en www.eclipse.org

Borland JBuilder. Excelente entorno integrado de desarrollo Java de Borland. Existen versiones
limitadas que pueden bajarse de www.borland.com

Microsoft Visual J++. Uno de los ms populares, aunque las aplicaciones obtenidas pueden
presentar problemas de compatibilidad con el SDK oficial de Java, por el uso de libreras especificas

1
1

de Microsoft. Permite construir aplicaciones Java dentro de la plataforma .NET. La versin express
puede obtenerse gratuitamente.
JAVA VS OTROS LENGUAJES OO
Java C# C++ Eiffel Smaltalk
Aparicin 1995 2000 1985 1985 1970
Sintaxis ins. C++ ins. Java ins. C ins. Pascal original
Difusin Amplia Amplia Amplia Limitada Limitada
Librera de clases Muy Amplia Muy Amplia Escasa Amplia Amplia
Recolector basura Si Si No Si Si
Manejo objetos Dinmico Dinmico Est./Din. Est./Din Dinmico
Tipo ejecutable Bytecode IL code binario binario Byte codes
Ejecucin mediante JVM mediante CLR directa directa Mediante SVM
Velocidad Ejecutable media media muy alta alta baja
Soporte excepciones Si Si Si Si Si
Herencia mltiple No No Si Si No
Soporte operadores Muy Limitado Limitado Si Si No
Soporte plantillas No No Si Si No

1
2

Ejemplos bsicos

Ejemplo: convertidor de unidades

import java.io.*;
import java.util.Scanner;
public class Medidas{
public static void main( String args[] ){
Scanner leer = new Scanner(System.in);
int KM,CM,Y, op;
double RES;
System.out.println( "Ingrese la operacion" );
System.out.println( "1.- Centimetos a pulgadas" );
System.out.println( "2.- Yardas a metros" );
System.out.println( "3.- Kilometros a millas" );
System.out.println( "\n" );
op = leer.nextInt();
switch(op){
case 1:
System.out.println(Centimetros a pulgadas" );
System.out.println("Ingrese los centimetros" );
CM = leer.nextInt(); RES = CM * 2.3;
System.out.println("El resultado es: "+RES+" pulgadas" );
break;

case 2:
System.out.println( "Yardas a Metros" );
System.out.println( "Ingrese el numero de Yardas" );
Y = leer.nextInt(); RES = Y * 0.914401829;
System.out.println( "El resultado es: "+RES+" metros" );
break;

case 3:
System.out.println( "Kilometros a Millas" );
System.out.println( "Ingrese el numero de Kilometros" );
KM = leer.nextInt(); RES = KM * 0.621;
System.out.println( "El resultado es: "+RES+" millas" );
break;
}
}
}

1
3


UNIDAD II
POO EN JAVA

OBJETIVO:
El objetivo de esta unidad es introducir al participante
en los conceptos tericos y prcticos de la
programacin orientada a objetos, esto incluye: la
implementacin de clases, objetos, proteccin de
clases, su inicializacin y finalizacin, como se
sobrecargan las operaciones, los constructores, y
como realizar escrituras y lecturas a disco utilizando
para ello las clases propias de Java.

Al concluir, esta unidad el participante deber estar en
la capacidad de definir propiedades y mtodos con sus
diferente tipos de proteccin, instanciar clase, trabajar
con objetos, persistir a disco los objetos con
serializacin, sobrecargar operaciones y leer entradas
de datos utilizando diferentes clases de Java.
PUNTOS A TRATAR:
1. Clases de Objetos
2. Instanciacin de la clase
3. Mtodos o atributos estticos
4. Proteccin de miembros de la clase
5. Clases amigas
6. Proteccin de Clases
7. Inicializacin y finalizacin
8. Sobrecarga de Operaciones
9. Creacin de objetos
10. Trabajando con objetos
11. Autoreferencias (this)
12. Aplicaciones orientadas a objetos
13. Entrada y salida
POO EN JAVA
1

1
4

CLASES DE OBJETOS

Las clases de objetos representan conceptos o entidades significativos en un problema
determinado. Una clase describe las caractersticas comunes de un conjunto de objetos, mediante
dos elementos:
1. Atributos (o variables miembro, variables de clase). Describen el estado interno de cada
objeto
2. Operaciones (o mtodos, funciones miembro). Describen lo que se puede hacer con el
objeto, los servicios que proporciona

Cuenta Nombre de la clase
nmero: String
titular: String
Atributos saldo: Float
interesAnual: Float
ingreso(cantidad: Float)
reintegro(cantidad: Float)
Operaciones ingresoInteresMes()
enRojos(): Boolean
leerSaldo(): Real

1
5

INSTANCIACIN DE LA CLASE

Durante la ejecucin de la aplicacin se producir la instanciacin de la clase, es decir, la
creacin de los objetos que representan cada uno de los individuos con sus caractersticas
propias, es decir, valores especficos para sus atributos

c : Cuenta
numero=123890023
titular=Miguel Prez
saldo=1800.4
intersAnual=0.25

Cuenta
nmero: String
titular: String
saldo: Float
interesAnual: Float
ingreso(cantidad: Float)
reintegro(cantidad: Float)
ingresoInteresMes()
enRojos(): Boolean
leerSaldo(): Real

e : Cuenta
numero=151590020
titular=Javier
Snchez
saldo=1200.2
intersAnual=1.25

Clase de Objetos d : Cuenta
numero=23900839
titular=Antonio
Gmez
saldo=200
intersAnual=0.25
Objetos

La implementacin de esta clase en Java se realizara en un fichero con nombre cuenta.java, y su
contenido sera el siguiente:

Atributos

Operaciones
class Cuenta {
long numero;
String titular;
float saldo;
float interesAnual;

void ingreso(float cantidad){}
void reintegro(float cantidad){}
void ingresoInteresMes(){}
boolean enRojos(){}
float leerSaldo(){}
}

1
6

Los atributos pueden ser de cualquiera de los tipos bsicos de Java: boolean, char, byte, short,
int, long, float y double, referencias a otros objetos o arrays de elementos de alguno de los
tipos citados

Al contrario que C++, Java realiza la definicin e implementacin de la clase en el mismo lugar, en
un nico fichero .java

Ejemplo: implementacin del archivo Cuenta.java

class Cuenta {
long numero;
String titular;
float saldo;
float interesAnual;

void ingreso(float cantidad) {saldo += cantidad;}
void reintegro(float cantidad) {saldo =cantidad;}
void ingresoInteresMes(){saldo+=interesAnual * saldo / 1200;}
boolean enRojos() { return saldo < 0; }
float leerSaldo() { return saldo; }
}

JG Tecnol ogas
MTODOS O ATRIBUTOS

El acceso a los atributos de la clase desde la implementaci
operaciones se realiza de forma directa
Los atributos u operaciones estticas (
el proceso de instanciacin de objetos a partir de la clase
De un
que se crea. Exi
todos los objetos de la clase
Una
estticos

En el siguiente ejemplo, se desea llevar el control del nmero de transacciones que realiza el
banco, es importante destacar que cada cuenta puede generar n movimientos.
El atributo nOp mantiene una cuenta global del nmero de operaciones realizadas en las
cuentas del banco, para la realizacin de estadsticas.
La operacin leerNOperaciones() permite leer est
La operacin eurosAPesetas() es una operacin auxiliar de la clase Cuenta para ser usada
cuando sea necesaria una conversin de moneda

Ejemplo: Metodos y Atributos Static

class Cuenta {
long numero;
String titular;
float saldo;
float interesAnual;
//Contador de operaciones
static int nOp = 0;
static int leerNOperaciones() { return nOp; }
//Operacin esttica auxiliar de conversin
static long eurosAPesetas(float euros){return euros * 166.386f;}
void ingreso(float cantidad
void reintegro(float cantidad) { saldo =cantidad; ++nOp; }
}

MTODOS O ATRIBUTOS ESTTICOS
El acceso a los atributos de la clase desde la implementaci
operaciones se realiza de forma directa
Los atributos u operaciones estticas (static) no son afectados por
De un atributo esttico no se genera una copia por cada objeto
que se crea. Existe una nica copia compartida y accesible desde
todos los objetos de la clase
Una operacin esttica nicamente puede acceder a miembros
estticos
mportante destacar que cada cuenta puede generar n movimientos.
mantiene una cuenta global del nmero de operaciones realizadas en las
cuentas del banco, para la realizacin de estadsticas.
La operacin leerNOperaciones() permite leer este contador
cuando sea necesaria una conversin de moneda
: Metodos y Atributos Static
class Cuenta {
long numero;
String titular;
float saldo;
t interesAnual;
//Contador de operaciones
int nOp = 0;
int leerNOperaciones() { return nOp; }
//Operacin esttica auxiliar de conversin
long eurosAPesetas(float euros){return euros * 166.386f;}
void ingreso(float cantidad) { saldo += cantidad; ++nOp; }
1
7

jgtecnol ogias. com
El acceso a los atributos de la clase desde la implementacin de las
) no son afectados por
no se genera una copia por cada objeto
ste una nica copia compartida y accesible desde
nicamente puede acceder a miembros
mportante destacar que cada cuenta puede generar n movimientos.
mantiene una cuenta global del nmero de operaciones realizadas en las
long eurosAPesetas(float euros){return euros * 166.386f;}
) { saldo += cantidad; ++nOp; }

JG Tecnol ogas
PROTECCIN DE MIEMBR
El principio de ocultacin de informacin se plasma
mecanismos de proteccin de los miemb
niveles de proteccin diferentes a cada miembro de la clase:
Miembros pblicos (+) Sin ningn tipo de proteccin especial
Miembros privados (-) Inaccesibles desde el exterior de la clase
Miembros protegidos (#)
acceso desde las clases descendientes

En Java un miembro se etiqueta como pblico colocando el identificador
public delante de su declaracin
Para los miembros privados utilizaremos el identificador

Cuenta
numero: Long
titular: String
saldo: Float
intersAnual: Real
+ingreso(cantidad: Integer)
+reintegro(cantidad: Integer)
+ingresoInteresMes()
+enRojos(): Boolean
+leerSaldo(): Integer

PROTECCIN DE MIEMBROS DE LA CLASE
El principio de ocultacin de informacin se plasma en los lenguajes OO en diversos
proteccin de los miembros de la clase. UML permite asociar tres
diferentes a cada miembro de la clase:
Sin ningn tipo de proteccin especial
Inaccesibles desde el exterior de la clase
Miembros protegidos (#) Similares a los privados aunque se permite su
desde las clases descendientes (sub clases derivadas de una clase padre)
Clase
+atributoPublico: Tipo
-atributoPrivado: Tipo
#atributoProtegido: Tipo
operacionPrivada()
+operacionPublica()
#operacionProtegida()
delante de su declaracin
Para los miembros privados utilizaremos el identificador
1
8

jgtecnol ogias. com
en los lenguajes OO en diversos
UML permite asociar tres
ilares a los privados aunque se permite su
(sub clases derivadas de una clase padre)
Para los miembros privados utilizaremos el identificador private

1
9


Ejemplo: Proteccin de miembros de la clase Cuenta

class Cuenta {
private long numero;
private String titular;
private float saldo;
private float interesAnual;
public void ingreso(float cantidad) {saldo += cantidad;}
public void reintegro(float cantidad) {saldo =cantidad;}
public void ingresoInteresMes(){saldo+=interesAnual*saldo/ 1200;}
public boolean enRojos() { return saldo < 0; }
public float leerSaldo() { return saldo; }
}

CLASES AMIGAS
En Java se consideran amigas todas aquellas que forman parte del mismo paquete
Un fichero fuente java forma en s un paquete y por tanto todas las clases incluidas en l son
amigas
Las clases incluidas en varios archivos fuente pueden agruparse en un nico paquete
indicando el nombre de paquete al principio de cada archivo mediante el indicador package
Los miembros no etiquetados son accesibles por parte de clases amigas. En C++ y otros
lenguajes OO las clases amigas a una dada pueden indicarse explcitamente

archivo A.java archivo C.java archivo D.java
package prueba;
class A {
...
}
class B {
...
}
package prueba;
class C {
...
}
class D {
....
}

class E {
....
}
Las clases A, B y C son
amigas al pertenecer al
mismo paquete prueba

Las clases D y E son amigas
al pertenecer al mismo
fichero fuente

JG Tecnol ogas
En el siguiente ejemplo, las clases
fuente. El acceso a los atributos de los objetos de la clase Cuenta almacenados en el vector interno
de Banco queda as garantizado. El atributo saldo puede mantenerse como privado puesto que
existe una operacin que permite obtener su valor:

Ejemplo: clases amigas. Implementacin del archivo Cuenta.java

class Cuenta {
long numero;
String titular;
float interesAnual;
public void reintegro(float cantidad) {saldo =ca
public void ingresoInteresMes(
}

class Banco {
Cuenta[] c; // vector de cuentas
...
}

Atencin: todas las clas
paquete de forma explcita, pertenecen a un paquete por defecto y por tanto son
amigas.

Un paquete crea un espacio de nombres propios. Esto significa que la clase pasa a tener
como prefijo el propio nombre del paquete. A la hora de utilizarla tenemos tres opciones:
1. Utilizar su nombre completo:
2. Importar esa clase, para poder utilizarla sin el prefijo. Esto se indica al principio del
cdigo fuente mediante
3. Importar directamente t
import prueba.*
Un paquete puede estar situado dentro de otro paquete
jerrquicas. Ejemplo: miapp.prueba.A
En el siguiente ejemplo, las clases Cuenta y Banco son amigas al pertenecer al mismo archivo
. El acceso a los atributos de los objetos de la clase Cuenta almacenados en el vector interno
existe una operacin que permite obtener su valor:
lases amigas. Implementacin del archivo Cuenta.java
{
long numero;
String titular;
float interesAnual;
public void reintegro(float cantidad) {saldo =ca
public void ingresoInteresMes( {saldo+=interesAnual*saldo/

Cuenta[] c; // vector de cuentas
: todas las clases que no se declaren como pertenecientes a ningn
ombre del paquete. A la hora de utilizarla tenemos tres opciones:
Utilizar su nombre completo: prueba.A
Importar esa clase, para poder utilizarla sin el prefijo. Esto se indica al principio del
cdigo fuente mediante import prueba.A
Importar directamente todas las clases del paquete, que se usaran sin prefijo:
Un paquete puede estar situado dentro de otro paquete
miapp.prueba.A
2
0

jgtecnol ogias. com
Cuenta y Banco son amigas al pertenecer al mismo archivo
. El acceso a los atributos de los objetos de la clase Cuenta almacenados en el vector interno
lases amigas. Implementacin del archivo Cuenta.java
saldo+=interesAnual*saldo/1200;}
es que no se declaren como pertenecientes a ningn
ombre del paquete. A la hora de utilizarla tenemos tres opciones:
Importar esa clase, para poder utilizarla sin el prefijo. Esto se indica al principio del
odas las clases del paquete, que se usaran sin prefijo:
formando estructuras

2
1

Java obliga a que exista una correspondencia entre la estructura de paquetes de una clase y
la estructura de directorios donde est situada
La raiz de la estructura de directorios debe estar incluida en el classpath de Java (parmetro
cp <dir>)

Las clases:
miapp.prueba.A,
miapp.prueba.B y
miapp.C
Deben estar en la siguiente estructura de directorios:

Paquete prueba est
dentro del paquete miapp
miapp.prueba.A
Archivo A.java

Archivo B.java

Archivo C.java

JG Tecnol ogas
PROTECCIN DE CLASES
Por proteccin de clases entendemos un
a nivel de clases. Es decir, se trata de especificar que clases pueden ser utilizadas y cules
no, y por quin
Dentro de un paquete, las clases son amigas
a la utilizacin de una clase por las otras
Sin embargo, desde el punto de vista del exterior, nicamente podrn ser utilizadas las
clases pblicas del paquete
de su declaracin

Atencin: Java slo permite una clase pblica por fichero fuente, y el nombre de la
clase y el fichero deben coincidir obligatoriamente
que la clase Cuenta pueda ser utilizada desde el
deberemos declararla como pblica

Ejemplo: Proteccin de clases

public class Cuenta {
public void ingresoInteresMes(){saldo+
public boolean enRojos() { return saldo <
}

PROTECCIN DE CLASES
Por proteccin de clases entendemos un nivel superior de la ocultacin de informacin,
. Es decir, se trata de especificar que clases pueden ser utilizadas y cules
Dentro de un paquete, las clases son amigas y por tanto no existen restricciones respecto
a la utilizacin de una clase por las otras
desde el punto de vista del exterior, nicamente podrn ser utilizadas las
aquete, es decir, aquellas con el identificador public situado delante
: Java slo permite una clase pblica por fichero fuente, y el nombre de la
clase y el fichero deben coincidir obligatoriamente. En nuestro ejemplo, si que
que la clase Cuenta pueda ser utilizada desde el exterior del fichero Cuenta.java
deberemos declararla como pblica.
: Proteccin de clases
Cuenta {
public void ingresoInteresMes(){saldo+=interesAnual*saldo/1200;}
2
2

jgtecnol ogias. com
nivel superior de la ocultacin de informacin,
. Es decir, se trata de especificar que clases pueden ser utilizadas y cules
y por tanto no existen restricciones respecto
desde el punto de vista del exterior, nicamente podrn ser utilizadas las
, es decir, aquellas con el identificador public situado delante
: Java slo permite una clase pblica por fichero fuente, y el nombre de la
En nuestro ejemplo, si queremos
exterior del fichero Cuenta.java
interesAnual*saldo/1200;}

2
3

INICIALIZACIN Y FINALIZACIN
La iniciacin de los atributos de la clase se realiza en Java, al igual que en C++, mediante el uso de
constructores cuyo nombre coincide con el de la clase, en el siguiente ejemplo podemos notar que
hay un mtodo llamado igual al nombre de la clase, en este caso cuenta,

Ejemplo: Inicializacin y Finalizacin


//Constructor de la clase
Cuenta(long aNumero, String aTitular, float aInteresAnual){
numero = aNumero;
titular = aTitular;
saldo = 0;
interesAnual = aInteresAnual;
}
public void ingreso(float cantidad){saldo += cantidad;}
// Resto de operaciones de la clase Cuenta a partir de aqu

2
4

SOBRECARGA DE OPERACIONES
Java permite la sobrecarga de operaciones, por tanto se pueden definir varios constructores posible
para una clase siempre que se diferencien en la lista de argumentos


// Importar todas las clases del paquete java.io
import java.io.*;
//Constructor general
Cuenta(long aNumero, String aTitular, float aInteresAnual){
numero = aNumero;
titular = aTitular;
saldo = 0;
}
// Constructor para obtener los datos de la cuenta de un archivo
Cuenta(long aNumero) throws FileNotFoundException, IOException,
ClassNotFoundException {
FileInputStream fis = new FileInputStream(aNumero + .cnt);
ObjectInputStream ois = new ObjectInputStream(fis);
numero = aNumero;
titular = (String) ois.readObject();
saldo = ois.readFloat();
interesAnual = ois.readFloat();
ois.close();
}
public void ingresoInteresMes(){saldo+=interesAnual*saldo/1200;}
}

2
5

Si no se proporciona ningn
constructor, Java proporciona
automticamente un constructor
por defecto, que no recibe
argumentos y realiza una
inicializacin por defecto de los
atributos
Una vez implementado un
constructor propio por parte del
programador, Java elimina dicho
constructor, aunque puede ser
definido nuevamente de manera
explcita

class Cuenta {
numero = 00000000;
titular = ninguno;
saldo = 0;
interesAnual = 0;
}

Naturalmente los constructores pueden ser marcados como pblicos, privados, protegidos o
con acceso a nivel de paquete, lo que especificar quien puede crear objetos de esta clase y de
qu manera


// Constructor general
public Cuenta(long aNumero,String aTitular,float aInteresAnual){
numero = aNumero;
titular = aTitular;
saldo = 0;
}
// Constructor para obtener los datos de la cuenta de un fichero
public Cuenta(long aNumero) throws FileNotFoundException,
IOException, ClassNotFoundException {
FileInputStream fis = new FileInputStream(aNumero + .cnt);
ObjectInputStream ois = new ObjectInputStream(fis);
numero = aNumero;
titular = (String)ois.readObject();
ois.close();
}

2
6

Cuando finaliza el uso de un objeto, es frecuente la realizacin de ciertas tareas antes de su
destruccin, principalmente la liberacin de la memoria solicitada durante su ejecucin. Esto
se realiza en C++ y otros lenguajes OO en los denominados destructores.
Estos destructores son operaciones invocadas automticamente justo antes de la
destruccin del objeto.
Sin embargo, en Java la liberacin de memoria se realiza de manera automtica por parte
del recolector de basura, por tanto la necesidad de este tipo de operaciones no existe en la
mayor parte de los casos.
Sin embargo s puede ser necesario realizar alguna tarea no relacionada con la liberacin de
memoria antes de la destruccin del objeto, como por ejemplo salvar el estado de la clase en
un fichero o base de datos
Java permite introducir cdigo para este fin implementando una operacin pblica especial
denominada finalize. Esta operacin es invocada automticamente antes de la destruccin
del objeto por parte del recolector de basura

Siguiendo nuestro ejemplo, vamos asegurarnos de que el estado de una cuenta queda salvado en
disco antes de su destruccin, para poder ser recuperada posteriormente. Para ello introducimos el
cdigo de escritura en fichero en la operacin finalize de la clase Cuenta

Ejemplo: uso de finalize

public void finalize() : throws FileNotFoundException, IOException
{
FileOutputStream fos = new FileOutputStream(numero + .cnt);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(titular);
oos.writeFloat(saldo);
oos.writeFloat(interesAnual);
oos.close();
}

Problema: no es posible saber con seguridad en qu momento ser invocada finalize, puesto que
el recolector de basura puede decidir su eliminacin en un momento indeterminado, e incluso no ser
eliminado hasta el final de la ejecucin de la aplicacin.

2
7

Una posible solucin es ordenar al recolector de basura que realice una limpieza de memoria
inmediata, para asegurar la finalizacin de los objetos. Esto se realiza mediante
Runtime.getRuntime().gc()
Por motivos de eficiencia, lo anterior es poco recomendable, sobre todo si se hace con
frecuencia
Una mejor opcin es definir una operacin ordinaria con este mismo propsito, a llamar de
manera explcita cuando haya finalizado el uso del objeto Introduciremos en la clase Cuenta
una operacin pblica salvar en lugar de finalize, con la misma implementacin. Tras
finalizar las operaciones sobre la cuenta, invocaremos a salvar para guardar los cambios
realizados.
CREACIN DE OBJETOS
1. En Java los objetos se crean nicamente de forma dinmica. Para ello se utiliza el operador
new, de manera similar a C++
2. Los objetos en Java se utilizan siempre a travs de referencias. Las referencias son
similares a los punteros de C/C++, aunque su uso es mucho ms sencillo
3. Por tanto los pasos a seguir en la creacin de un objeto son:
a. Declarar una referencia a la clase
b. Crear un objeto mediante el operador new invocando al constructor adecuado
c. Conectar el objeto con la referencia

La creacin de un objeto de la clase Cuenta se realizara de la siguiente forma:
Cuenta c; // Una referencia a un objeto de la clase Cuenta
c = new Cuenta(18400200, Pedro Jimnez, 0.1f);

En cambio, los tipos bsicos (int, long, float, etc.) s pueden ser creados directamente en la pila.
Esto es posible porque Java no los implementa realmente como clases de objetos, por motivos de
eficiencia y comodidad, ya que su uso es muy frecuente
Cuenta c;
float in;
long num;
in = 0.1f;
num = 18400200;
c = new Cuenta(num, Pedro Garcia, in);

Las cadenas de caracteres se implementan con una clase (String). Sin embargo no suele ser
necesaria su creacin de manera explcita, ya que Java lo hace de manera automtica al asignar
una cadena constante*

2
8


String s; // Una referencia a un objeto de la clase String
// Conexin de la referencia s con un objeto String
// creado dinmicamente e inicializado con la constante Pedro
s = Pedro;
// Sera equivalente a:
// char[] cc = {'P', 'e', 'd', 'r', 'o'}
// s = new String(cc);

Los arrays tambin deben ser creados dinmicamente con new como si fueran objetos

int[] v; // Una referencia a un vector de enteros
v = new int[10] // Creacin de un vector de 10 enteros

Si el array es de referencias a objetos, habr que crear adems cada uno de los objetos
referenciados por separado
La destruccin de los objetos se realiza de manera automtica cuando el recolector de basura
detecta que el objeto no est siendo usado, es decir, no est conectado a ninguna referencia

Cuenta[] v; // Un vector de referencias a objetos de la clase Cuenta
int c;
v = new Cuenta[10] // Crear espacio para 10 referencias a cuentas
for (c = 0; c < 10; c++)
v[c] = new Cuenta(18400200 + c, Cliente n. + c, 0.1f);

Cuenta c1 = new Cuenta(18400200, Cliente 1, 0.1f);
Cuenta c2 = new Cuenta(18400201, Cliente 2, 0.1f);
c1 = c2
// El objeto asociado a la cuenta 18400200 ha quedado desconectado y ser
// eliminado por el recolector de basura

2
9

TRABAJANDO CON OBJETOS
Trabajar con un objeto Java es similar a C++, aunque las referencias permiten un uso mucho ms
sencillo.

Cuenta c1 = new Cuenta(18400200, Pedro Jimnez, 0.1f);
Cuenta c2 = new Cuenta(18400201);
c2.reintegro(1000);
c1.ingreso(500);
if (c2.enRojos())
System.out.println(Atencin: cuenta 18400201 en nmeros rojos);
System.out.println(Saldo actual de la cuenta 18400201: +
c1.leerSaldo());
c1 = new Cuenta(18400202);
// El objeto asociado a la Cuenta 18400200 queda desconectado
c1.ingreso(500);
System.out.println(Saldo actual de la cuenta 18400202: +
c1.leerSaldo());

3
0


Ejemplo: se pide un nmero de cuenta al usuario y una cantidad a retirar. A
continuacin se carga la cuenta solicitada y se realiza el reintegro.

BufferedReader br = new
BufferedReader(InputStreamReader(System.in));
long nc;
float mi;
try{
System.out.println(Introduzca nm. de de cuenta: );
nc = Long.parseLong(br.readLine());
System.out.println(Introduzca importe a retirar: );
mi = Float.parseFloat(br.readLine());
}
catch(Exception e) {
System.out.println(Error al leer datos);
return;
}
Cuenta c;
try {
c = new Cuenta(nc);
}
catch(Exception e) {
System.out.println(Imposible recuperar cuenta);
return;
}
if (c.leerSaldo() < mi)
System.out.println(Saldo insuficiente);
else
c.reintegro(mi);
c.salvar();

3
1

Naturalmente el compilador producir un error ante cualquier acceso ilegal a un miembro de la clase
Cuenta c = new Cuenta(18400200, Pedro Jimnez, 0.1f);
c.saldo = 1000;
Cuenta.java:XX: saldo has private access
c.saldo = 1000;
^
1 error

El acceso a un miembro esttico se realiza utilizando el nombre de la clase en lugar de un objeto

Cuenta c = new Cuenta(18400200, Cliente 1, 0.1f);
c.ingreso(1000);
int pts = Cuenta.eurosAPesetas(c.leerSaldo());
System.out.println(Saldo: + c.leerSaldo() + ( + pts + pesetas);
AUTOREFERENCIAS (THIS)
En ocasiones es necesario obtener una referencia en la implementacin de una operacin al
propio objeto sobre el que ha sido invocada la operacin.
Esta referencia se obtiene en C++ y Java mediante el operador this
Cuando encontremos this en una expresin, podremos sustituirlo mentalmente por este
objeto
Aunque no es necesario, podemos utilizar this para llamar desde la implementacin de una
operacin a otra operacin del mismo objeto

La llamada a la operacin ingreso desde ingresoInteresMes() puede realizarse utilizando this
como referencia del objeto sobre el que se invoca la operacin

private Cliente titular;
private float saldo, interesAnual;
public void ingresoInteresMes() {
this.ingreso(interesAnual * saldo / 1200);
}
// Resto de las operaciones de la clase Cuenta

3
2

En este ejemplo, el uso de this es realmente til. Nos permite implementar la operacin
transferirDesde() llamando a una operacin transferirHasta(), previamente implementada
public void transferirHasta(Cuenta c, float cant) {
reintegro(cant);
c.ingreso(cant);
}
public void transferirDesde(Cuenta c, float cant) {
c.transferirHasta(this, cant);
}
// Resto de las operaciones de la clase Cuenta

Otra utilidad de this en Java es realizar una llamada a un constructor desde otro constructor
public Cuenta(long aNumero, Cliente aTitular, float aInteresAnual) {
numero = aNumero; titular = aTitular; saldo = 0;
movimientos = new LinkedList();
}
// Constructor especfico para cuentas de ahorro (interesAnual = 0.1%)
public Cuenta(long aNumero, Cliente aTitular) {
this(aNumero, aTitular, 0.1);
}
// Resto de la clase Cuenta

Pero atencin: un constructor no es una operacin ordinaria. nicamente puede llamarse a un
constructor desde otro constructor y debe ser la primera instruccin dentro de la implementacin.

3
3

APLICACIONES ORIENTADAS A OBJETOS
En una aplicacin orientada a objetos debe existir una clase que represente la propia
aplicacin. Este sera el punto donde comenzara la ejecucin de la misma.

En lenguajes no totalmente orientados como C++ en la funcin main se crea una instancia de esta
clase y se llama a alguna operacin como ejecutar para arrancar la aplicacin. Sin embargo esto no
es obligatorio, y un mal programador puede realizar una aplicacin hbrida, con cdigo no orientado
a objetos.

En un lenguaje orientado a objetos puro como Java esta clase de aplicacin es obligatoria.

La mquina virtual Java se encarga de instanciar esta clase y llamar a una operacin especial
con nombre main. La existencia de esta operacin especial es lo que caracteriza a la clase de
aplicacin
1. La clase de aplicacin debe ser pblica y no tener ningn constructor o un constructor por
defecto
2. Al menos debe implementar la operacin main, con la siguiente declaracin: public static
main(String[] args)

public class BancoApp {
public static void main(String[] args) {
Cuenta c1 = new Cuenta(18400200, Pedro Jimnez, 0.1f);
c1.ingreso(1000);
System.out.println(Ingreso realizado);
}
}

A la hora de ejecutar la aplicacin, deber indicarse esta clase a la mquina virtual Java
1. Tras compilar los archivos de la ltima versin de nuestro ejemplo:
Cliente.java, Cuenta.java y BancoApp.java
Obtendremos los ficheros en byte code:
Cliente.class, Cuenta.class, Movimiento.class y BancoApp.class
2. Finalmente, pasando la clase BancoApp.class a la mquina virtual java pondremos en
funcionamiento la aplicacin

3
4

Nota: Las clases que constituyen una aplicacin Java tambin pueden distribuirse de manera
mucho ms compacta en un nico fichero JAR.

3
5

ENTRADA Y SALIDA
Entrada/ Salida. La librera de clases de Java dispone de gran cantidad de clases para la gestin
transparente de E/S. Estas clases pueden combinarse para crear flujos de datos especializados

E/S Binaria (streams):
a) Las clases FileInputStream y FileOutputStream permite abrir streams de E/S secuencial a
ficheros en disco. La clase RandomAccessFile permite leer y escribir informacin a un
fichero de forma aleatoria
b) Las clases BufferedInputStream y BufferedOutputStream permite leer y escribir
informacin de un input/output stream, utilizando un buffer intermedio para acelerar las
operaciones
c) Las clases DataInputStream y DataOutputStream permite leer y escribir tipos simples en
un input/output stream

Ejemplo: Lectura y escritura bsicas en un fichero:

import java.io.*;
public class ESBinaria {
DataOutputStream ds =
new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(datos)));
ds.writeInt(2);
ds.writeFloat(4.5);
ds.writeChars(Hola);
ds.close();
ds = new DataInputStream(
new BufferedInputStream(
new FileInputStream(datos)));
int k = ds.readInt();
System.out.println(k);
ds.close();
}
}

3
6

E/S de caracteres (readers)
a) Las clases FileReader y FileWriter permite abrir readers/writers de acceso secuencial a
ficheros en disco
b) Las clases BufferedReader y BufferedWriter permite leer y escribir informacin utilizando
un buffer intermedio para acelerar las operaciones. Posibilitan el leer/escribir lneas
completas
c) Las clases InputStreamReader y OutputStreamWriter permiten convertir un stream en un
reader/writer
d) La clase especializada PrintWriter permite escribir directamente cualquier tipo de dato en un
writer. Su uso es ms cmodo que el de un BufferedWriter
e) La clase especializada Scanner permite leer de manera sencilla cualquier tipo simple de un
fichero de texto. Su uso es ms cmodo que mediante BufferedReader

Ejemplo: Escritura de un fichero mediante BufferedWriter y PrintWriter:

import java.io.*;
public class ESTexto {
try {
BufferedWriter bw =
new BufferedWriter(New FileWriter(datos.txt));
bw.write(Hola);
bw.writeLine();
bw.write(new Integer(3).toString());
bw.writeLine();
bw.write(new Float(10.3).toString());
bw.close();
PrintWriter pw = new PrintWriter(datos.txt);
pw.println(Hola);
pw.println(3);
pw.println(10.3);
pw.close();
}
catch(IOException e) {
System.out.println(Error de E/S);
}
}
}

3
7

Hay dos mtodos de lectura:
a) El primero usa la operacin parse() de las clases wrapper de los tipos bsicos
b) El segundo, ms flexible y sencillo, utiliza la clase Scanner

Ejemplo: Leyendo con la clase BufferedReader y la clase scanner

import java.io.*;
public class ESTexto {
try {
BufferedReader br = new BufferedReader(
new FileReader(datos.txt));
String s = br.readLine();
int k = Integer.parseInt(br.readLine());
float p = Float.parseFloat(br.readLine());
br.close();
Scanner sc = new Scanner(new File(datos.txt));
s = sc.nextLine();
k = sc.nextInt();
p = sc.nextFloat();
sc.close();
}
System.out.println(Error de E/S);
}
}
}

3
8

Serializacin.
Una de las caractersticas ms potentes de Java es la posibilidad de serializar un objeto, es decir,
convertirlo en una secuencia de bytes y enviarlo a un fichero en disco, por un socket a otro
ordenador a travs de la red, etc. El proceso sera el siguiente:
a) Declarar la implementacin de la interfaz Serializable en la clase que deseemos
serializar. Se trata de una interfaz vaca, por lo que no hay operaciones que implementar
b) Para serializar el objeto crearamos un stream ObjectOutputStream y escribiramos el
objeto mediante la operacin writeObject()
c) Para deserializar el objeto crearamos un stream ObjectInputStream, leeramos el objeto
mediante readObject() y realizaramos un casting a la clase del objeto

Vamos a modificar ahora el constructor de la clase Cuenta y la operacin salvar() para que sean
capaces de cargar y salvar el histrico de movimientos. La capacidad de serializacin de Java
permite salvar la lista enlazada de un solo golpe.

import java.io.*;
import java.util.*;
// Es necesario que tanto las clases Cliente como Movimiento implementen la
interfaz
// Serializable para que los objetos puedan ser escritos en disco
class Movimiento implements Serializable {
Date fecha;
char tipo;
float importe;
float saldo;
public Movimiento
(Date aFecha, char aTipo, float aImporte, float aSaldo) {
fecha = aFecha;
tipo = aTipo;
importe = aImporte;
saldo = aSaldo;
}
}
//continua abajo

3
9

long numero;
Cliente titular;
float interesAnual;
LinkedList movimientos;

numero = aNumero;
titular = aTitular;
saldo = 0;
}

Cuenta(long aNumero) throws FileNotFoundException,
IOException, ClassNotFoundException {
ObjectInputStream ois =
new ObjectInputStream(new FileInputStream(aNumero + ".cnt"));
numero = ois.readLong();
titular = (Cliente) ois.readObject();
movimientos = (LinkedList) ois.readObject();
ois.close();
}
void salvar() throws FileNotFoundException, IOException {
ObjectOutputStream oos =
new ObjectOutputStream(new FileOutputStream(numero + ".cnt"));
oos.writeLong(numero);
oos.writeObject(titular);
oos.writeFloat(saldo);
oos.writeFloat(interesAnual);
oos.writeObject(movimientos);
oos.close();
}

4
0

UNIDAD III

OBJETIVO:
saberes relacionados con los distintos tipos de
relaciones que pueden surgir entre varios objetos, tales
como dependencia, asociacin, agregacin,
composicin y de las clases anidadas e interiores.

Al concluir, esta unidad el participante deber estar en
la capacidad de realizar implementaciones entre clases
a travs de sus relaciones, como por ejemplo,
relacionar una clase cuenta bancaria con sus clientes y
movimientos.

PUNTOS A TRATAR:
1. Relacin entre objetos
2. La dependencia entre objetos
3. La asociacin entre objetos
4. La agregacin entre objetos
5. La composicin entre objetos
6. Clases anidadas e interiores
RELACIN ENTRE OBJETOS JAVA
3

4
1

Un conjunto de objetos aislados tiene escasa capacidad para resolver un problema. En una
aplicacin real los objetos colaboran e intercambian informacin, existiendo distintos tipos de
relaciones entre ellos
A nivel de diseo, podemos distinguir entre 5 tipos de relaciones bsicas entre clases de
objetos:
dependencia, asociacin, agregacin, composicin y herencia
LA DEPENDENCIA ENTRE OBJETOS
La dependencia es la relacin menos importante. Simplemente refleja que la implementacin
de una clase depende de otra
Una dependencia puede indicar la utilizacin de un objeto de una clase como argumento de
una operacin de otra o en su implementacin.

La Dependencia corresponde a relacin "usa-un": Esta relacin generalmente se refleja en el uso de
instancias de otras clases para cumplir los servicios o responsabilidades de una clase. Eje.: Un
amplificador usa un parlante para emitir el sonido. Un Computador usa la red para enviar sus datos.
Es decir si en nuestro diseo el Computador es el responsable de enviar los datos, entonces ste
deber acceder a una instancia de Red para enviar los datos.

Como vimos anteriormente, la clase Cuenta requiere las clases FileOutputStream y
ObjectOutputStream de la librera de clases de Java para la implementacin de la operacin salvar

Cuenta
numero: Long
titular: String
saldo: Float
intersAnual: Real
+enRojos(): Boolean

java.io.FileOutputStream
java.io.ObjectOutputStrea

4
2

LA ASOCIACIN ENTRE OBJETOS
En cambio, la asociacin es la relacin ms importante y comn. Refleja una relacin entre dos
clases independientes que se mantiene durante la vida de los objetos de dichas clases o al menos
durante un tiempo prolongado

En UML suele indicarse el nombre de la relacin, el sentido de dicha relacin y las cardinalidades
en los dos extremos

Vamos a sustituir el atributo titular por una asociacin con una nueva clase Cliente completa

Cuenta
- numero: Long
- titular: String
- saldo: Float
- intersAnual: Real
+enRojos(): Boolean
Cliente
- nombres: String
- apellidos: String
- direccion: String
- localidad: String
- fnacimiento: Date
+nombreCompleto(): String
+direccionCompleta(): String

Una asociacin se implementa en Java introduciendo referencias a objetos una clase como
atributos en la otra
Si la relacin tiene una cardinalidad superior a uno entonces ser necesario utilizar un array
de referencias. Tambin es posible utilizar una estructura de datos dinmica del paquete
java.util como Vector o LinkedList para almacenar las referencias
Normalmente la conexin entre los objetos se realiza recibiendo la referencia de uno de ellos
en el constructor o una operacin ordinaria del otro

* 1
titular

4
3

public class Cliente {
private String nombre, apellidos;
private String direccion, localidad;
private Date fNacimiento;
Cliente(String aNombre, String aApellidos, String aDireccion,
String aLocalidad, Date aFNacimiento) {
nombre = aNombre;
apellidos = aApellidos;
direccion = aDireccion;
localidad = aLocalidad;
fNacimiento = aFNacimiento;
}
String nombreCompleto() { return nombre + + apellidos; }
String direccionCompleta() { return direccion + , + localidad; }
}

numero = aNumero;
titular = aTitular;
saldo = 0;
}
Cliente leerTitular() { return titular; }

Asociacin con la clase Cliente

4
4

LA AGREGACIN ENTRE OBJETOS
La agregacin es un tipo especial de asociacin donde se aade el matiz semntico de que la clase
de donde parte la relacin representa el todo y las clases relacionadas las partes

Realmente Java y la mayora de lenguajes orientados a objetos no disponen de una implementacin
especial para este tipo de relaciones. Bsicamente se tratan como las asociaciones ordinarias

Polgono

Segmento

Departamento

Despacho

LA COMPOSICIN ENTRE OBJETOS
La composicin es un tipo de agregacin que aade el matiz de que la clase todo controla la
existencia de las clases parte. Es decir, normalmente la clase todo crear al principio las clases
parte y al final se encargar de su destruccin

Supongamos que aadimos un registro de movimientos a la clase Cuenta, de forma que quede
constancia tras cada ingreso o reintegro

Cuenta
- numero: Long
- titular: String
- saldo: Float
- intersAnual: Real
+enRojos(): Boolean
Cliente
- nombres: String
- apellidos: String
- direccion: String
- localidad: String
- fnacimiento: Date
+nombreCompleto(): String
+direccionCompleta(): String

Movimiento
fecha: Date
tipo: Char
importe: Real
saldo: Real
- fnacimiento: Date

2 *
1 *
formado por
dispone de
* 1
titular
registra
*

4
5

Las composiciones tienen una implementacin similar a las asociaciones, con la diferencia de que
el objeto principal realizar en algn momento la construccin de los objetos compuestos

import java.util.Date
class Movimiento {
Date fecha;
char tipo;
float importe;
float saldo;
public Movimiento(Date aFecha,char aTipo,float aImporte,float aSaldo){
fecha = aFecha;
tipo = aTipo;
importe = aImporte;
saldo = aSaldo;
}
}

private LinkedList movimientos; // Lista de movimientos
interesAnual = aInteresAnual; movimientos = new LinkedList();
}
// Nueva implementacin de ingreso y reintegro
public void ingreso(float cantidad) {
movimientos.add(new Movimiento(new Date(), 'I', cantidad, saldo +=
cantidad));
}
public void reintegro(float cantidad) {
movimientos.add(new Movimiento(new Date(), 'R', cantidad, saldo =
cantidad));
}
public void ingresoInteresMes() { ingreso(interesAnual * saldo / 1200); }

Nota: tambin sera necesario modificar el otro constructor y la operacin salvar para tener en
cuenta la lista de movimientos a la hora de leer/escribir la informacin de la Cuenta en disco

4
6

CLASES ANIDADAS E INTERIORES
Java y algunos otros lenguajes OOP permiten la definicin de una clase de objetos dentro
de otra, con una doble utilidad:
1. Organizar mejor el cdigo. Empaquetar en una clase principal otras que no tienen
utilidad o sentido fuera del contexto de sta
2. Evitar colisiones de nombres. La clase principal define un espacio de nombres al que
pertenecen las anidadas
Al igual que cualquier otro miembro de una clase, una clase anidada puede ser esttica o no
esttica y utilizar los niveles de proteccin public, private y protected
El tipo de clase anidamiento ms sencillo es aquel en que la clase contenida se declara
como esttica

Desde el punto de vista de la organizacin del cdigo, tendra mucho ms sentido introducir la
clase Movimiento en el interior de Cuenta. Al ser declarada como privada, se impedira su utilizacin
desde el exterior

static private class Movimiento {
Date fecha;
char tipo;
float importe;
float saldo;
public Movimiento(Date aFecha, char aTipo, float aImporte,
float aSaldo){
fecha = aFecha; tipo = aTipo; importe = aImporte; saldo = aSaldo;
}
}
}

introduciendio la clase
movimiento en el interior
de la clase cuenta

4
7

Cuando la clase anidada no es esttica, se denomina clase interior y tiene caractersticas
especiales:
1. Pueden ser creadas nicamente dentro de la clase continente
2. Tiene acceso completo y directo a todos los atributos y operaciones del objeto que realiza su
creacin

Los objetos de la clase interior quedan ligados permanentemente al objeto concreto de la clase
continente que realiz su creacin.

No debe confundirse este elemento con la relacin de composicin, aunque en muchos casos es
posible utilizar clases interiores para la implementacin de este tipo de relaciones.

Implementando la clase Movimiento como una clase interior es posible copiar el valor del saldo
actual de la cuenta que realiza el movimiento de manera directa.


private class Movimiento {
Date fecha; char tipo; float importe, saldoMov;
public Movimiento(Date aFecha, char aTipo, float aImporte) {
fecha = aFecha; tipo = aTipo; importe = aImporte;
saldoMov = saldo; // Copamos el saldo actual
}
}
// Sigue la implementacin de la clase Cuenta

4
8

UNIDAD IV
HERENCIA

Objetivo:
saberes relacionados con el mecanismo de herencia
entre clases.

Al concluir esta unidad el participante deber estar en
la capacidad de implementar herencia simple y mltiple
entre clases, como por ejemplo: una clase cuenta
corriente, una cuenta plazo fijo que heredan de una
superclase genrica denominada cuenta, aparte de
poder redefinir, anular, y adicionar la herencia, aparte
de trabajar con clases abstractas, polimorfismo y
ligadura dinmica.

Puntos a tratar:
1. La herencia
2. Mtodo Super()
3. Adicionar la herencia
4. Redefinir la herencia
5. Anular la herencia
6. Proteccin y herencia
7. Clases abstractas
8. Herencia mltiple
9. Polimorfismo
10. Ligadura dinmica
HERENCIA
4

4
9

LA HERENCIA
La herencia es un mecanismo de la OOP que permite construir una clase incorporando de manera
implcita todas las caractersticas de una clase previamente existente. Las razones que justifican su
necesidad son variadas:
1. Modelado de la realidad. Son frecuentes las relaciones de especializacin/generalizacin
entre las entidades del mundo real, por tanto es lgico que dispongamos de un mecanismo
similar entre las clases de objetos.
2. Evitar redundancias. Toda la funcionalidad que aporta una clase de objetos es adoptada
de manera inmediata por la clase que hereda, por tanto evitamos la repeticin de cdigo
entre clases semejantes.
3. Facilitar la reutilizacin. Una clase no tiene por qu limitarse a recibir una serie de
caractersticas de otra clase por herencia de forma pasiva. Tambin disponen de cierto
margen de adaptacin de estas caractersticas
4. Soporte al polimorfismo

Sea una clase A. Si una segunda clase B hereda de A entonces decimos:
A es un ascendiente o superclase de B. Si la herencia entre A y B es directa decimos
adems que A es la clase padre de B
B es un descendiente o subclase de A. Si la herencia entre A y B es directa decimos adems
que B es una clase hija de A
A

B

C

D

En Java, Eiffel, Smalltalk y otros lenguajes orientados a objetos puros, todas las clases heredan
automticamente de una superclase universal. En Java esta superclase se denomina Object

5
0

Existen diferentes situaciones en las que puede aplicarse herencia:
1. Especializacin. Dado un concepto B y otro concepto A que representa una especializacin
de A, entonces puede establecerse una relacin de herencia entre las clases de objetos que
representan a A y B. En estas situaciones, el enunciado A es un B suele ser aplicable

vehiculo

empleado

figura

coche

contable

cuadrado

2. Extensin. Una clase puede servir para extender la funcionalidad de una superclase sin que
represente necesariamente un concepto ms especfico

lista

cuenta

lista salvable

recuperar()
salvar()

CuentaConhistorico
movimiento
fecha: date
tipo: Char
importe: Real
saldo: Real

3. Especificacin. Una superclase puede servir para especificar la funcionalidad mnima
comn de un conjunto de descendientes. Existen mecanismos para obligar a la
implementacin de una serie de operaciones en estos descendientes

ObjetoGrafico
seleccionar()
mover()
escalar()
cambiarColor()

texto

linea

cuadrado

registra
*

5
1

Construccin. Una clase puede construirse a partir de otra, simplemente porque la hija puede
aprovechar internamente parte o toda la funcionalidad del padre, aunque representen entidades sin
conexin alguna
lista

pila

Ejemplos de herencia:
Distintos tipos de cuentas bancarias:

cuenta
numero: Long
titular: String
saldo: Float
interes: Float
ingreso()
ingresoInteresMes()
leerSaldo()
transferirHasta()

CuentaCorriente

reintegro()

CuentaAhorroPFijo
vencimiento: Date
ingresoMes()

PlanPensiones
vencimiento:Date
cotizacion: Float
numCuentaOrigen: String

5
2

Vamos a estudiar la implementacin de la herencia en Java mediante el ejemplo de un conjunto
de tareas programables:
TPReloj (actualizar un reloj digital cada segundo),
TPAviso (mostrar un aviso peridicamente) y
TPEjecucion (ejecucin de un comando cada cierto tiempo)

tareaPeriodica
periodoSegs: Integer
ultimaej: Date
activa: Boolean
+necesitaEjecucion(): Boolean
+actualizarReloj()
+ejecutarTarea()
+activar()
+desactivar()

TPReloj

+leerHora(): String

TPAviso
msg: String
+leerMsg(): String

TPEjecucion
cmd: String
+leerCmd(): String

5
3

La clase TareaPeriodica tiene las caractersticas comunes a los tres tipos de tarea:
1. Periodo de ejecucin en segundos,
2. Hora de la ltima ejecucin y
3. Bandera de estado activo/inactivo
import java.util.*;
public class TareaPeriodica {
int periodoSegs; // Periodo de ejecucin
Date ultimaEj; // Hora de ltima ejecucin
boolean activa;

public TareaPeriodica(int aPeriodoSegs) {
periodoSegs = aPeriodoSegs;
actualizarReloj();
activa = true;
}

// Constructor para ejecuciones cada segundo
public TareaPeriodica() { this(1); }

// Establecer la ltima ejecucin a la hora actual
public void actualizarReloj() { ultimaEj = new Date(); // Hora actual }

public boolean necesitaEjecucion() {
if (!activa)
return false;
// Calcular la hora de la prxima ejecucin
Calendar calProximaEj = new GregorianCalendar();
calProximaEj.setTime(ultimaEj);
calProximaEj.add(Calendar.SECOND, periodoSegs);
Calendar calAhora = new GregorianCalendar();
// Comprobar si ha pasado a la hora actual
return (calProximaEj.before(calAhora));
}
public void ejecutarTarea() {System.out.println("Ejecucion de tarea");}
public void activar() { activa = true; }
public void desactivar() { activa = false; }
}
Nota: La operacin ejecutarTarea realmente no tiene una implementacin concreta a este nivel

5
4

Para que una clase herede de otra, utilizaremos el indicador extends en la declaracin de la
clase
import java.util.Calendar;
import java.util.GregorianCalendar;
public class TPReloj extends TareaPeriodica {
public TPReloj() {
periodoSegs = 60; // Comprobar cada minuto
actualizarReloj();
activa = true;
}

public String leerHora() {
Calendar cal = new GregorianCalendar();
return cal.get(Calendar.HOUR_OF_DAY) + ":" + cal.get(Calendar.MINUTE);
}
}

Atencin: Aunque el cdigo de estas clases compila perfectamente, la implementacin de los
constructores es formalmente incorrecta. Ms adelante veremos por qu.
public class TPAviso extends TareaPeriodica {
String msg;
public TPAviso(String aMsg, int aPeriodoSegs) {
actualizarReloj();
activa = true;
msg = aMsg;
}
public String leerMsg() { return msg; }
}

import java.lang.Runtime;
import java.io.IOException;
public class TPEjecucion extends TareaPeriodica {
String cmd;
public TPEjecucion(String aCmd, int aPeriodoSegs) {
actualizarReloj();
activa = true;
cmd = aCmd;
}
String leerCmd() { return cmd; }
}

5
5

Todas las clases en Java heredan en ltima instancia de Object. Incluso si creamos una clase
independiente, Java la hace heredar implcitamente de Object

Esto hace que las clases formen una jerarqua con Object como raz

En la implementacin de una operacin de la subclase no existe diferencia aparente entre un
atributo u operacin propia de la clase y un atributo u operacin heredados

Ahora podemos crear y usar objetos de cualquiera de las clases anteriores. Desde el exterior
tampoco existen diferencias aparentes entre la llamada a una operacin heredada o propia de la
clase:

public class AppGestorTareas {
TareaPeriodica tp = new TareaPeriodica(5);
TPAviso tpa = new TPAviso(Estudiar Programacin Avanzada !, 60);
while (!tp.necesitaEjecucion())
System.println(Esperando ejecucin de tarea peridica...);
tp.ejecutarTarea();
while (!tpa.necesitaEjecucion()){
System.println(Esperando ejecucin de aviso...);
System.println(Aviso: + tpa.leerMsg());
}
}
Object
#clone(): Object
+equals(Object obj): Boolean
#finalize()
+getClass(): Class
+hasCode(): int
+notify()
+notifyAll()
+toString(): String
+wait()
+wait(timeout: Long)
+wait(timeout: Long, nanos: Integer)

5
6

MTODO SUPER()
La inicializacin de los atributos de una superclase en el constructor de una subclase
presenta varios inconvenientes serios:
Resulta redundante. La superclase tiene ya un constructor que hace ese trabajo.
Por qu repetir cdigo entonces?
Si la clase tiene una larga lista de ascendientes, entonces el constructor sera muy largo
La superclase puede tener una inicializacin compleja, y la inclusin del cdigo de
inicializacin en la subclase puede requerir un conocimiento excesivo de la superclase por
parte del implementador

String msg;
actualizarReloj();
activa = true;
msg = aMsg;
}
}

El procedimiento correcto consiste en realizar una llamada al constructor de la superclase para que
realice la inicializacin de los atributos heredados

En Java esta llamada al constructor de la superclase se realiza con la operacion super() seguida
de los parmetros de inicializacin de alguno de los constructores del padre de la clase

La implementacin correcta del constructor de la clase TPAviso sera por tanto la siguiente:
String msg;
super(aPeriodoSegs);
msg = aMsg;
}
}

5
7

Y de las otras dos subclases:

public TPReloj() {
super(60);
}
return cal.get(Calendar.HOUR_OF_DAY) + ":"
+ cal.get(Calendar.MINUTE);
}
}

String cmd;
cmd = aCmd;
}
}

nicamente debe llamarse explcitamente a un constructor del ascendiente inmediato

El constructor de este ltimo realizar a su vez una llamada a un constructor de su ascendiente
inmediato y as sucesivamente hasta inicializar todos los atributos heredados

5
8

ANULAR LA HERENCIA
Es posible impedir la herencia a partir de una clase declarndola como final

Sin embargo, esta es una caracterstica que debe ser utilizada con prudencia, ya que puede
restringir en exceso la extensin y reutilizacin de las clases del sistema en el futuro.

final public class TPEjecucion extends TareaPeriodica {
String cmd;
cmd = aCmd;
}
}

ADICIN, REDEFINICIN Y ANULACIN DE LA HERENCIA
La herencia en s no sera tan interesante si no fuera por la posibilidad de adaptar en el
descendiente los miembros heredados
1. Adicin. Trivialmente el descendiente puede aadir nuevos atributos y operaciones que se
suman a los recibidos a travs de la herencia
2. Redefinicin. Es posible redefinir la implementacin de una operacin heredada para
adaptarla a las caractersticas de la clase descendiente. Tambin es posible cambiar el tipo
de un atributo heredado
3. Anulacin. Cuando un atributo u operacin heredados no tienen utilidad en el descendiente,
pueden ser anulados para impedir su utilizacin.

No todos los lenguajes orientados a objetos soportan estas caractersticas, en especial la anulacin

5
9

LA REDIFINICIN
La redefinicin se realiza en Java y la mayora de los lenguajes OO definiendo nuevamente la
operacin (con los mismos argumentos) en el descendiente.

Las clases descendientes TPReloj, TPEjecucion y TPAviso no estn operativas todava porque la
implementacin de ejecutarTarea() que contienen es la heredada de TareaPeriodica, que no hace
nada en particular.

Es preciso redefinir esta operacin en cada una de las subclases para que realicen las tareas
correspondientes.

tareaPeriodica
ultimaej: Date
activa: Boolean
+actualizarReloj()
+ejecutarTarea()
+activar()
+desactivar()

TPReloj

+leerHora(): String
+ejecutarTarea()

TPAviso
msg: String
+leerMsg(): String
+ejecutarTarea()

TPEjecucion
cmd: String
+leerCmd(): String
+ejecutarTarea()

6
0

public TPReloj() {
super(60);
}
Return
cal.get(Calendar.HOUR_OF_DAY) + ":" + cal.get(Calendar.MINUTE);
}
public void ejecutarTarea() {
int min = cal.get(Calendar.MINUTE);
if (min == 0 || min == 30)
System.out.println("Hora: " +
cal.get(Calendar.HOUR_OF_DAY)+ " " + min);
}
}

String cmd;
cmd = aCmd;
}
try {
Runtime.getRuntime().exec(cmd);
}
System.out.println("Imposible ejecutar comando: "
+ cmd);
}
}
}

6
1

String msg;
msg = aMsg;
}
System.out.println("ATENCIN AVISO: " + msg);
desactivar();
}
}

Cada tarea ejecuta ahora su funcin, aunque la llamada es aparentemente la misma
TPAviso tpa = new TPAviso(Estudiar programacin !, 60);
TPEjecucion tpe = new TPEjecucion(rm ~/tmp/*, 3600);
System.println
(Esperando ejecucin de tarea peridica...);
tp.ejecutarTarea();
while (!tpa.necesitaEjecucion())
System.println(Esperando ejecucin de aviso...);
tpa.ejecutarTarea();
while (!tpr.necesitaEjecucion())
System.println
(Esperando ejecucin de comando...);
tpe.ejecutarTarea();
}
}

Despus de la redefinicin, en el descendiente es posible llamar a la versin original de la operacin
en el ascendiente mediante: super.operacionRedefinida()

6
2

Otro uso posible de la palabra clave final es impedir la redefinicin de una operacin en las
subclases.
import java.util.*;
int periodoSegs;
Date ultimaEj;
boolean activa;

actualizarReloj();
activa = true;
}


final public void actualizarReloj() {
ultimaEj = new Date(); // Hora actual
}

final public boolean necesitaEjecucion() {
// Implementacin de la operacin
}

System.out.println("Ejecucion de tarea");
}

final public void activar() { activa = true; }

final public void desactivar() { activa = false; }
}

6
3

LA ANULACIN
La anulacin es un mecanismo menos til, y con menor soporte por parte de los lenguajes de
programacin

En Java es posible impedir el acceso a un atributo re declarndolo en una subclase como privado o
protegido, segn sea el nivel de proteccin que se desee.

String msg;
// Impedir el acceso desde el exterior y las subclases
// al atributo activa
private boolean activa;
msg = aMsg;
}
// Resto de la implementacin de la clase a partir de aqu
}

Sin embargo, Java no permite redefinir una operacin haciendo su nivel de acceso ms restrictivo
Una solucin parcial consistira en redefinirla como vaca o incluyendo un cdigo que impida su
utilizacin
String msg;
msg = aMsg;
}
public void activar() {}
public void desactivar() {
System.out.printl(Error: llamada a operacin privada);
System.getRuntime().exit(1);
}
System.out.println("ATENCIN AVISO: " + msg);
desactivar();
}
}

6
4

PROTECCIN Y HERENCIA
Hemos visto anteriormente como los distintos niveles de proteccin limitan el acceso a los miembros
de la clase desde el exterior. Pero cmo afectan estos niveles de proteccin a los miembros
heredados?
Tipo de proteccin Descripcin

Miembros pblicos
Son accesibles desde los descendientes, y se heredan
como pblicos

Miembros privados
No son accesibles desde los descendientes

Miembros con acceso a
nivel de paquete
Son accesibles desde los descendientes siempre y
cuando pertenezcan al mismo paquete que el
ascendiente. Se heredan con el mismo nivel de
proteccin

Miembros protegidos
(protected).
Un miembro protegido es accesible nicamente desde
los descendientes. Adems, un miembro protegido
mantiene en las subclases el nivel de acceso protegido

En nuestro ejemplo, los atributos de la clase TareaPeriodica son accesibles desde TPReloj,
TPEjecucion y TPAviso porque al pertenecer al mismo paquete son amigas
Para permitir el acceso a los atributos de la clase TareaPeriodica nicamente desde los
descendientes es conveniente marcarlos como protegidos

import java.util.*;
protected int periodoSegs;
protected Date ultimaEj;
boolean activa;
actualizarReloj();
activa = true;
}
// Resto de operaciones de la clase a partir de aqu

6
5

CLASES ABSTRACTAS
Existen clases que representan conceptos tan genricos que no tiene sentido su instanciacin en
objetos, adems en este tipo de clases puede ser imposible o intil la implementacin de ciertas
operaciones. La utilidad de este tipo de clases est en la aplicacin de herencia para obtener clases
que representan conceptos concretos para los que s que tiene sentido su instanciacin

La clase TareaPeriodica es un claro ejemplo: por s sola no tiene utilidad, pero simplifica mucho la
construccin de las otras tres clases. De hecho, la operacin ejecutarTarea() en TareaPeriodica no
tiene una implementacin til

Estas clases se denominan clases abstractas y este tipo de operaciones sin implementacin
posible, operaciones abstractas

Las operaciones abstractas deben ser implementadas obligatoriamente en alguna de las subclases
para que la clase correspondiente sea instanciable

Una clase abstracta puede no tener ninguna operacin abstracta, pero una clase que contenga al
menos una operacin abstracta debe ser declarada como abstracta

En Java, utilizando la declaracin abstract podremos establecer una clase o una operacin como
abstracta.

6
6

Vamos a declarar la clase TareaPeriodica y su operacin ejecutarTarea() como abstractas
import java.util.*;
abstract class TareaPeriodica {
int periodoSegs;
Date ultimaEj;
boolean activa;
actualizarReloj();
activa = true;
}
public void actualizarReloj() {
ultimaEj = new Date(); // Hora actual
}
if (!activa)
return false;
// Resto de la implementacin de esta
// operacin aqu
}
abstract public void ejecutarTarea();
public void desactivar() { activa = false; }
}

Java devuelve ahora un error en tiempo de compilacin si se intenta crear un objeto de la clase
TareaPeriodica
System.println(Esperando ejecucin de tarea peridica...);
tp.ejecutarTarea();
}
}
AppGestorTareas.java:XX:
class TareaPeriodica is an abstract class; cannot be instantiated
TareaPeriodica tp = new TareaPeriodica();
^
1 error

6
7

La abstraccin de una clase se propaga por la jerarqua de herencia hasta que todas las
operaciones quedan implementadas.
La idea de clase abstracta, llevada al extremo, nos lleva en Java a las interfaces. Una
interfaz es similar a una clase totalmente abstracta:
Todas las operaciones de la interfaz son implcitamente abstractas, es decir, carecen de
implementacin
Una interfaz no puede contener atributos
Las interfaces sirven para especificar las operaciones que obligatoriamente deben
implementar una serie de clases
La implementacin de una interfaz no se realiza mediante herencia (extends) sino mediante
implements. No obstante, el comportamiento es similar al de la herencia, aunque ms
sencillo

La idea de clase implementa una interfaz, esta implementacin debe ser completa, es decir, de
todas las operaciones de la interfaz.
Podemos transformar TareaPeriodica en una interfaz, de forma que especifique lo que tiene que
implementar cualquier clase que represente una tarea peridica. Este enfoque proporciona mayor
libertad a la hora de disear las otras clases.

<<interfaz>>
TareaPeriodica

+actualizarReloj()
+ejecutarTarea()
+activar()
+desactivar()

TPReloj

+leerHora(): String
+necesitaEjecucion():
Boolean
+actualizarReloj()
+ejecutarTarea()
+activar()
+desactivar()

TPAviso
msg: String
+leerMsg(): String
Boolean
+actualizarReloj()
+ejecutarTarea()
+activar()
+desactivar()

TPEjecucion
cmd: String
+leerCmd(): String
Boolean
+actualizarReloj()
+ejecutarTarea()
+activar()
+desactivar()

Una interfaz no
posee atributos

6
8

La interfaz TareaPeriodica y la clase TPReloj tendran ahora el siguiente aspecto.
Las otras clases tendran implementaciones similares
public interface TareaPeriodica {
boolean necesitaEjecucion();
void ejecutarTarea();
void activar();
void desactivar();
}

public class TPReloj implements TareaPeriodica {
Date ultEjecucion;
boolean activa;
public TPReloj() { activa = true; ultEjecucion = new Date() }
int min = cal.get(Calendar.MINUTE);
System.out.println
("Hora: " + cal.get(Calendar.HOUR_OF_DAY) + " " + min);
ultEjecucion = cal.getTime();
}

if (!activa)return false;
Calendar calProximaEj = new GregorianCalendar();
Calendar calUltEjecucion = new GregorianCalendar();
calUltEjecucion.setTime(ultEjecucion);
Calendar calAhora = new GregorianCalendar();
if (calAhora.equal(calUltEjecucion)) return false;
int min = calAhora.get(Calendar.MINUTE);
if (min == 00 || min == 30) return true;
return false;
}
public void desactivar() { activar = false; }
return cal.get(Calendar.HOUR_OF_DAY) + ":" +
cal.get(Calendar.MINUTE);
}
}

6
9

Una clase puede implementar ms de una interfaz
Una interfaz puede heredar de otra interfaz

Cundo utilizar una interfaz en lugar de una clase abstracta?
a) Por su sencillez se recomienda utilizar interfaces siempre que sea posible
b) Si la clase debe incorporar atributos, o resulta interesante la implementacin de alguna de
sus operaciones, entonces declararla como abstracta

En la biblioteca de clases de Java se hace un uso intensivo de las interfaces para
caracterizar las clases.
Algunos ejemplos:
a) Para que un objeto pueda ser guardado en un archivo la clase debe implementar la
interfaz Serializable
b) Para que un objeto sea duplicable, su clase debe implementar Cloneable
c) Para que un objeto sea ordenable, su clase debe implementar Comparable

7
0

HERENCIA MLTIPLE
Consiste en la posibilidad de que una clase tenga varios ascendientes directos
Puede surgir de manera relativamente frecuente y natural durante el diseo

Tiene claramente aspectos positivos
a) Surge de manera natural al describir la estructura de un sistema
b) Proporciona mucha flexibilidad a la hora de construir clases nuevas
Pero tambin aspectos negativos
a) Complica el diseo. La jerarqua de clases deja de ser tal jerarqua para pasar a ser una red
b) Provoca problemas de eficiencia. La llamada a una operacin heredada implica la bsqueda
por mltiples caminos
c) Ambigedad: dos atributos u operaciones con el mismo nombre pueden llegar a una clase
por dos caminos distintos
d) Herencia repetida: en una estructura con forma de rombo, un atributo u operacin puede
llegar a una clase por dos caminos distintos

7
1


La apuesta de los creadores de Java es clara: no permitir la herencia mltiple, por las
razones expuestas anteriormente
A veces es posible sustituir la herencia mltiple por una combinacin herencia/composicin,
aunque el resultado no puede considerarse equivalente

Adems, Java s que permite la implementacin de una o varias interfaces adems de la
herencia, lo que puede considerarse una forma restringida de herencia mltiple
Una clase puede heredar de otra e implementar una o varias interfaces sin que aparezcan
los problemas asociados con la herencia mltiple

7
2


POLIMORFISMO
Son dos mecanismos relacionados que otorgan a la OOP una gran potencia frente a otros
paradigmas de programacin. nicamente tienen sentido por la existencia de la herencia

El polimorfismo (o upcasting) consiste en la posibilidad de que una referencia a objetos de una
clase pueda conectarse tambin con objetos de descendientes de sta

A

A ra = new A(); //Asignacin ordinaria
B rb = ra; //Asignacin polimorfa rb: B objeto: A

B

A rb = new A(); //Asignacin polimorfa ra. A

TPReloj tpr = new TPReloj();
TPAviso tpa = new TPAviso(Ha pasado un minuto, 60);
TPEjecucion tpe = new TPEjecucion(/bin/sync, 120);
TareaPeriodica tp;

tp = tpr;
tp.desactivar();

tp = tpa;
tp.desactivar();

tp = tpe;
tp.desactivar();
}
}

7
3

El sentido del polimorfismo es realizar una generalizacin, olvidar los detalles concretos de uno o
varios objetos de distintas clases y buscar un punto comn a todos ellos en un ancestro.

La mayora de las veces, las conexiones polimorfas se realizan de manera implcita en el paso de
argumentos a una operacin. De esta manera es posible escribir operaciones polimorfas que
reciban objetos de mltiples clases.

private static void esperarEjecutar(TareaPeriodica tp){
while (!tp.necesitaEjecucion());
tp.ejecutarTarea();
}
esperarEjecutar(tpr);
esperarEjecutar(tpa);
esperarEjecutar(tpe);
}
}

7
4

Otra aplicacin muy til es la construccin de estructuras de datos que puedan mantener objetos de
distintas clases.
Vamos a implementar una nueva clase GestorTareas que va a contener una lista de tareas a
realizar. La llamada a chequearEjecutar() realizar la comprobacin y ejecucin de las tareas que lo
requieran

import java.lang.Exception;
class DemasiadasTareas extends Exception {}
public class GestorTareas {
TareaPeriodica[] tareas;
int nTareas, maxTareas;
public GestorTareas(int aMaxTareas){
nTareas = 0;
maxTareas = aMaxTareas;
tareas1 = new TareaPeriodica[maxTareas];
}

public void nuevaTarea(TareaPeriodica tp)throws DemasiadasTareas {
if (nTareas == maxTareas) throw new DemasiadasTareas();
tareas[nTareas++] = tp;
}
public void chequearEjecutar(){
for (int t = 0; t < nTareas; t++)
if (tareas[t].necesitaEjecucion())
tareas[t].ejecutarTarea();
}
}
import java.lang.System;
GestorTareas gt = new GestorTareas(10);
try {
gt.nuevaTarea(new TPReloj());
gt.nuevaTarea(new TPAviso(Ha pasado un minuto, 60));
gt.nuevaTarea(new TPEjecucion(/bin/sync, 120));
} catch(DemasiadasTareas e) {
System.out.println
(Mmmm.... esto no deberia haber pasado);
}
gt.chequearEjecutar();
}
}

7
5


Pero siempre debe quedar claro que tras la conexin polimorfa nicamente podemos acceder a las
operaciones pertenecientes a la clase asociada a la referencia.
El resto de operaciones del objeto no son accesibles a travs de esta referencia.

TareaPeriodica tp;
tp = tpr;
tp.desactivar(); // Ok
tp.leerHora() // Error !!
tpr.leerHora(); // Ok
}
}
AppGestorTareas.java:XX: cannot resolve symbol
symbol : method leerHora()
location: class TareaPeriodica
tp.leerHora();
^
1 error

En Java, una referencia a Object puede ser conectada a cualquier objeto, puesto que como
sabemos es un ancestro de todas las clases
Object o;
o = tpr;
System.out.println(o.getClass().getName());
}
}

Adems, las interfaces implementadas por una clase tambin pueden ser utilizadas para realizar
conexiones polimorfas

7
6

LIGADURA DINMICA
Entendemos por resolucin de una llamada el proceso por el cual se sustituye una llamada a una
funcin por un salto a la direccin que contiene el cdigo de esta funcin.
Normalmente, la resolucin de llamadas se realiza en tiempo de compilacin, porque resulta ms
sencillo y sobre todo ms eficiente. Cuando la aplicacin se est ejecutando, las llamadas ya estn
preparadas. Este enfoque se denomina ligadura esttica

f() CALL _f
El problema aparece en OOP cuando realizamos una conexin polimorfa y llamamos a una
operacin redefinida

El compilador no tiene informacin para resolver la llamada. Por defecto utilizara el tipo de la
referencia, y por tanto generara una llamada a A.f()
Pero la referencia r puede apuntar a objetos de las clases A, B o C, con distintas versiones de f()
La solucin consiste en esperar a resolver la llamada al tiempo de ejecucin, cuando se conoce
realmente los objetos conectados a r, y cul es la versin de f() apropiada. Este enfoque de
resolucin de llamadas se denomina ligadura dinmica y es mucho ms lenta y compleja que la
esttica
Hay tres enfoques posibles a la hora de escoger entre ligadura esttica o dinmica:
Establecer la ligadura esttica por defecto. El programador puede activar la ligadura dinmica
para una funcin concreta cuando lo ve necesario (C++)
Utilizar un compilador inteligente que decide la ligadura esttica o dinmica en funcin del empleo
que se hace de cada funcin (Eiffel)
Establecer la ligadura dinmica para todas las funciones y evitar problemas a costa de eficiencia
en la ejecucin (Smalltalk, Java)
Por tanto, la ligadura dinmica, por defecto en Java, garantiza siempre la llamada a la versin
correcta de cada funcin, con independencia del uso de conexiones polimorfas o no

7
7

Por tanto en Java las llamadas a la funcin ejecutarTarea() se resuelven correctamente, a pesar
de realizarse a travs de una referencia a TareaPeriodica

TareaPeriodica tp;
tp = tpr;
tp.ejecutarTarea(); // Versin de TPReloj
tp = tpa;
tp.ejecutarTarea(); // Versin de TPAviso
tp = tpe;
tp.ejecutarTarea(); // Versin de TPEjecucion
}
}

7
8

INFORMACIN DE LAS CLASES EN TIEMPO DE EJECUCIN
Tras realizar una conexin polimorfa es frecuente la necesidad de volver a recuperar el objeto
original, para acceder a sus operaciones propias
Se trata de la operacin inversa al polimorfismo (upcasting), denominada downcasting
Si el polimorfismo implica una generalizacin, el downcasting implica una especializacin
Al contrario que el upcasting, el downcasting no puede realizarse directamente mediante una
conexin con una referencia de la clase del objeto

Tras crear un objeto de tipo TPReloj y conectarlo mediante una referencia a TareaPeriodica,
intentamos recuperar nuevamente una referencia de tipo TPReloj al objeto. No es posible de
manera directa

TareaPeriodica tp = new TPReloj(); // upcasting
TPReloj tr = tp; // downcasting ?
}
}

AppGestorTareas.java:XX: incompatible types
found : TareaPeriodica
required: TPReloj
TPReloj tr = tp;
^
1 error

Un simple casting permite forzar la conexin a la referencia
TPReloj tr = (TPReloj) tp; // downcasting
}
}

7
9

Un intento de casting imposible generar una excepcin ClassCastException en tiempo de
ejecucin
TPReloj tr = (TPReloj) tp; // downcasting ok
// Downcasting imposible: lanza excepcin ClassCastException
TPAviso ta = (TPAviso) tp;
}
}
Exception in Thread main java.lang.ClassCastException
at AppGestorTareas.main(AppGestorTareas.java:XX)

Podemos capturar esta excepcin para determinar si el objeto apuntado por la referencia es del
tipo esperado o no, realizando acciones diferentes en cada caso

import java.lang.*;
TareaPeriodica tp;
TPReloj tr;
// Posiblemente en algn punto la referencia
// tp ha sido conectada
// con un objeto de la clase TPReloj
...
try {
tr = (TPReloj) tp;
System.out.println
(La hora actual es: + tr.leerHora());
}
catch(ClassCastException e) {
System.out.println
(La referencia tp no apunta a un objeto +
de la clase TPReloj);
}
}
}

8
0

import java.lang.*;
TareaPeriodica tp; TPReloj tr; TPAviso ta; TPEjecucion te;
// tp es conectada a algn objeto
...
try {
tr = (TPReloj) tp;
// Operar con tr
return;
}
// Si no es de tipo TPReloj, continuamos por aqu
}
try {
ta = (TPAviso) tp;
// Operar con ta
return;
}
// Si no es de tipo TPAviso, continuamos por aqu
}
try {
te = (TPEjecucion) tp;
// Operar con te
return;
}
// Si tampoco es de tipo TPEjecucin
//Entonces de que tipo es?
System.out.println(Error: objeto de clase desconocida);
}
}
}

8
1

Mucho ms cmodo es utilizar instanceof para determina si el objeto es de la clase esperada
antes de realizar el casting

TareaPeriodica tp; TPReloj tr; TPAviso ta; TPEjecucion te;
...
if (tp instanceof TPReloj) {
tr = (TPReloj) tp; // Operar con tr
}
else if (tp instanceof TPAviso) {
ta = (TPAviso) tp; // Operar con ta
}
else if (tp instanceof TPEjecucion) {
te = (TPEjecucion) tp; // Operar con te
}
else
System.out.println(Error: objeto de clase desconocida);
}
}

La operacin getClass() de Object devuelve un objeto de la clase Class que permite obtener en
tiempo de ejecucin gran cantidad de informacin de la clase a la que pertenece el objeto. El
atributo esttico class de la clase tambin devuelve una referencia a este objeto.

TareaPeriodica tp;
...
Class c = tp.getClass();
System.out.println
(La referencia tp apunta a un objeto de la clase:
+ c.getName());
Class c = TareaPeriodica.class;
if (c.isInterface())
System.out.println(TareaPeriodica es una Interfaz);
}
}

8
2

Las libreras de contenedores de Java (java.util) utilizan el polimorfismo para conseguir
genericidad, trabajando siempre con Object
A la hora de recuperar los objetos almacenados, es necesario utilizar downcasting para conectar
con una referencia de la clase apropiada

import java.util.*;
LinkedList l = new LinkedList;
// Aadir elementos
l.add(new String(Jan));
l.add(Granada);
// Recuperar el primer elemento
String s = (String)l.get(0);
System.out.println(s);
}
}

A partir de la versin 5, Java ha incorporado similar al utilizado por los templates de C++ para
especificar el tipo de los elementos del contenedor
La ventaja es que la referencia devuelta es directamente del tipo especificado en la creacin del
contenedor
import java.util.*;
LinkedList<String> l = new LinkedList<String>;
// Aadir elementos
l.add(new String(Jan));
l.add(Granada);
// Ya no es necesario el downcasting
String s = l.get(0);
System.out.println(s);
}
}

8
3

Otro inconveniente del uso del polimorfismo para la implementacin de los contenedores es que
los tipos simples (int, char, etc.) no pueden almacenarse directamente, al no ser clases de objetos
Para solucionarlo, Java incorpora una clase wrapper para cada tipo simple: (int > Integer, char >
Character, etc.)
import java.util.*;
LinkedList l = new LinkedList;
// Aadir elementos
l.add(new Integer(5));
l.add(new Integer(3));
// Recuperar el primer elemento
int i = ((Integer)l.get(0)).intValue();
System.out.println(i);
}
}

Nuevamente, a partir de la versin 5, este problema se ha eliminado con el autoboxing de tipos
simples.
Es decir, Java transforma un tipo simple en su clase wrapper cuando es necesario de manera
automtica.
Es algo similar a la construccin automtica de String a partir de arrays de caractres que ya
conocemos.
import java.util.*;
LinkedList<Integer> l = new LinkedList<Integer>;
// Aadir elementos. La conversin a Integer es
// automtica
l.add(5);
l.add(3);
// Recuperar el primer elemento. La conversin a
// int es automtica
int i = l.get(0);
System.out.println(i);
}
}

8
4


UNIDAD V
MULTI TAREA

OBJETIVO:
saberes relacionados con la programacin multi tarea,
que no es ms que la ejecucin en paralelo de varias
tareas en el sistema operativo.

la capacidad de desarrollar un programa que define
una tarea que funciona en paralelo con el resto de la
aplicacin, realizando comprobaciones peridicas de la
ejecucin de la misma.
PUNTOS A TRATAR:
1. Multi tarea
2. Hilos
MULTI TAREA
5

8
5

MULTITAREA
Es posible implementar una o varias tareas que se ejecuten en varias hebras de ejecucin en
paralelo, de la siguiente manera:
a) Construir una clase que represente la tarea y herede de la clase Java Thread
b) Redefiniendo la operacin run() de Thread podremos introducir el cdigo que deseamos
ejecutar en la hebra
c) Para arrancar la nueva hebra basta con crear un objeto de la clase y ejecutar la operacin
start()
d) Si se desea parar la hebra durante un tiempo determinado, puede utilizarse la operacin
sleep(int segs)
e) La tarea finaliza cuando se el hilo de ejecucin llega de forma natural al final de la operacin
run()

Ejemplo: un gestor de tareas que funciona en paralelo con el resto de la aplicacin, realizando la
comprobacin peridica de las tareas que requieren ejecucin

import java.lang.Exception;
class DemasiadasTareas extends Exception {}

public class GestorTareas extends Thread {
TareaPeriodica[] tareas;
int nTareas, maxTareas;
boolean terminar;

public GestorTareas(int aMaxTareas) {
super("GestorTareas");
terminar = false;
nTareas = 0;
maxTareas = aMaxTareas;
tareas = new TareaPeriodica[maxTareas];
}

public void nuevaTarea(TareaPeriodica tp) throws DemasiadasTareas {
if (nTareas == maxTareas)
throw new DemasiadasTareas();
tareas[nTareas++] = tp;
}
// Sigue...

8
6

La operacin terminar() va a permitir forzar la finalizacin del gestor de tareas
// Continua la clase GestorTareas
public void run(){
System.out.println("Gestor de tareas en funcionamiento");
while (!terminar) {
for (int t = 0; t < nTareas; t++)
if (tareas[t].necesitaEjecucion())
tareas[t].ejecutarTarea();
//Esperar un segundo antes de volver a comprobar
try {
sleep(1);
}
catch(InterruptedException e) { };
}
System.out.println("Finalizando gestor de tareas");
}

void terminar() { terminar = true; }
}

Esta aplicacin contara con dos hilos de ejecucin en paralelo, uno principal y otro asociado al
gestor de tareas
public AppGestorTareas() {}
GestorTareas gt = new GestorTareas(10);
try {
gt.nuevaTarea(new TPReloj());
gt.nuevaTarea(
new TPAviso("Ha pasado 5 segundos", 5));
} catch(DemasiadasTareas dt) {
System.out.println("esto no debera haber pasado");
}
gt.start();
System.out.println("Hilo de ejecucin principal");
System.out.println("Pulsa una tecla para terminar");
try {System.in.read();}
catch(IOException e) {}
System.out.println("Final de aplicacin");
gt.terminar();
}
}

8
7

UNIDAD VI
ESTRUCTURAS DE DATOS EN JAVA

Objetivo:
saberes relacionados con las diferentes estructuras de
datos soportadas por Java como por ejemplo; arraylist,
hashset, hashmap, treeset, linkendlist.

la capacidad de realizar almacenamiento de
informacin en memoria principal utilizando para ello
estructuras de datos dinmicas nativas del lenguaje de
programacin.

Puntos a tratar:
1. ArrayList
2. HashSet
3. HashMap
4. TreeSet
5. Resumen de Colecciones
ESTRUCTURAS DE DATOS EN JAVA
6

8
8

COLECCIONES EN JAVA
1. Colecciones son objetos que referencian a un grupo de objetos.
2. A diferencia de los arreglos, las colecciones solamente mantienen referencias a objetos de
tipo Object.
3. Cualquier objeto puede ser almacenado en una coleccin.
4. El casting es requerido para acceder a los objetos de la coleccin.

Las colecciones pueden:
1. Cambiar de tamao dinmicamente.
2. Proveer ordenamiento.
3. insertar y borrar elementos.

PAQUETE JAVA.UTIL
Conjunto de clases e interfases usadas para:
1. Administrar colecciones de objetos.
2. Administrar la comunicacin entre objetos.
3. Manipular informacin de los objetos.

Tecnologas de Almacenamiento usadas para almacenar y administrar una Coleccin de
Objetos

Array:
1. Tamao fijo.
2. Acceso rpido y eficiente.
3. Difcil de modificar.

8
9

LikendList

LinkedList
first

Link
data

next

prev

Link
data

next

prev

Link
data

next

prev

Tree:
Guarda elementos en orden.
Fcil de cambiar.

Hashtable:
Usa una clave indexada para identificar elementos. Los elementos son obtenidos de un hashtable
usando la clave del elemento.

TIPOS DE COLECCIONES
Collection
Contenedor simple de objetos no ordenados.
Los duplicados son permitidos.
List
Contenedor de elementos ordenados.
Los duplicados son permitidos.
Set
Coleccin desordenada de objetos.
Los duplicados no son permitidos.
Map
Coleccin de pares: clave/valor.

9
0

La clave es usada para indexar el elemento.
Los duplicados no son permitidos.

INTERFASES ITERATOR Y LISTITERATOR
1. Iterator: Provee un mecanismo bsico para iterar a travs de los elementos de una
coleccin. Solo se mueve hacia delante en la lista.
Para recorrer un ArrayList, podemos llamar a get dado un ndice.
Podemos prescindir de los ndices y usar un Iterator sobre este ArrayList
La clase Iterator pertenece al paquete java.util
La nica funcin de un objeto de tipo Iterator es recorrer un ArrayList.
Iterator tiene como mtodos hasNext (que devuelve un boolean) y next (que devuelve
un Object).
2. ListIterator: Provee soporte para la iteracin a travs de una lista. Permite recorrer una lista
tanto hacia delante como hacia atrs.

La interfase de la interface ListIterator permite iterar a travs de las listas.
Los mtodos ms comunes de la interface Iterator son:

Metodo Descripcion
public boolean hasNext() Retorna true si la iteracin contiene ms elementos,.
public object next() Retorna el siguiente elemento de la lista
public void remove() Elimina el ltimo elemento retornado por el mtodo next()

9
1


9
2


Ejemplo: uso de Iterator para recorrer un ArrayList

import java.util.*;
public class ArrayListIterator {
public static void main(String[ ] args) {
ArrayList thisArrayList = new ArrayList();
thisArrayList.add("hello");
thisArrayList.add(",");
thisArrayList.add("are");
thisArrayList.add("you");
thisArrayList.add("?");
Iterator it = thisArrayList.iterator();
while (it.hasNext())
System.out.print(it.next()+" ");
}
}

COLLECTION CLASES

9
3


9
4

OBJETOS SET
La clase HashSet implementa la interface Set.
Los objetos HashSet no permiten duplicados y no estn ordenados.
La clase TreeSet implementa la interfase SortedSet.
Los objetos de tipo TreeSet no admiten duplicados y ordenan sus elementos de forma
ascendente. Incluye mtodos para aprovechar el ordenamiento, ejemplos:
1. TreeSet.first()
2. TreeSet.last()
3. TreeSet.headSet()
4. TreeSet.subSet()

OBJETOS LIST
Vector
Es una coleccin de objetos que implementa la interfase List.
De tamao variable.
Mantiene el orden en que los objetos son agregados.
Permite duplicados.
ArrayList
Clase similar a Vector, con la diferencia que no es sincronizada.
LinkedList
Cada elemento tiene una referencia al anterior y posterior elemento.

OBJETOS MAP
Usa una clave nica para referenciar un elemento.
La clave determina donde debe ser guardado un elemento.
El mtodo hashCode() de la clase Object provee el identificador nico del objeto (clave
nica). Este mtodo debe ser sobreescrito.

9
5


9
6

ORDENANDO Y MEZCLANDO UNA LISTA DE OBJETOS
Collection tiene mtodos de ordenamiento:
Collection.sort() ordena una lista completa o una subseccin de esta.
Collection.reverse() reversa la lista actual.
Shuffling (mezcla) mueve elementos dentro de una lista de forma aleatoria.

9
7


JG Tecnol ogas
LINKEDLIST
Es una lista enlazada de Recipientes (nodos) donde cada uno contiene elementos (objetos, otras
listas, etc) y uno o dos punteros hacia posiciones de memoria que apuntan al anterior o siguiente
nodo.

til cuando se quiere insertar o eliminar elementos al principio o al final de la lista. No permite
acceder a un elemento en concreto de la lista directamente sin recorrer antes los anteriores.

Linked List simplemente enlazada en Java

Linked List doblemente enlazada en Java


Linked List simplemente enlazada en Java

enlazada en Java
9
8

jgtecnol ogias. com

9
9


Ejemplo: Operaciones bsicas con LikendList

import java.util.*;
public class ListaLigada {

public static void main (String args[]) {
int num;
int op;

LinkedList lista = new LinkedList();
do{
System.out.println( "\t Men \t" );
System.out.println( "Operaciones con listas" );
System.out.println( "1.- Insertar al principio" );
System.out.println( "2.- Insertar al final" );
System.out.println( "3.- Borrar al principio" );
System.out.println( "4.- Borrar al final" );
System.out.println( "5.- Mostrar la lista" );
System.out.println( "6.- Borrar toda la lista" );
System.out.println( "7.- Salir" );
System.out.println( "\n" );
System.out.println( "Elija la operacin que desee" );

switch(op){
case 1:
System.out.println( "Inserte numero" );
num = leer.nextInt();
lista.addFirst(num);
break;
case 2:
System.out.println( "Inserte numero" );
num = leer.nextInt();
lista.addLast(num);
break;
case 3:
System.out.println( "Se borrara el primer nodo" );
lista.removeFirst();
break;

1
0
0


case 4:
System.out.println( "Se borrara el nodo final" );
lista.removeLast();
break;

case 5:
System.out.println( "La lista es la siguiente" );
List lista2 = new ArrayList(lista);
Iterator it = lista2.iterator();
while (it.hasNext()){
System.out.println(it.next()+"");
}
break;

case 6:
System.out.println( "Se borraran todos los elemtos de
la lista" );
lista.clear();
break;

case 7:
System.out.println( "Al rato" );
break;
}
}while( op != 7 );
}
}

1
0
1

ARRAYLIST
1. Un ArrayList es un array dinmico. No tiene restricciones de capacidad. Su tamao se ajusta
de forma dinmica.
2. Constructor por defecto: new ArrayList(). Inicialmente, la capacidad de un ArrayList creado
as es 0.
3. Los elementos dentro de un ArrayList son Objetos. No pueden ser de tipo bsico, pero
pueden ser de cualquier tipo de objeto.
4. La clase ArrayList forma parte del paquete java.util
5. Para poner un elemento dentro de esta estructura, usamos el mtodo add y para recoger un
elemento usamos el mtodo get.

A diferencia de la LinkedList, la ArrayList permite acceder a cualquier elemento de la lista
directamente mediante su ndice, lo que la hace especialmente adecuada para bsquedas rpidas.

Nota: Los objetos ArrayList se comportan igual que un objeto Vector desincronizado, por lo tanto, un
ArrayList se ejecuta mas rpido que un Vector, ya que el ArrayList no tiene que implementar los
mtodos de sincronizacin de procesos.

Operaciones con ArrayList:

Agregar elementos
El ArrayList contendr diversos elementos que debemos gestionar, para agregar elementos, se
puede hacer de dos formas usando el mtodo add() que recibe por parmetro un objeto de tipo
Object:

La primera forma sera insertndolo sin darle una posicin especfica, entonces, por defecto el
elemento ser agregado al final:
// instanciamos un nuevo ArrayList
ArrayList mi_lista = new ArrayList();

// agregamos el elemento, por defecto lo agregar de ltimo
mi_lista.add("elemento 1");

La segunda forma sera dndole una posicin especfica en la lista. Si se d el caso de que el
elemento que vamos a insertar en un ndice donde ya hay un elemento, la lista, por definicin el
elemento insertado y todos a la derecha de l se corrern una posicin a la derecha:

// instanciamos un nuevo ArrayList

1
0
2


// agregamos el elemento, por defecto lo agregar de ltimo
mi_lista.add(1, "elemento A");

Ejemplo: uso de ArrayList para almacenar varios caracteres

import java.util.*;
public class ArrayListExample1 {
public static void main(String[ ] args) {
ArrayList thisArrayList = new ArrayList();
thisArrayList.add("hello");
thisArrayList.add(",");
thisArrayList.add("are");
thisArrayList.add("you");
thisArrayList.add("?");
for (int i=0;i<thisArrayList.size();i++)
System.out.print(thisArrayList.get(i)+" ");
}
}

Eliminar Elementos
Para eliminar elementos se dispone de el mtodo remove() en el cual se recibe como argumento
el objeto (s, el objeto) o eleminar el elemento conociendo su indice el ndice (posicin).

Para este ejemplo supongamos que tenemos una clase Persona, que tiene nombre y edad,
insertaremos unos cuantas personas en la lista y luego eliminaremos una de ellas usando las dos
formas

1
0
3


//Eliminado segn su ndice en la lista
Persona persona_1 = new Persona("Julian", 20);
Persona persona_2 = new Persona("Bety", 17);
Persona persona_3 = new Persona("Marta", 22);


//agregamos unos cuantos elementos
mi_lista.add(persona_1);

// la estructura de a lista ha quedado asi: 0 = [Julian] 1 = [Bety] 2 = [Marta]
// si queremos eliminar a "Betty" por su ndice seria asi:
mi_lista.remove(1) // el 1 pertenece al ndice o posicion de Betty en la lista
// la estructura de la lista ha quedado as: 0 = [Julian] 1 = [Marta]

Nota: Marta ha pasado a la posicin 1, ya que la lista forza a correr todos los elementos a la
izquierda para que ocupe ese espacio eliminado, entonces el tamao de la lista se reduce a 2
elementos nicamente

La otra forma de eliminar elementos de la lista sera si le enviamos el objeto para que la lista lo
identifique. Aclaro, ingresar un nuevo elemento con los mismos datos no significa que sea el mismo
elemento, para que deba ser igual deber tener la misma instancia y/o la misma posicin en
memoria.
Persona persona_1 = new Persona("Julian", 20);
Persona persona_2 = new Persona("Bety", 17);
Persona persona_3 = new Persona("Marta", 22);


// agregamos unos cuantos elementos
// la estructura de a lista ha quedado asi: 0 = [Julian] 1 = [Bety] 2 = [Marta]

// si queremos eliminar a "Julian" debemos "enviarle a Juan" de nuevo
mi_lista.remove(persona_1) // se envia la instancia de Juan
// la estructura de a lista ha quedado asi: 0 = [bety] 1 = [Marta]

1
0
4


Ejemplo: Solicitar el nombre del alumno y tres calificaciones para luego calcular
su promedio. Se puede agregar cualquier cantidad de elementos a la lista

//Implementacin de la clase NodoLista4
public class NodoLista4{
String nom;
int calif1;
int calif2;
int calif3;
}

//Implementacin de la clase ListaAlumnos
import java.util.*;
public class ListaAlumnos{
static double prom;
public static void main( String args[] ){

NodoLista4 nodo = new NodoLista4();
int op;

ArrayList lista = new ArrayList();
do{
System.out.println( "Ingrese el nombre del alumno:" );
nodo.nom = leer.next();
System.out.println( "Ingrese la 1era. calificacin:" );
nodo.calif1 = leer.nextInt();
System.out.println( "Ingrese la 2da. calificacin:" );
System.out.println( "Ingrese la 3era. calificacin:" );

lista.add("Nombre del alumno:\n"+nodo.nom);
lista.add("Calificacin 1:\n"+nodo.calif1);
lista.add("Calificacin 2:\n"+nodo.calif2);
lista.add("Calificacin 3\n"+nodo.calif3);

promedio(nodo.calif1, nodo.calif2, nodo.calif3);

lista.add("Su promedio es:\n"+prom);

1
0
5


System.out.println( "Desea ingresar otro alumno?" );
System.out.println( "1.-Si\t 2.-No" );
}while(op != 2);
List lista2 = new ArrayList(lista);
Iterator it = lista2.iterator();
while (it.hasNext()){
System.out.println(it.next()+"");
}
}

private static double promedio(int calif1, int calif2, int
calif3){
int suma = calif1 + calif2 + calif3;
prom = suma/3;
return prom;
}
}

Otros mtodos de ArrayList

Mtodo Descripcin
int total = mi_lista.size(); Determina la cantidad de elementos de la lista
mi_lista.clear() Para vaciar la lista y dejarla sin ningn elemento
boolean existencia =
mi_lista.contains(elObjetoBuscado);
Para saber si un objeto sta insertado en lista usamos
el mtodo contains(), el cual devuelve true si existe o
un false si sucede lo contrario
boolean vacia = mi_lista.isEmpty(); Para saber si la lista esta vaca, es decir, si no tiene
elementos usamos isEmpty() que devuelve true si NO
hay elementos o un false si contiene algn elemento.
Object objetos [ ] = mi_lista.toArray(); Para pasar o copiar los elementos a un arreglo de
objetos (TipoObjeto objetos [ ])
void set(index, obj) Sustituye el elemento en la posicin index por el objeto
obj. (index tiene que ser entre 0 y size()-1) dentro del
ArrayList, sustituyendo el elemento previamente
almacenado a la posicin N. Es equivalente a A[N] =
obj para un array A.
Object remove(index) Elimina el elemento a la posicin index (index entre 0 y

1
0
6

size()-1). Devuelve el objeto eliminado Los elementos
despus de este objeto estn rebajados de una
posicin. El tamao del ArrayList disminuye de 1.
int indexOf(obj) Busca el objeto obj dentro del ArrayList, y si lo
encuentra, devuelve la posicin donde lo ha
encontrado. Si no, devuelve -1.
Object remove(index) Elimina el elemento a la posicin index (index entre 0 y
size()-1).
Devuelve el objeto eliminado
Los elementos despus de este objeto estn rebajados
de una posicin. El tamaodel ArrayList disminuye de
1.
int indexOf(obj) Busca el objeto obj dentro del ArrayList, y si lo
encuentra,
devuelve la posicin donde lo ha encontrado. Si no,
devuelve -1.

1
0
7

Ejercicios de ArrayList
Escribir los siguientes mtodos:
void eliminarTodos(ArrayList cadenas,String cadena)
Elimina todas las copias de cadena dentro de cadenas
int min(ArrayList numeros)
Devuelve el nmero ms pequeo del array dinmico
void toUpperCase(ArrayList cadenas)
Sustituye cada cadena (String) del arrayList por la su versin myuscula.
int veces(ArrayList cadenas,String cadena)
Devuelve el nmero de veces que aparece la cadena en el array dinmico de cadenas.

Clase Iterator
Para recorrer un ArrayList, podemos llamar a get dado un ndice (como en los mtodos
anteriores).
Podemos prescindir de los ndices y usar un Iterator sobre este ArrayList:
ArrayListIterator.java
La clase Iterator pertenece al paquete java.util
La nica funcin de un objeto de tipo Iterator es recorrer un ArrayList.
Iterator tiene como mtodos hasNext (que devuelve un boolean) y next (que devuelve un
Object).
Como StringTokenizer, un objeto de tipo Iterator es de un solo uso.

1
0
8


Ejemplo: uso de ArrayList para almacenar nmeros enteros

import java.util.ArrayList;
public class ArrayListInteger {
ArrayList numeros = new ArrayList();
Integer num1 = new Integer(10);
numeros.add(num1);
numeros.add(num2);
numeros.add(num3);
numeros.add(num4);
int suma=0;
for (int i=0;i<numeros.size();i++) {
Integer thisNumero = (Integer)numeros.get(i);
suma = suma + thisNumero.intValue();
System.out.print(thisNumero);
if(i<numeros.size()-1)
System.out.print("+");
else
System.out.print("=");
}
System.out.println(suma);
}
}

1
0
9


Ejemplo: uso de ArrayList Primero creamos una clase Persona

//Implementacin de la clase Persona
class Persona{
private String id;
private String nombres;
private String apellidos;

public Persona(){
//inicializamos variables
id = "";
nombres = "";
apellidos = "";
}
public void setId(String id){
this.id = id;
}
public void setNombres(String nombres){
this.nombres = nombres;
}
public void setApellidos(String apellidos){
this.apellidos = apellidos;
}
public String getId(){
return this.id;
}
public String getNombres(){
return this.nombres;
}
public String getApellidos(){
return this.apellidos;
}
}

1
1
0


Ejemplo(cont.): uso de ArrayList Primero creamos una clase Persona

//Implementacin de la clase main del proyecto
public class Main{
public static void main(String []args){
Scanner scanner = new Scanner(System.in);
ArrayList listaPersonas = new ArrayList();
//Ingresaremos en el ArrayList 3 Personas, pueden ser mas
Personas = 3;
for(int i = 0;i < numeroPersonas;i++){
Persona persona = new Persona();//Creamos una persona
System.out.println("id de la persona numero: "+i);
persona.setId(scanner.nextLine());
System.out.println("nombre de la persona num"+i);
persona.setNombres(scanner.nextLine());
System.out.println("apellido de la persona numero "+i);
persona.setApellidos(scanner.nextLine());
//adjuntamos a la lista la persona que acabamos de crear
listaPersonas.add(persona);
}

for(int j = 0;j < listaPersonas.size();j++){
//ahora imprimiremos las personas de nuestro ArrayList
System.out.println("Persona numero "+j);
Persona persona = (Persona)listaPersonas.get(j);
System.out.println("Id: "+persona.getId());
System.out.println("Nombre: "+persona.getNombres());
System.out.println("Apellidos: "+persona.getApellidos());
}
}
}

1
1
1

HASHSET
Un HashSet es una estructura de datos que contiene un conjunto de objetos. Permite buscar un
objeto dentro del conjunto de forma rpida y fcil. Internamente gestiona un array y guarda los
objetos utilizando un ndice calculado con un cdigo hash del objeto.
1. Los elementos de un HashSet no estn ordenados
2. Para aadir un elemento al HashSet se utiliza el mtodo add(Object obj).
3. Para borrar un elemento se utiliza remove(Object obj).
4. Para borrar todos los elementos se utiliza clear().
5. El tamao del HashSet se puede obtener con la funcin size()

JG Tecnol ogas
HASHMAP
Un HashMap permite guardar elementos, donde cada elemento es un
de un array simple donde se guarda el valor en un ndice en concreto, un HashMap determina el
ndice l mismo basndose en el valor hash (hashcode) generado a partir de la clave.

HashMap es una tabla en la que podemos insertar claves. Implementa el interface Map, lo cual nos
permite utilizar los mtodos relativos a los mapas. El rendimiento de las func
.put() es constante, ya que los elementos estn dispersos en el mapa de forma concreta

Sintaxis

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable,
Serializable

Un HashMap permite guardar elementos, donde cada elemento es un par clave/valor
l mismo basndose en el valor hash (hashcode) generado a partir de la clave.
permite utilizar los mtodos relativos a los mapas. El rendimiento de las func
.put() es constante, ya que los elementos estn dispersos en el mapa de forma concreta
1
1
2

jgtecnol ogias. com
par clave/valor. A diferencia
l mismo basndose en el valor hash (hashcode) generado a partir de la clave.

permite utilizar los mtodos relativos a los mapas. El rendimiento de las funciones bsicas .get() y
.put() es constante, ya que los elementos estn dispersos en el mapa de forma concreta .

1
1
3

Mtodos:
Mtodo Descripcin Sintaxis
clear() Elimina todos los mappings
<clave,valor> del array.
Map.clear()
clone()
containsKey() Mtodo que devuelve true si el
mapa contiene la clave pasada
como parmetro.
public boolean containsKey(Object key)
containsValue()
entrySet() Mtodo que devuelve una vista
del HashMap en formato
coleccin. Cualquier modificacin
en la vista afecta directamente al
contenido del HashMap. No
recibe parmetros
public Set<Map.Entry<K,V>> entrySet()
get() Retorna el valor del HashMap
para la clave pasada como
parmetro.
public V get(Object key)
isEmpty() Devuelve true si el map es vaco Boolean vacio=Map.Empty()
keySet() Devuelve un Set (conjunto de
elementos individuales nicos)
correspondiente a las claves del
map. Podemos iterar sobre este
Set (con un Iterator).

put() Aade el mapping <clave,valor>
a map, donde clave y valor son
objetos. Si clave ya existe,
sustituye su valor por valor.
public V put(K key, V value)
putAll()
remove() Elimina la asociacin cuya clave
es obj. Devuelve el valor
asociado con esta clave antes de
eliminar.

size() El tamao actual = nmero de
mappings <clave,valor>
Int tamao=Map.size()
values() Devuelve una Collection
(conjunto de elementos

1
1
4

individuales no nicos) de los
valores que hay dentro del
hashmap.
Podemos iterar sobre esta
Collection.

1
1
5

Ejemplo 1

Map<String,String> hm = new HashMap<String,String>();

hm.put("1","Luis");
hm.put("2","Amaya");
hm.put("3","Julio");

// Aadimos un elemento con clave existente. Se sobrescribe su valor
// ya que no puede haber valores duplicados
hm.put("1","Victor");

Iterator<Entry<String,String>> it = hm.entrySet().iterator();

while (it.hasNext()) {
Entry<String,String> e = it.next();
System.out.println(e.getKey() + " " + e.getValue());
}

Ejemplo 2

import java.util.*;
public class UseHashMap{
String aa= "INDIA";
HashMap hashmap = new HashMap();
hashmap.put("one",new Integer(1));
hashmap.put("two",null);
hashmap.put("three","THREE");
hashmap.put("four",aa);
System.out.println("The size of HashMap = "+ hashmap.size());
System.out.println("If hashmap empty = "+ hashmap.isEmpty());

Ejemplo del mtodo containsKey() del HashMap

// Nmero de ocurrencias
int[] listaNumeros = {1,4,7,8,9,2,7,15,4,6,9,9,8};
HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
int clave;

for (int x=0;x<listaNumeros.length;x++) {
clave = listaNumeros[x];

1
1
6

if (hm.containsKey(clave))
hm.put(clave, hm.get(clave)+1);
else
hm.put(clave,1);
}

Para recorrer un hashmap:
1. Conseguimos el conjunto de claves
2. Recorremos este conjunto, y para cada clave, sacamos su valor correspondiente en el
hashmap

System.out.println("The elements of HashMap are");
Set set= hashmap.keySet();
Iterator iter = set.iterator();
while(iter.hasNext()){
Object clave = iter.next();
Object valor = hashmap.get(clave);
System.out.println("Key: " + clave + " Value: " + valor);
}

1
1
7

Ejemplo del mtodo get() del HashMap


hm.put("1","Luis");

Iterator<Entry<String,String>> it = hm.entrySet().iterator();

Entry<String,String> e = it.next();
System.out.println(e.getKey() + " " + e.getValue());
}

Ejemplo de HashMap.entrySet()
Iterator<Entry<Integer,Integer>> it = hm.entrySet().iterator();

Entry<Integer,Integer> e = it.next();
System.out.println(e.getKey() + e.getValue());
}

Ejemplo de HashMap.put()

hm.put("1","Luis");

1
1
8


Ejemplo: Operaciones con HashMap

import java.util.HashMap;
import java.util.Iterator;

public class HashMapExample{
public static void main(String args[]){
//constructs a new empty HashMap with default initial capacity
HashMap hashMap = new HashMap();
/*
To specify initial capacity, use following constructor
HashMap HashMap = new HashMap(100);
To create HashMap from map use following constructor
HashMap HashMap = new HashMap(Map myMap);
*/
hashMap.put("One", new Integer(1)); // adding value into HashMap
hashMap.put("Two", new Integer(2));
hashMap.put("Three", new Integer(3));
/*
IMPORTANT : We CAN NOT add primitives to the HashMap.
We have to wrap it into
one of the wrapper classes before adding.
*/
/*
To copy all key - value pairs from any Map to HashMap use putAll
method.
Signature of putAll method is,void putAll(Map m)
*/

//get number of keys present in the HashMap
System.out.println("HashMap contains " + hashMap.size() + " key
value pairs.");

1
1
9


Ejemplo(cont): Operaciones con HashMap

/*
To check whether HashMap is empty or not, use isEmpty() method.
isEmpty() returns true is HashMap is empty, otherwise false.

Finding particular value from the HashMap:
HashMap's containsValue method returns boolean depending upon
the presence of the value in given HashMap

Signature of the containsValue method is, boolean
containsValue(Object value)

*/
if(hashMap.containsValue(new Integer(1))){
System.out.println("HashMap contains 1 as value");
}
else{
System.out.println("HashMap does not contain 1 as value");
}

/*
Finding particular Key from the HashMap:
HashMap's containsKey method returns boolean depending upon the
Presence of the key in given HashMap
Signature of the method is,
boolean containsKey(Object key)
*/

if( hashMap.containsKey("One") ){
System.out.println("HashMap contains One as key");
}
else{
System.out.println("HashMap does not contain One as value");
}

/*
Use get method of HashMap to get value mapped to particular key.
Signature of the get method is,
Object get(Object key)
*/

1
2
0



Integer one = (Integer) hashMap.get("One");
System.out.println("Value mapped with key \"One\" is " + one);

/*
IMPORTANT: get method returns Object, so we need to downcast it.
*/

/*
To get all keys stored in HashMap use keySet method
Signature of the keysSet method is,
Set keySet()
*/

System.out.println("Retrieving all keys from the HashMap");
Iterator iterator = hashMap.keySet().iterator();

while(iterator. hasNext()){
System.out.println(iterator.next());
}

/*
To get all values stored in HashMap use entrySet() method.
Signature of the entrySet() method is,
Set entrySet()
*/

System.out.println("Retrieving all values from the HashMap");
iterator = hashMap.entrySet().iterator();

while(iterator. hasNext()){
System.out.println(iterator.next());
}

1
2
1



/*
To remove particular key - value pair from the HashMap use remove
method.
Signature of remove method is,
Object remove(Object key)
This method returns value that was mapped to the given
key,
otherwise null if mapping not found.

*/

System.out.println( hashMap.remove("One") + " is removed from the
HashMap.");

}
}

/*
OUTPUT of the above given Java HashMap Example would be :
HashMap contains 3 key value pair.
HashMap contains 1 as value
HashMap contains One as key
Value mapped with key "One" is 1
Retrieving all keys from the HashMap
Three
Two
One
Retrieving all values from the HashMap
Three=3
Two=2
One=1
1 is removed from the HashMap.
*/

1
2
2


Ejemplo: Agenda telefnica usando HashMap

AgendaHashMap.java
import java.util.*;
public class AgendaHashMap{
public static void main(String args[]){
HashMap agenda = new HashMap();// Definir un HashMap
// Agregar pares "clave"-"valor" al HashMap
agenda.put("Doctor", "(+52)-4000-5000");
agenda.put("Casa", "(888)-4500-3400");
agenda.put("Hermano", "(575)-2042-3233");
agenda.put("Tio", "(421)-1010-0020");
agenda.put("Suegros", "(334)-6105-4334");
agenda.put("Oficina", "(304)-5205-8454");
agenda.put("Abogado", "(756)-1205-3454");
agenda.put("Papa", "(55)-9555-3270");
agenda.put("Tienda", "(874)-2400-8600");

// Definir Iterator para extraer/imprimir valores
mostrarMapa(agenda);

// Definir un arreglo con valores determinados
String personas[] = {"Tio", "Suegros", "Abogado"};

// Eliminar los valores contenidos en el arreglo
for(int i = 0; i < personas.length; i++) {
agenda.remove(personas[i]);
}
mostrarMapa(agenda);
}

1
2
3


Ejemplo(cont): Agenda telefnica usando HashMap

public static void mostrarMapa(Map agenda){
System.out.println(" Agenda con " + agenda.size() +
" telefonos");
for( Iterator it = agenda.keySet().iterator();
it.hasNext();) {
String clave = (String)it.next();
String valor = (String)agenda.get(clave);
System.out.println(clave + " : " + valor);
}
}
} //Fin de la clase AgendaHashMap

1
2
4

Ejercicios de HashMap
Escribir los mtodos:
Alumno getAlumno(HashMap alumnos,String nia)
Dado un array asociativo de <NIA,objeto-alumno>, el mtodo devuelve el valor (objeto-alumno)
dado la clave.
void increment(HashMap palabras,String palabra)
Dado un array asociativo palabras de <cadena,numero>, donde cadena es una palabra (tipo) de un
corpus y numero el nmero de veces que ocurre en el corpus, el mtodo incrementa de uno el
nmero de veces que ocurre palabra.
Importante: puede que palabra no exista en el hashmap, en tal caso habr que aadirlo.

1
2
5


TREESET
Un TreeSet mantiene los objetos ordenados en lo que se conoce como un red-black tree, es decir,
en un rbol binario balanceado (cada padre tiene como mximo 2 hijos, y cuando se inserta una
entrada se autobalancea de forma que quede un rbol binario simtrico).

Un TreeSet permite hacer bsquedas rpidas. No tanto como un HashMap, pero el TreeSet tiene la
ventaja de estar ordenado por clave.

Ejemplo: Implementacin de varios tipos de estructuras en Java

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeMap;
import java.util.TreeSet;

public class CollectionAll {
List list1 = new LinkedList();
list1.add("list");
list1.add("dup");
list1.add("x");
list1.add("dup");
traverse(list1);

1
2
6

List list2 = new ArrayList();
list2.add("list");
list2.add("dup");
list2.add("x");
list2.add("dup");
traverse(list2);
Set set1 = new HashSet();
set1.add("set");
set1.add("dup");
set1.add("x");
set1.add("dup");
traverse(set1);
SortedSet set2 = new TreeSet();
set2.add("set");
set2.add("dup");
set2.add("x");
set2.add("dup");
traverse(set2);
LinkedHashSet set3 = new LinkedHashSet();
set3.add("set");
set3.add("dup");
set3.add("x");
set3.add("dup");
traverse(set3);
Map m1 = new HashMap();
m1.put("map", "Java2s");
m1.put("dup", "Kava2s");
m1.put("x", "Mava2s");
m1.put("dup", "Lava2s");
traverse(m1.keySet());
traverse(m1.values());
SortedMap m2 = new TreeMap();
LinkedHashMap /* from String to String */m3 = new
LinkedHashMap();

1
2
7

}

static void traverse(Collection coll) {
Iterator iter = coll.iterator();
while (iter.hasNext()) {
String elem = (String) iter.next();
System.out.print(elem + " ");
}
System.out.println();
}

}

1
2
8

RESUMEN DE COLECCIONES

LISTAS: Interface List<E>

Mtodos:
boolean add(E elemento) boolean equals(Object x) E remove(int posicion)
void add(int posicion, E elemento) E get(int posicion) boolean remove(E elemento)
void clear() int indexOf(E elemento) E set(int posicion, E elemento)
boolean contains(E elemento) boolean isEmpty() Iterator<E> iterator()
int size()

Implementaciones
1. ArrayList<E>
2. LinkedList<E>
3. Vector<E>

Ejemplo
List<String> l = new ArrayList<String>();
l.add(hola);
l.add(adios);
l.add(ciao);
l.add(bye);
l.add(2, bye);
System.out.println(l.size()); // Devuelve 5
System.out.println(l.get(0)); // Devuelve hola
System.out.println(l.get(1)); // Devuelve adios
System.out.println(l.get(2)); // Devuelve bye
System.out.println(l.get(3)); // Devuelve ciao
System.out.println(l.get(4)); // Devuelve bye
for (String v: l)
System.out.print(v); // Imprime: holaadiosbyeciaobye
for (int i=0; i<l.size(); i++){
String v = l.get(i);
System.out.print(v);
} // Imprime: holaadiosbyeciaobye
Iterator<String> it = l.iterator();
while(it.hasNext()) {
String v = it.next();
} // Imprime: holaadiosbyeciaobye

1
2
9

CONJUNTOS: Interface Set<E>

Mtodos
boolean add(E elemento) boolean equals(Object x) boolean remove(E elemento)
void clear() boolean isEmpty() int size()
boolean contains(E elemento) Iterator<E> iterator()

Implementaciones
HashSet<E>
TreeSet<E>

Ejemplo
Set<String> s = new HashSet<String>() ;
s.add(hola);
s.add(adios);
s.add(ciao);
s.add(bye);
s.add(bye);
s.add(ciao);
System.out.println(l.size()); // Devuelve 4
for (String v: s)
System.out.print(v); // Imprime: holaadiosbyeciao
//(puede ser en otro orden)
Iterator<String> it = s.iterator();
while(it.hasNext()) {
String v = it.next();
procesa (dato);
}

1
3
0

INTERFACE Map<K,V>
Mtodos
void clear() boolean equals(Object x) Set<K> keySet()
boolean containsKey(Object clave) V get(Object clave) V put(K clave, V value)
boolean containsValue(Object valor) boolean isEmpty() V remove(Object clave)
int size()

Implementaciones
HashMap<K,V>
LinkedHashMap<K,V>
TreeMap<K,V>
Hashtable<K,V>

Ejemplo
Map<String,String> m = new HashMap <String,String>();
m.put("Pedro", "becario");
m.put("Pablo", "aprendiz");
m.put("Maria", "jefe");
m.put("Jorge", "desempleado");
m.put("Pablo", "empleado");
System.out.println(m.size()); // Devuelve 4
for (String k: m.keySet()) {
String v = m.get(k);
System.out.println(k + " = " + v);
} // Imprime: Pedro = becario
// Pablo = empleado
// Maria = jefe
// Jorge = desempleado
// (el orden puede variar)
for (Iterator<String> it=m.keySet().iterator(); it.hasNext();){
String k = it.next();
String v = m.get(k);
System.out.println(k + " = " + v);
}

1
3
1

ITERADORES
Clase Iterator<E>

Mtodos
boolean hasNext() E next() Void remove()

Ejemplo:
Ver ejemplos en listas y conjuntos

1
3
2

Ejemplo de colecciones

import java.util.*;
public class Colecciones {
List lista1 = new LinkedList();
lista1.add("elemento1"); lista1.add("elemento2");
mostrar_elementos(lista1);
List lista2 = new ArrayList();
lista2.add("elemento1"); lista2.add("elemento2");
mostrar_elementos(lista2);
Set conjunto1 = new HashSet();
conjunto1.add("elemento1");
mostrar_elementos(conjunto1);
SortedSet conjunto2 = new TreeSet();
mostrar_elementos(conjunto2);
Map mapa1 = new HashMap();
mapa1.put("clave1", "elemento1");
mostrar_elementos(mapa1.keySet());
mostrar_elementos(mapa1.values());
SortedMap mapa2 = new TreeMap();
mostrar_elementos(mapa2.keySet());
mostrar_elementos(mapa2.values());
}
static void mostrar_elementos(Collection coleccion) {
Iterator iterador = coleccion.iterator();
while (iterador.hasNext()) {
String elemento = (String) iterador.next();
System.out.print(elemento + " ");
}
}
}

1
3
3

UNIDAD VII
INTERFACES GRFICAS
1.
2.
Objetivo:
saberes relacionados con las diferentes tecnologas
de ranuras o slot de expansin desarrolladas para
aadir nuevo harware a nuestro pc como: tarjetas de
video, tarjetas de sonido, puertos paralelos (LPT) de
25 pines para impresoras, tarjetas de red rj45 e
inalmbricas, entre otros dispositos.

la capacidad de identificar fsicamente el tiopo de
ranura de expansin que posee una tarjeta madre
(ISA, PCI, AGP, PCI-Express, entre otras), as como
realizar una comparativas de velocidades de
transmisin y rendimiento.

Puntos a tratar:
1. Introduccin a Java swing
INTERFACES GRFICAS
7

1
3
4

INTRODUCCIN
Entendemos por Interfaz Grfica de Usuario (GUI) al software que permite la interaccin entre el
usuario y los servicios que proporciona el sistema operativo, utilizando para ello una representacin
grfica intuitiva de alto nivel

La informtica moderna no puede entenderse sin el impacto que supuso la generalizacin de los
entornos grficos de usuario a partir de los 80

Hoy en da, la mayor parte de las aplicaciones destinadas a usuarios finales se realizan para este
tipo de entornos

La mayora de los GUIs de propsito general siguen la llamada metfora de escritorio, y utilizan un
sistema de ventanas. Para la interaccin con el usuario disponen de un nmero ms o menos
grande de elementos o widgets: botones, editores, etc.
CARACTERSTICAS DE LA PROGRAMACIN EN GUIS
La programacin en un GUI determinado requiere el uso de un toolkit (o SDK) para ese GUI,
en el lenguaje de programacin que queramos utilizar.
Existe siempre un toolkit oficial que proporciona el fabricante del GUI, normalmente para C
o C++. Por ejemplo MFC para programacin en Windows
Tambin existen toolkits alternativos desarrollados por terceros, ya sean comerciales o
gratuitos. Por ejemplo, OWL (C++) de Borland para Windows
Finalmente tambin es posible el uso de un toolkit multiplataforma, como GTK+ (para C), Qt
o Fltk (ambos para C++)
La estructura de un GUI es de forma natural orientada a objetos.
El desarrollo con un toolkit orientado a objetos es mucho ms sencillo y rpido
La programacin de aplicaciones para un GUI implica un cambio radical de filosofa y
estructura en los programas.
Un programa tradicional tiene una estructura lineal, con el cdigo repartido en una serie de
funciones u operaciones.
Existe una funcin u operacin principal donde comienza la ejecucin y a partir de ah se
encadenan las llamadas de unas funciones a otras hasta que en un punto determinado
acaba la ejecucin

inicio

.

fin

Tarea 2 Tarea 1

1
3
5

En cambio la programacin en GUIs es orientada a eventos. La mayora de los eventos son
sucesos asncronos producidos por la interaccin del usuario con la aplicacin, y estn
ligados a algn elemento de la interfaz. Algunos ejemplos son:
o Pulsar un botn
o Cambiar el tamao de una ventana
o Mover una barra de desplazamiento
o Pulsar una tecla
o Tocar alguno de los botones minimizar maximizar cerrar
o de la ventana
o Hacer un click de ratn sobre un elemento determinado
Algunos eventos no relacionados directamente con el usuario son:
o Aparicin de una ventana
o Tick de un reloj programado con antelacin

La mayor parte del cdigo en un programa para un GUI est en los llamados manejadores de
eventos. Cada manejador se encarga de realizar el conjunto de acciones asociadas a un evento
determinado. Existe un gestor de eventos (que puede proporcionar el toolkit) que se encarga de
recibir todos los eventos de la aplicacin y llamar al manejador adecuado.

La programacin en GUIs suele ser un proceso iterativo de tres pasos:
1. El primero consiste en disear la interfaz de una parte de la aplicacin, utilizando
los widgets disponibles en el toolkit de desarrollo e incluye dos tareas:
a) Posicionar los widgets y establecer sus dimensiones
b) Modificar sus caractersticas visuales y funcionales (ttulos, colores,
comportamiento)
2. En el segundo se realiza la captura de los eventos de la interfaz que permitan
implementar la funcionalidad requerida
3. En el tercer paso, se implementa cada uno de los manejadores correspondientes
a los eventos capturados

1
3
6

Los entornos modernos orientados a componentes como Delphi, C++ Builder, Visual Basic etc.
Permiten realizar los dos primeros pasos de manera visual en lo que se conoce como fase de
diseo

Una vez realizado el diseo, los entornos de desarrollo eligen una de las siguientes
estrategias:
1. Salvar el diseo y las propiedades en ficheros ocultos especiales que son compilados
junto al cdigo (Delphi, C++ Builder, Visual Basic)
2. Generar el cdigo correspondiente de la interfaz que el desarrollador completa con
su propio cdigo (NetBeans).

1
3
7

GESTIN DE EVENTOS
Como acabamos de ver, en un programa para un GUI la tarea fundamental a realizar es
gestionar adecuadamente los eventos recibidos
La informacin asociada a un evento suele ser como mnimo un campo indicador del tipo de
evento y el identificador del elemento que genera dicho evento (botn, ventana, etc.)
Un aspecto fundamental en el diseo de un toolkit es la forma en que se produce la
conexin entre el gestor de eventos y los manejadores.
En los toolkits ms bsicos y primitivos, que suelen ser para el lenguaje C, el programador
realiza la Implementacin del gestor de eventos y la llamada directa a los distintos
manejadores.
Durante la inicializacin de la aplicacin debe pasarse al toolkit el nombre de nuestro gestor
de eventos

int main() {
...
/* Indicar al toolkit la funcin para la gestin de eventos */
gestorEventosGUI(gestorEventos);
...
}
void gestorEventos(Evento e){
switch(e.tipo) {
case VENTANA_ABRIR: ventanaAbrir(e); break;
case VENTANA_CERRAR: ventanaCerrar(e); break;
case BOTON_PULSADO: botonPulsado(e); break;
...
}
}
En toolkits ms sofisticados es posible indicar por cada evento que nos interese una funcin
que hace las veces de manejador (CALLBACK). El gestor de eventos est integrado en el
toolkit.
El uso de CALLBACKs suele favorecer el uso de elementos no muy aconsejables: variables
y objetos globales, punteros a void, etc.
int main() {
...
/* Indicar al toolkit los distintos manejadores */
manejadorEventoGUI(VENTANA_ABRIR, ventanaAbrir);
manejadorEventoGUI(VENTANA_CERRAR, ventanaCerrar);
manejadorEventoGUI(BOTON_PULSADO, botonPulsado);
...
}

1
3
8

Java utiliza un sistema basado en el patrn de diseo Observador
El elemento que genera un evento admite una lista de observadores del mismo
El elemento enviar una notificacin a los observadores cada vez que se genere el evento
// Definicin de una clase observador del procesamiento de
// pulsaciones de botn
class procesamientoBoton implements ActionListener {
void actionPerformed(ActionEvent e){
// Procesar evento de pulsacin de botn
}
}
// Suscribir el observador procesamientoBoton al evento de
// pulsacin de este botn
boton1.addActionListener(new procesamientoBoton());

Otros toolkits com Qt disponen de mecanismos especficos. Incorpora una extensin a C++
que permite enlazar un evento producido por un elemento con una operacin de un objeto
determinado (SIGNAL/SLOT)
MFC tambin hace uso extensivo de macros especiales para conectar los eventos con
ciertas operaciones de la clase que realizan su procesamiento

1
3
9

ARQUITECTURA DE UNA APLICACIN CON GUI
La arquitectura de una aplicacin con GUI tiene una serie de niveles que engloban clases que
realizan distintas tareas.
1. Capa de presentacin o interfaz
2. Capa de aplicacin o del dominio del problema
3. Capa de persistencia

Capa de presentacin

Capa de aplicacin

Capa de persistencia
LA CAPA DE PRESENTACIN O INTERFAZ
Contiene los objetos que permiten mostrar la informacin al usuario y gestionar la interaccin con el
mismo. Atencin: es dependiente del toolkit utilizado La capa de aplicacin o de dominio del
problema contiene las objetos que modelan la solucin del problema (objetos de negocio). Es la
capa ms importante y puede ser reutilizada total o parcialmente en mltiples aplicaciones similares
La capa de persistencia contiene el cdigo necesario para almacenar los objetos de negocio en
bases de datos o ficheros. Puede ser dependiente de la base de datos/formato de fichero utilizado.
LA CAPA DE APLICACIN
Contiene los objetos que modelan la solucin del problema (objetos de negocio). Es la capa ms
importante y puede ser reutilizada total o parcialmente en mltiples aplicaciones similares.
LA CAPA DE PERSISTENCIA
Contiene el cdigo necesario para almacenar los objetos de negocio en bases de datos o ficheros.
Puede ser dependiente de la base de datos/formato de fichero utilizado

Es fundamental respetar siempre esta divisin de tareas entre las clases de una aplicacin
Mezclar en una misma clase aspectos funcionalidades de estos tres niveles es un grave
fallo de diseo con diversas consecuencias
o Propensin a errores
o Dificultad para entender su funcionamiento
o Mantenimiento y localizacin de errores compleja
o Imposibilidad de reutilizacin

1
4
0

Otra regla importante a seguir es procurar que las clases de cada nivel se comuniquen
nicamente con las del nivel inmediatamente inferior
En la asignatura Interfaz PersonaOrdenador se estudiar con mayor detalle este tema
PROGRAMACIN DE GUIS EN JAVA
Puesto que Java pretende ser un lenguaje multiplataforma, el diseo del toolkit para
programacin de GUIs se hizo pensando en que las aplicaciones tuvieran un buen aspecto
en cualquier plataforma pero independiente de cualquier GUI especfico
Este toolkit se denomin AWT 1.0 (Abstract Window Toolkit)

1
4
1

Realmente las aplicaciones AWT 1.0 tenan un aspecto mediocre y un escaso nmero de
elementos. Adems su diseo interno era muy deficiente
La situacin mejor algo con AWT 1.1, pero no fue hasta Java 1.2 cuando apareci Swing,
un toolkit completamente nuevo, con un diseo interno orientado a componentes y un look
mucho ms satisfactorio

A pesar de que Swing tiene un estilo visual propio por defecto, puede tambin utilizar un aspecto
Motif, Windows o Apple. Estos ltimos slo en las plataformas correspondientes. Adems
puede cambiar de aspecto en tiempo de ejecucin

1
4
2

Aspecto swing por defecto:

Aspecto Motif

1
4
3

Aspecto Windows

1
4
4

COMPONENTES DE SWING
Componentes contenedores (sirven para contener y organizar otros compontes):
Componente

JFrame. Representa una ventana bsica, capaz
de contener otros componentes. Casi todas las
aplicaciones construyen al menos un JFrame

JDialog, JOptionPane, etc. Los cuadros de
dilogo son JFrame restringidos, dependientes
de un JFrame principal. Los JOptionPane son
cuadros de dilogo sencillos predefinidos para
pedir confirmacin, realizar advertencias o
notificar errores. Los JDialog son cuadros de
dilogo generales, normalmente utilizados para
peticiones de datos

JInternalFrame. Consiste simplemente en una
ventana hija, que no puede salir de los lmites
marcados por la ventana principal. Es muy
comn en aplicaciones que permiten tener
varios documentos abiertos simultneamente

JPanel. Un panel sirve para agrupar y organizar
otros componentes. Puede estar decorado
mediante un borde y una etiqueta

JScrollPane. Es un panel que permite visualizar
un componente de un tamao mayor que el
disponible mediante el uso de barras de
desplazamiento

1
4
5

Componente

JSplitPane.Permite visualizar dos componentes, uno a
cada lado, con la posibilidad de modificar la cantidad de
espacio otorgado a cada uno

JTabbedPane. Permite definir varias hojas con
pestaas, que pueden contener otros componentes. El
usuario puede seleccionar la hoja que desea ver
mediante las pestaas

JToolBar. Es un contenedor que permite agrupar otros
componentes, normalmente botones con iconos en una
fila o columna. Las barras de herramientas tienen la
particularidad de que el usuario puede situarlas en
distintas configuraciones sobre el frame principal

Controles especializados
Componente

JColorChooser. Consiste en un selector de colores

JFileChooser. Permite abrir un cuadro de dilogo para
pedir un nombre de fichero

JTable. Permite visualizar una tabla de informacin, con
capacidad para permitir la edicin por parte del usuario.
La tabla puede incluir texto, imgenes y algunos
controles bsicos como check buttons y combo boxes
configuraciones sobre el frame principal

1
4
6

Componente

JTree. Su funcin es mostrar informacin de tipo jerrquico

Controles no interactivos (muestran algn tipo de informacin pero no interaccionan con el
usuario):
Componente

JLabel. Permite situar un texto, un texto con una imagen o una
imagen nicamente en la ventana. No son iteractivos y puede
utilizarse cdigo HTML para escribir texto en varias lneas y con
varios atributos

JProgressBar. Permite mostrar que porcentaje del total de una
tarea a realizar ha sido completado

JToolTip. Consiste en una etiqueta de ayuda que surge al cabo
de uno segundos sobre la posicin apuntada por el cursor.
Normalmente no es necesario utilizar directamente la clase
JToolTip, se puede establecer para cualquier componente de la
ventana mediante: e.setToolTipText(sta es la etiqueta)

1
4
7

PRIMEROS PASOS EN SWING
Casi siempre, el primer paso a la hora de construir una aplicacin es crear un JFrame inicial
Por defecto un JFrame se crea de forma invisible, as que que es necesario activar su
visualizacin mediante la operacin setVisible()

import javax.swing.JFrame;
public class AppHolaMundo {
JFrame f = new JFrame("Prueba");
f.setVisible(true);
}
}

Sin embargo, al cerrar este frame la aplicacin no termina, se queda colgada. Esto ocurre
porque es necesario asociar la accin de cerrar el JFrame con la finalizacin de la aplicacin
Podemos realizar esta asociacin mediante la operacin setDefaultCloseOperation()

import javax.swing.*;
public class AppHolaMundo {
JFrame f = new JFrame("Prueba");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}
}

1
4
8


UNIDAD VIII
EJERCICIOS
3.
4.
OBJETIVO:
El objetivo de esta unidad es ofrecerles a los
participantes un conjunto de ejercicios propuestos y
otros resueltos con la intencin de realizar una
comprobacin de saberes de todas las unidades del
curso.

PUNTOS A TRATAS
1. Ejercicios de orientacin a objetos
2. Ejercicios de herencia
3. Ejercicios de concurrencia e hilos
EJERCICIOS
8

1
4
9

ORIENTACIN A OBJETOS
1. Desarrolle una clase en Java que realice la abstraccin de un sistema planetario debiendo tener
en cuenta para cada cuerpo del sistema aspectos como: masa, densidad, dimetro, distancia al
sol (suponga rbitas circulares), un nmero de identificador nico y un nombre textual. Incluya
mtodos que calculen la atraccin gravitatoria entre dos cuerpos cualesquiera del sistema.
2. Escriba un programa en java que genere aleatoriamente (Ayuda: Vea la clase Math para saber
cmo generar nmeros aleatorios en java) un array de nmeros reales, ylo ordene mediante el
algoritmo de la burbuja o mediante quicksort (esto deber poder elegirlo el usuario).
3. Se quiere implementar el control de un Ferry. Para ello cree una clase Vehculo. Incluya
aspectos comunes a todos los vehculos como nmero de pasajeros, presencia o ausencia de
tripulacin, nmero de ruedas, fecha de matriculacin, medio por el que se desplaza, etc.
Incluya los mtodos que considere oportunos. Realice un programa capaz de leer por teclado
los datos de 10 vehculos y los liste a continuacin por pantalla.
HERENCIA
1. A partir de la clase anterior, y mediante herencia cree nuevas clases que permitan diferenciar si
el objeto es un coche, una moto, un camin, una bicicleta, una lancha. Incluya en cada clase
algn atributo especfico que la diferencie de las dems. Por ejemplo, para el coche un booleano
que determine si es de tres o cinco puertas, para el camin la altura (indiferente en los otros
vehculos), etc. Realice un programa como el del ejercicio anterior capaz de trabajar con los
distintos tipos de vehculos.
CONCURRENCIA. HILOS
1. Desarrolle un programa en Java que implemente el primer paso del refinamiento sucesivo que
conduce al algoritmo de Dekker (variable de turno semforo).
2. Habilite una variable de turno compartida por dos hilos, cree estos utilizando el mtodo de
herencia de la clase Thread, y observe el comportamiento obtenido. La seccin crtica de cada
hilo ser otra variable compartida que se incrementar en uno, imprimindose su valor.
3. El planeta Wa-Tor es un mundo acutico, toroidal y reticulado de dimensin 20x20.Este mundo
est habitado por peces y tiburones de ambos sexos. Escriba un programa en java que
inicialmente site en forma aleatoria 100 peces (50 machos y50 hembras) y 10 tiburones (5
machos y 5 hembras) en el planeta de manera que:
a. Cada habitante del mundo (pez o tiburn) est representado por un hilo concurrente.
b. Cada habitante del mundo nada desde la posicin en que se encuentra una posicin
hacia el norte, sur, este u oeste (recuerde que el mundo es un toroide).
4. Si habitantes del mundo se encuentran en la misma posicin ocurre lo siguiente:
a. Si son del mismo sexo y de la misma especie, uno aniquila al otro.

1
5
0

b. Si son de especies diferentes, el tiburn siempre aniquila al pez.
c. Si son de la misma especie y de distinto sexo, se reproducen, generando un nuevo
individuo cuyo sexo ser macho o hembra con igual probabilidad, y luego continan su
camino.
5. Utilizando mtodos synchronized, disee un protocolo de exclusin mutua para n hilos
concurrentes. El nmero de hilos ser un argumento pasado desde la lnea de comandos, y la
seccin crtica de cada hilo ser una variable compartida por todos ellos, que se incrementar
en uno.
6. Utilizando una clase vaca, construya un protocolo de exclusin mutua para n hilos
concurrentes. El nmero de hilos ser un argumento pasado desde la lnea de comandos, y la
seccin crtica de cada hilo ser una variable compartida por todos ellos, que se incrementar
en uno. No utilice mtodo globalmente definidos como synchronized. En su lugar, utilice una
instancia de la clase vaca previamente definida como cerrojo que bloquee nicamente el
acceso en exclusin muta a la seccin crtica.
7. Habilite una variable de turno compartida por dos hilos, cree estos utilizando el mtodo de
herencia de la clase Thread, y observe el comportamiento obtenido. La seccin crtica de cada
hilo ser otra variable compartida que se incrementar en uno, imprimindose su valor.
8. Utilizando mtodos wait, notify y notifyAll , disee un protocolo de sincronizacin entre dos hilos
concurrentes.
9. Utilice varios hilos concurrentes para encontrar el valor mximo de un array de 100nmeros
enteros generados aleatoriamente. Cada hilo investigar un subarray de 10unidades, y el
programa principal deber coordinarse con ellos, para extraer la solucin final de las soluciones
parciales. Provea la exclusin mutua y la sincronizacin que considere necesarias.
10. Otro de los problemas clsicos de la comunicacin entre procesos ocurre en una peluquera. La
peluquera tiene un barbero, una silla de peluquero y n sillas para quese sienten los clientes en
espera, si es que los hay. Si no hay clientes presentes, el barbero se sienta en su silla de
peluquero y se duerme. Cuando llega un cliente, ste debe despertar al barbero dormiln. Si
llegan ms clientes mientras el barbero corta el cabello de un cliente, ellos se sientan (si hay
sillas desocupadas). Escriba un monitor en java que permita modelar el problema
11. El propsito del ejercicio es la construccin de un servidor remoto de operacionessobre vectores
reales. En particular el servidor debe poder sumar y restar vectores,realizar el producto escalar y
el escalado de un vector por un factor real. Debetambin comprobar la ortogonalidad entre dos
vectores. Para ello, el alumno debe:
a. Disear un fichero de interfaz (llamado IVector.java) que implante la interfaz java
necesaria.
b. Escriba el fichero que realice la implementacin del fichero de interfaz.(ImpVector.java)
c. Escriba un servidor que lance tres hilos concurrentes, cada uno de los cuales registre un
objeto servidor con un nombre diferente pero sobre el mismo puerto.(servidor.java)

1
5
1

d. Obtenga los ficheros de stub y skeleton correspondientes, y realice el registro delos
servicios.
e. Confeccione un cliente que cree varios hilos concurrentes. Cada hilo debe obtener una
referencia a un objeto servidor, y enviarle peticiones de trabajo. (cliente.java)

1
5
2

EJERCICIOS RESUELTOS
Una empresa de autobuses hace viajes desde la Capital del Pas hacia ciudades del interior, para lo
cual dispone de dos tipos de vehculos, pequeos y grandes, con capacidad de 20 y 60 pasajeros
respectivamente.

Cada vez que parte un autobs del terminal de la ciudad Capital es anotado el tipo de vehculo (P o
G) y el nmero de pasajeros que transporta.

La empresa desea un reporte al final del da con la informacin siguiente:
1) Para cada viaje:
a. El tipo de autobs:
b. La cantidad de pasajeros.
c. El mensaje " Gananca " si en el autobs viaja un nmero de pasajeros igual o mayor que el
50% de su capacidad, y " Prdida " en caso contrario.

2) Para la totalidad de los viajes:
a) Para cada tipo de vehculo:
i) El nmero de viajes.
ii) El total de pasajeros.
iii) c. El promedio de pasajeros por viaje.

Cree los mtodos necesarios para resolverlo.

1
5
3


Solucin: Desarrollo de la clase

class CAutobuses{
public static void main (String arg[]){
char resp,tipo;
int pas , acumP , acumG , contP , contG ;
pas = acumP = acumG = contP = contG = 0;
System.out.println("Hay Autobuses? ");
resp = CTeclado.ReadChar();
while ((resp == 's') || (resp == 'S')){
System.out.println("Tipo de autobus P o G ");
tipo = CTeclado.ReadChar();
System.out.println
("Introd. Cantidad de pasajeros ");
pas = CTeclado.ReadInt();

if ((tipo == 'p') && (pas <= 20)){
Viaje(20, pas, tipo);
contP++;
acumP += pas;
}
else if ((tipo == 'g') && (pas <= 60)){
Viaje(60, pas, tipo);
contG++;
acumG += pas;
}
else{
System.out.println
("Hay error en la entrada");
}
System.out.println("Hay Autobuses? ");
resp = CTeclado.ReadChar();
}
System.out.println
("Para los autobuses tipo 'p' pequenos ");
MostrarTotales (contP, acumP);
System.out.println
("Para los autobuses tipo 'g' grandes ");
MostrarTotales (contG, acumG);
}

1
5
4


static void Viaje (int puestos,int pasajeros,char tipo){
System.out.println("El tipo de autobus es " + tipo);
System.out.println("El autobus tiene " + pasajeros + "
pasajeros");
if ((pasajeros * 100/puestos) >= 50){
System.out.println("Ganancia");
}
else{
System.out.println("Perdida");
}
}

static void MostrarTotales (int contador,int acumulador){
System.out.println
("La cantidad de Viajes fue " + contador);
System.out.println
("La cantidad de pasajeros " + acumulador);
System.out.println
("El Promedio de pasajeros por viajes fue" +
acumulador/contador);
}
}

Manual Java

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Manual Java

Încărcat de

Drepturi de autor:

Formate disponibile

Este curso tiene por objetivo brindar el conocimiento sobre la programacin orientada a

S-ar putea să vă placă și