Módulo Java Programación Lenguaje

Mdulo 2
Lenguaje de
Programacin JAVA
Profesional en
Plataforma
JAVA
www.learning.es
Para uso exclusivo de los alumnos de LEARNING & TRAINING CLOUD, S.L.
Contenido
Introduccin y Objetivos ........................................................................................................ 1
Introduccin ........................................................................................................................................................... 1
Objetivo .................................................................................................................................................................. 1
Unidad 1. Introduccin .......................................................................................................... 2
Arquitectura de Java ............................................................................................................................................... 2
Introduccin ........................................................................................................................................................... 2
La mquina virtual Java (JVM) ................................................................................................................................ 2
El Garbage collection .............................................................................................................................................. 3
Seguridad del cdigo .............................................................................................................................................. 3
Caractersticas de Java............................................................................................................................................ 4
Desarrollo con Java................................................................................................................................................. 5
Unidad 2. Programacin Orientada a Objetos ........................................................................... 8
Introduccin ........................................................................................................................................................... 8
Clases ..................................................................................................................................................................... 9
Tipos de clases ...................................................................................................................................................... 11
Variables de instancia ........................................................................................................................................... 12
Variables estticas ................................................................................................................................................ 12
Variables finales ................................................................................................................................................... 13
Mtodos de clase ................................................................................................................................................. 13
Sobrecarga de mtodos o polimorfismo .............................................................................................................. 14
Unidad 3 . Identificadores, palabras clave y tipos .................................................................... 15
Introduccin ......................................................................................................................................................... 15
Utilizar comentarios en el cdigo fuente .............................................................................................................. 15
Identificadores ..................................................................................................................................................... 15
Tipos de datos ...................................................................................................................................................... 17
Variables ............................................................................................................................................................... 18
Operadores........................................................................................................................................................... 18
Laboratorio 1: Definiendo tipos de datos ............................................................................................................. 22
Laboratorio 2: Definiendo tipos de datos II .......................................................................................................... 22
Laboratorio 3: Definiendo tipos de datos III ......................................................................................................... 23
Unidad 4. Expresiones y control de flujo ................................................................................. 24
Introduccin ......................................................................................................................................................... 24
if-else .................................................................................................................................................................... 24
switch-case ........................................................................................................................................................... 25
www.learning.es
for ......................................................................................................................................................................... 26
while ..................................................................................................................................................................... 26
do-while ............................................................................................................................................................... 27
CONTINUE ............................................................................................................................................................ 29
BREAK ................................................................................................................................................................... 29
return ................................................................................................................................................................... 29
Laboratorio: Uso del bucle While ......................................................................................................................... 30
Unidad 5. Arrays ................................................................................................................ 31
Introduccin ......................................................................................................................................................... 31
Creacin de un array ............................................................................................................................................ 31
Unidad 6. Diseo de clases ................................................................................................... 34
Introduccin ......................................................................................................................................................... 34
Variables y mtodos en las subclases ................................................................................................................... 36
Clases y Mtodos finales ...................................................................................................................................... 36
Clases abstractas .................................................................................................................................................. 36
Paquetes............................................................................................................................................................... 37
Interfaces ............................................................................................................................................................. 38
Unidad 7. Caractersticas Avanzadas de Clases ........................................................................ 39
Introduccin ......................................................................................................................................................... 39
this y super ........................................................................................................................................................... 39
Destruccin de objetos ......................................................................................................................................... 40
Crear y usar tipos enumerados ........................................................................................................................... 41
Importaciones estticas ....................................................................................................................................... 41
Laboratorio: Clase Objeto cadena ........................................................................................................................ 42
Unidad 8. Excepciones y aserciones ....................................................................................... 45
Introduccin ......................................................................................................................................................... 45
try-catch-finally .................................................................................................................................................... 45
ASERCIONES ......................................................................................................................................................... 47
Unidad 9. API Colecciones y genricos ................................................................................... 49
Introduccin ......................................................................................................................................................... 49
Colecciones........................................................................................................................................................... 49
Genricos ............................................................................................................................................................. 55
Unidad 10. Principios bsicos de E/S ...................................................................................... 58
Introduccin ......................................................................................................................................................... 58
Argumentos de la lnea de comandos .................................................................................................................. 58
www.learning.es
Propiedades del Sistema ...................................................................................................................................... 58
Ficheros ................................................................................................................................................................ 61
Laboratorio: Uso de la clase File ........................................................................................................................... 63
Laboratorio: Uso de las clases FileOutputStream y FileInputStream .................................................................... 67
Unidad 11. E/S de consola y E/S de archivos .......................................................................... 83
Introduccin ......................................................................................................................................................... 83
System.in .............................................................................................................................................................. 84
System.out ........................................................................................................................................................... 85
System.err ............................................................................................................................................................ 85
Unidad 12. Creacin de interfaces grficas con el API Swing ..................................................... 87
Introduccin ......................................................................................................................................................... 87
Programacin grfica con Swing .......................................................................................................................... 88
Ejemplos con algunas de las clases de Swing ....................................................................................................... 90
Laboratorio: Manejo de los cuadros de dilogo ................................................................................................... 96
Unidad 13. Control de eventos generados por la interfaz grfica ............................................... 102
Introduccin ....................................................................................................................................................... 102
Modelo nuevo de delegacin. (Source, Listener, Adapter). ............................................................................... 102
Ejemplos con eventos ......................................................................................................................................... 104
Clase SwingWorker ............................................................................................................................................. 105
Laboratorio 1: Movimiento entre frames ........................................................................................................... 106
Laboratorio 2: Cargador de imgenes ................................................................................................................ 109
Unidad 14. Aplicaciones basadas en la interfaz grfica ........................................................... 112
Introduccin ....................................................................................................................................................... 112
Creacin de un men ......................................................................................................................................... 112
Creacin de un Toolbar ...................................................................................................................................... 114
JPopupMenu ...................................................................................................................................................... 115
Unidad 15 . Hilos ................................................................................................................ 118
Introduccin ....................................................................................................................................................... 118
Ciclo de vida de un thread .................................................................................................................................. 118
Primer ejemplo de hilos ..................................................................................................................................... 119
Mtodos de la clase Thread ............................................................................................................................... 121
resume() ............................................................................................................................................................. 121
getPriority() ........................................................................................................................................................ 122
setPriority( int ) .................................................................................................................................................. 122
getName() .......................................................................................................................................................... 122
www.learning.es
setName( String ) ................................................................................................................................................ 122
Uso de Wait y Notify........................................................................................................................................... 122
Sincronizacin .................................................................................................................................................... 126
Unidad 16. Programacin en red ......................................................................................... 128
Introduccin ....................................................................................................................................................... 128
Clase InetAddress ............................................................................................................................................... 128
Realizar Laboratorio: Uso de la clase InetAddress .............................................................................................. 129
Socket ................................................................................................................................................................. 130
CLASE URL .......................................................................................................................................................... 132
CLASE URLConnetion .......................................................................................................................................... 134
CLASES DatagramPacket y DatagramSocket ....................................................................................................... 135
RMI ..................................................................................................................................................................... 137
www.learning.es
Introduccin y Objetivos
Introduccin
Sun Microsystems es la empresa que ha inventado el lenguaje Java, en un intento de resolver
simultneamente todos los problemas que se planteaban a los desarrolladores de software por la
proliferacin de arquitecturas incompatibles en los siguientes aspectos:
* Diferentes mquinas desde el punto de vista del hardware

* Diferentes sistemas operativos
* Diferentes sistemas de ventanas que funcionan sobre una misma mquina.
Estos problemas se han agravado an ms con la expansin de Internet en la cual debe
comunicarse plataformas heterogneas, y dnde las aplicaciones distribuidas son el corazn del
sistema.
Objetivo
El xito de Java reside en su arquitectura y las caractersticas que esta arquitectura le confiere, lo
cual veremos en el desarrollo del mdulo.
www.learning.es
Unidad 1. Introduccin
Sun Microsystems es la empresa que ha inventado el lenguaje Java, en un intento de resolver
simultneamente todos los problemas que se planteaban a los desarrolladores de software por la
proliferacin de arquitecturas incompatibles en los siguientes aspectos:
- Diferentes mquinas desde el punto de vista del hardware.

- Diferentes sistemas operativos.
- Diferentes sistemas de ventanas que funcionan sobre una misma mquina.
Estos problemas se han agravado an ms con la expansin de Internet en la cual deben

comunicarse plataformas heterogneas, y dnde las aplicaciones distribuidas son el corazn del
sistema.
El xito de Java reside en su arquitectura y las caractersticas que esta arquitectura le confiere.
Arquitectura de Java
Introduccin
En la arquitectura de Java es dnde se encuentra la solucin al problema planteado en la
introduccin. El siguiente dibujo intenta resumir dicha arquitectura:
- Los programas se compilan a un fichero (*.class) intermedio, en un lenguaje creado por Sun
(bytecodes). Este fichero luego es interpretado por una mquina virtual java (JVM). Por tanto,
java es compilable-interpretable.
La mquina virtual Java (JVM)

La Especificacin de la Mquina Virtual Java la define como:
Una mquina imaginaria implementada mediante la emulacin por software en una mquina real. El
cdigo para la mquina virtual Java se almacena en archivos .class, cada uno de los cuales contiene,
al menos, el cdigo para una clase pblica.
La especificacin de la mquina virtual java proporciona las especificaciones de hardware para las
que se compila toda la tecnologa java. Esta especificacin permite al software en java ser
independiente de la plataforma ya que la compilacin se hace para una mquina genrica conocida
como la mquina virtual java (JVM). Esta puede ser emulada por software para poder ser ejecutada
en los diferentes sistemas informticos existentes, o bien ser implementada en hardware.
www.learning.es
A partir del cdigo fuente el compilador genera bytecodes. Estos bytecodes son instrucciones de
cdigo mquina para la JVM. Cada intrprete de java tiene una implementacin de la JVM.
La especificacin de la JVM proporciona definiciones muy concretas para la implementacin de:
- Conjunto de instrucciones (equivalente al de la CPU).

- Registros del sistema.
- Formato de los archivos de clase.
- Pila.
- Garbage-collected heap.
- rea de memoria.
El Garbage collection
Gran parte de los lenguajes de programacin permiten la reserva de memoria en tiempo de
ejecucin. El proceso de reserva de memoria vara segn la sintaxis del lenguaje, pero siempre
involucra el retorno de un puntero al inicio del bloque de memoria reservado.
Una vez la memoria reservada deja de necesitarse (el puntero que la referencia esta "out of scope"),
el programa o el entorno de ejecucin debera liberar esa memoria.
En C, C++, y otros lenguajes, el programador es responsable de la gestin de la liberacin de

memoria. Esta es una tarea complicada a veces porque no siempre se sabe a priori cuando se puede
liberar la memoria. Los programas que no liberan la memoria utilizada pueden generar errores de
ejecucin cuando ya no queda memoria disponible en el sistema. Se dice que estos programas
tienen fugas de memoria ("memory-links").
Java libera al programador de la responsabilidad de liberar la memoria. El lenguaje java proporciona

una hebra de ejecucin, o proceso en paralelo, a nivel de sistema que rastrea las operaciones de
reserva de memoria. Durante los ciclos muertos de la JVM, la hebra de "garbage collection" verifica
qu memoria puede liberarse y realiza dicha operacin.
El proceso de "Garbage collection" se realiza automticamente durante el ciclo de vida de un

programa java, eliminando la necesidad de liberar memoria y evitando las prdidas de memoria. Sin
embargo, la implementacin del gestor de "garbage collection" puede variar sustancialmente en las
diferentes implementaciones de la JVM.
Seguridad del cdigo

Ya hemos visto que el cdigo fuente de Java se compila en el sentido de que se convierten a un
conjunto de bytecodes.
En el momento de la ejecucin, los diferentes archivos bytecodes que componen el programa a

ejecutar se cargan, se verifican y se ejecutan en el intrprete. La funcin del intrprete es doble:
- Por un lado ejecuta los bytecodes y por otro gestiona las llamadas al hardware del sistema.
- El entorno de ejecucin que ejecuta el cdigo compilado para una JVM realiza tres tareas
principales:
- Carga el cdigo: Lo realiza el cargador de clases.
- Verificacin del cdigo: Lo realiza el verificador de bytecode.
- Ejecucin del cdigo: Lo realiza el intrprete de bytecode.
El cargador de clases
Su funcin es cargar todas las clases necesarias para la ejecucin de un programa.
www.learning.es
Adems, mantiene separadas aquellas clases cargadas a partir del sistema de archivos local y
aquellas otras cargadas a travs de los recursos de la red. Esto permite limitar la accin de posibles
aplicaciones dainas, ya que las clases locales son las primeras en ser cargadas.
Una vez que todas las clases han sido cargadas, se determina el mapa de memoria de la aplicacin.
En este momento se asigna direcciones de memoria reales a las referencias simblicas del cdigo y
se rellena la tabla de asignacin de memoria. Debido a que el proceso de asignacin de memoria se
realiza en el momento de la ejecucin, el intrprete de java aade proteccin contra acceso no
autorizado a las reas de cdigo.
Verificador de bytecode
El cdigo de java se verifica mediante diferentes test antes de ejecutarse en la mquina. La JVM
verifica el formato de los diferentes fragmentos de bytecode en busca de cdigo ilegal - cdigo que
utilice punteros, que viola los permisos de acceso de los objetos o intenta cambiar los tipos de los
objetos. Todas las clases importadas por la red pasan obligatoriamente por el verificador de
bytecode.
En el proceso de verificacin se resuelve si el cdigo cumple las especificaciones de la JVM y no viola

la integridad del sistema. Si la verificacin se completa con xito, se puede asegurar lo siguiente:
- Las clases cumplen con el formato de archivo de clase de la especificacin JVM.
- No hay violaciones de acceso restringido.
- El cdigo no provoca desbordamientos de la pila.
- Los tipos de parmetros para todo el cdigo es correcto y no se modificar durante la ejecucin.
- No existen conversiones ilegales de datos, por ejemplo, convertir enteros a referencias a
objetos.
- Los accesos a los campos de los objetos estn autorizados.
Caractersticas de Java
Introduccin
La arquitectura presentada en el punto anterior proporciona unas caractersticas a Java que ningn
otro lenguaje de programacin tiene:
Robusto
Java realiza verificaciones en busca de problemas tanto en tiempo de compilacin como en tiempo
de ejecucin. En tiempo de compilacin no tiene ningn misterio porque todos los lenguajes realizan
esas verificaciones, sin embargo, en tiempo de ejecucin, la JVM, que realiza la interpretacin de los
bytecodes, detecta cuando existe algn problema en la ejecucin del programa, y lanza excepciones
que pueden ser recogidas por el programador con el propsito de recuperarse de dichos errores.
Arquitectura neutral (multiplataforma)

Gracias a que la compilacin se realiza a un cdigo objeto independiente de la arquitectura de la
mquina (bytecodes), tan slo necesitamos utilizar el intrprete adecuado para que nuestro
programa funcione sobre cualquier plataforma. El lema de Sun es "escribir una vez, ejecutar en
cualquier parte".
Seguro
Como toda la ejecucin la realiza la JVM, los programas Java pueden ser sometidos a muchas
comprobaciones antes de ejecutarse en la mquina. En concreto:
- El cdigo se pasa a travs de un verificador de ByteCodes que comprueba el formato de los
fragmentos de cdigo y detecta fragmentos de cdigo ilegal (cdigo que falsea punteros, viola
derechos de acceso sobre objetos, ...).
www.learning.es
- El cargador de clases separa el espacio de nombres del sistema de ficheros local del de los
recursos procedentes de la red. Esto limita cualquier aplicacin del tipo Caballo de Troya, ya que
las clases se buscan primero entre las locales y luego entre las procedentes del exterior.
- Respecto a la seguridad del cdigo fuente, el propio JDK proporciona un desensamblador de
ByteCodes, que hace que cualquier programa pueda ser convertido a cdigo fuente a partir de
sus bytecodes. Utilizando javap no se obtiene el cdigo fuente original, aunque si desmonta el
programa mostrando su estructura. Este problema de seguridad del cdigo fuente es algo
todava pendiente de subsanar.
Portable
Ms all de la portabilidad bsica por ser de arquitectura independiente, Java implementa otros
estndares de portabilidad para facilitar el desarrollo.
Los enteros son de 32 bits en complemento a 2.
Java construye sus interfaces de usuario a travs de un sistema abstracto de ventanas de forma que
stas puedan ser implantadas en entornos UNIX, Mac o Pc.
Desarrollo con Java

Para poder desarrollar software con Java necesitamos una serie de herramientas que nos
proporciona Sun a travs de su JDK (Java Development Kit).
Al igual que el lenguaje natural que utilizamos para comunicarnos, ya sea de forma oral o por
escrito, cualquier lenguaje de programacin dispone de unos elementos y reglas que deben
conocerse a la hora de programar.
Los elementos del lenguaje natural nos permiten designar cosas (nombres), expresar cualidades de
esas cosas (adjetivos), expresar acciones (verbos), etc.
Las reglas sintcticas (estructura) y semnticas (significado) permiten el entendimiento entre las
partes que forman la comunicacin.
En los lenguajes de programacin tambin encontramos unas reglas sintcticas que debemos
respetar a la hora de confeccionar los programas y una semntica encargada de resolver el
problema que queremos programar.
Elementos y reglas sintcticas de los lenguajes de programacin

Aunque todos los conceptos que aprenderemos a continuacin aparecen en todos los lenguajes de
programacin existen diferencias en la implementacin en cada uno de ellos lo que obliga a un
estudio individual en cada uno de ellos.
Comentarios en los programas

Un aspecto importante a la hora de confeccionar un programa es comentar lo ms detalladamente
posible lo que significa cada una de las rdenes que forman parte del programa, con el propsito de
poder recordar en un futuro la funcin que realiza cada una de ellas, y facilitar su estudio a personas
ajenas al programa.
Identificadores
En todo lenguaje de programacin surge la necesidad de utilizar una serie de elementos que
debemos designar con algn nombre, por ejemplo:
Elemento Descripcin
Variables - Elementos utilizados para referenciar posiciones de memoria dnde podremos
almacenar datos necesarios para el programa.
Funciones - Elementos utilizados para referenciar posiciones de memoria dnde reside el
www.learning.es
Elemento Descripcin
cdigo del programa.
Objetos - Elementos que encapsulan variables (propiedades) y funciones (mtodos) de
manera que resulta ms sencillo modelar los problemas que queremos resolver
simplificando el diseo de programas complejos.
etc. - Conforme avancemos iremos conociendo ms elementos de los lenguajes de
programacin.
A la hora de asignar nombre a todos estos elementos hay que seguir unas reglas.
Tipos de datos bsicos

El modelo mental ms sencillo que se puede tener de una aplicacin informtica es el de una caja
negra que recibe unos datos de entrada, los procesa y entrega unos datos de salida representados
de alguna manera.
Estos datos de entrada, los cules deben ser albergados en memoria y referenciados mediante
alguna variable, pueden ser de diferente naturaleza (numricos, alfanumricos, etc.).
Cada lenguaje de programacin dispone de unos tipos de datos bsicos a los cules nos tenemos
que amoldar a la hora de realizar el anlisis de los datos que necesitamos en nuestra aplicacin.
Variables
Este elemento juega un papel muy importante en el programa porque es el mecanismo que pone a
nuestra disposicin el lenguaje de programacin para gestionar de una manera sencilla los datos de
la aplicacin.
Al declarar una variable en el programa estamos reservando una zona de memoria para
posteriormente albergar un dato. Existen lenguajes que necesitan que especifiquemos el tipo de
dato que se va a albergar (java) y otros que no lo necesitan (javascript).
Al asignar un valor a la variable lo que estamos haciendo es almacenar el dato en la posicin de

memoria que se reserv para dicha variable.
En todo momento tenemos que tener presente que al usar la variable realmente estamos usando el
dato al que representa.
Operadores
Una de las primeras aplicaciones de los ordenadores fue el clculo de matemtico y, aunque ahora
ha pasado a un segundo plano, los lenguajes de programacin ofrecen una serie de elementos que
permiten realizar operaciones con los datos.
Estas operaciones no slo se limitan a operaciones aritmticas. Disponemos tambin de operaciones

lgicas, comparaciones, etc.
Sentencias de control
Sin embargo, la caracterstica que confiere al ordenador su potencia es la capacidad de
procesamiento de la que dispone.
Aunque esto nos pueda asustar, el tipo de procesamiento que puede realizar es muy bsico,
limitndose a:
Tomar decisiones sobre la ejecucin o no de determinadas tareas en base al cumplimiento o no de

una o varias condiciones (sentencias de decisin). En dichas condiciones siempre estarn implicados
datos (o si se quiere, sus representantes las variables).
www.learning.es
Alterar el flujo de ejecucin normal del cdigo del programa (sentencias de salto o bucles). Tambin
estas alteraciones estarn controladas por variables.
La combinacin adecuada de este tipo de sentencias es la que definir la estructura que resuelve un
determinado problema.
Almacenamiento de datos mediante Arrays.

Hemos visto el uso de variables como mecanismo bsico para almacenar y acceder a datos en
memoria. Sin embargo, en la mayora de aplicaciones este tipo de almacenamiento de informacin
se queda corto por ser demasiado simple y necesitamos a sistemas de almacenamiento ms
complejos pero tambin ms potentes.
Uno de estos sistemas, que aparece en todos los lenguajes de programacin, es el de los Arrays.
Excepciones
Todos los lenguajes de programacin avisan de los errores que cometamos en tiempo de
compilacin, pero pocos son los que han sido diseados para seguir avisando de posibles errores en
tiempo de ejecucin. Las aplicaciones Java, gracias a que se ejecutan bajo la supervisin de la
mquina virtual (JVM), estn siendo controladas constantemente. En caso de que ocurra algn error
de ejecucin, se lanza una excepcin que puede ser recogida y tratada por el programador en su
aplicacin. De esta manera, lo que antes sola terminar en una ejecucin anormal del programa, con
java puede ser resuelto.
Objetos
Java es un lenguaje de programacin orientado a objetos. La importancia de este tema es tal que le
dedicamos el siguiente captulo entero.
Actividades
Recuerde que para un seguimiento ptimo de la unidad es imprescindible realizar las
actividades que encontrar en la unidad correspondiente de la plataforma eLearning.
www.learning.es
Unidad 2. Programacin Orientada a Objetos
Introduccin
El programador debe conocer cul es su situacin respecto a la mquina que va a programar y qu
personajes, junto con l, son importantes a la hora de desarrollar una aplicacin. Cada uno de estos
personajes tiene un punto de vista diferente que describimos a continuacin:
Desarrollador del lenguaje de programacin. Su conocimiento de la mquina es profundo debido a

que debe desarrollar la aplicacin que ayudar al programador a realizar su trabajo. En un principio
se desarrollaban los lenguajes de programacin utilizando el lenguaje de ensamble del
microprocesador. Esto dio lugar a lenguajes como C, Pascal, etc.
Posteriormente, estos lenguajes se han podido utilizar para el desarrollo de tecnologas de

programacin ms potentes como C++, y ste a su vez es el que se ha utilizado en el desarrollo de
Java. El lenguaje de programacin proporciona las herramientas necesarias (API, entorno de
desarrollo, etc.) al siguiente personaje: el programador de aplicaciones.
Programador de aplicaciones. Su conocimiento suele centrarse en el lenguaje de programacin que

utiliza para el desarrollo de sus aplicaciones. No necesita conocer la mquina tan en profundidad
como el desarrollador de lenguajes de programacin, sin embargo, ese conocimiento extra ayuda a
comprender lo que se est realizando y, por tanto, facilita el desarrollo de aplicaciones. Su funcin
principal es utilizar todas las herramientas que le ofrece un lenguaje de programacin para
desarrollar aplicaciones fciles de usar (usabilidad) destinadas al siguiente personaje: el usuario.
Usuario. Su conocimiento del ordenador suele ser escaso, por no decir nulo, y su funcin es la de
utilizar las aplicaciones que ha desarrollado el programador.
Un ejemplo puede aclarar todo lo expuesto anteriormente. Veamos cmo realiza el acceso a la hora
cada uno de estos personajes.
Desarrollador del lenguaje de programacin. Este personaje conoce la manera que se ha diseado
en la mquina para contabilizar el tiempo. El reloj de tiempo real (RTC) incorpora un contador dnde
se almacenan los milisegundos que han transcurrido desde el 1-1-1970 a las 00:00:00 hasta este
momento. Conocido el origen de coordenadas y los milisegundos que han transcurrido, se puede
obtener mediante la aplicacin de un algoritmo matemtico el da, mes y ao en el que nos
encontramos, y la hora con una precisin de milisegundos. Por tanto, el desarrollador de un lenguaje
de programacin, para acceder hasta la hora del sistema, tendra que acceder al dato almacenado
en el RTC mediante la lectura del puerto dnde est situado e implementar el algoritmo de
conversin, lo que requiere un conocimiento del funcionamiento de la mquina determinado.
Programador. Aprovechando que el desarrollador del lenguaje de programacin ha implementado el

cdigo de ms bajo nivel para acceder a la hora del sistema, puede ofrecer este cdigo al
programador para simplificarle la forma de acceso. Una parte fundamental de un lenguaje de
programacin es el API que ofrece al programador. En l se encuentra todo el cdigo que ha
desarrollado el desarrollador del lenguaje de programacin y que puede utilizar el programador en
sus aplicaciones. La evolucin de las tecnologas de programacin ha dado lugar a dos tipos de
lenguaje de programacin (y por tanto a dos tipos de API).
- API orientado a funciones.

- API orientado a objetos. Por ejemplo, el objeto Date es que se debe utilizar para acceder a la
hora del sistema.
Usuario. Simplemente visualizar la hora del sistema tal y como el programador haya realizado la
representacin en la aplicacin.
www.learning.es
En este tema aprenderemos los conceptos de la programacin orientada a objetos.
- El desarrollador de lenguajes de programacin debe pensar en facilitar al programador su
trabajo, el desarrollo de aplicaciones informticas, ofrecindole unas herramientas que le
ofrezcan:
Clases
Las diferentes tecnologas de programacin se diferencian en la manera que ofrecen de estructurar
los datos y el cdigo que forman una aplicacin.
A la hora de plantear el anlisis del problema que se quiere resolver por software, todas las
tecnologas han optado por dividir dicho problema en parte ms pequeas. La estrategia a seguir es
conseguir una estructura en la que cada una de esas partes realice una tarea nica e indivisible,
coordinadas por una parte principal que obtiene la informacin de lo que hay que hacer de su
interaccin con el usuario. En la actualidad esta interaccin se realiza a travs de un entorno grfico
y las rdenes se generan mediante eventos.
En los lenguajes procedimentales, orientados a funciones, la estructura se realiza tomando como

referencia el cdigo. Cada una de esas partes se denomina subrutina, procedimiento o funcin
dependiendo del lenguaje en el que nos encontremos.
En los lenguaje orientados a objetos, la estructura se realiza tomando como referencia los datos.
Cada una de esas partes se denomina objeto.
En Java una clase se suele representar con la siguiente estructura:
public class NombreClase{

// Definicin de propiedades --> Caractersticas del elemento que describimos con la clase.
// Definicin de los mtodos --> Comportamiento y funcionalidades del elemento.
}
Analizaremos algunos conceptos bsicos para poder comprender el concepto de propiedad

(variables), mtodos (funciones) y lgicas de funcionamiento.
En este primer ejemplo podemos observar que creamos una clase coche.
Las propiedades de la clase representan caractersticas del coche: estado, velocidad actual,
velocidad mxima,
Los mtodos representan acciones que podemos realizar sobre el coche: montar, bajar, salir,...
La lgica de funcionamiento se implementa en el cdigo de cada mtodo
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
public class Coche{
static boolean estado=false;
static int velocidad=0;
static int VMAXIMA=120;
public static void menu(){
System.out.println("1.- Montar en el coche");
System.out.println("2.- Comenzar");
System.out.println("3.- Parar");
System.out.println("4.- Salir del coche");
System.out.println("");
System.out.println("Introduzca una opcin");
www.learning.es
}
public static void montar(){
if (estado==false){
System.out.println("Ya ests encima del coche.");
estado=true;
}
else{
System.out.println("Ya estabas arriba, no intentes subir otra vez.");
}
menu();
}
public static void comenzar (){
if(estado==false){
System.out.println("Primero sube al coche");
}
else if (velocidad== VMAXIMA){
System.out.println("Ya no puedes acelerar ms");
}
else{
++velocidad;
System.out.println("Velocidad actual= "+velocidad);
}
menu();
}
public static void parar(){
if (velocidad==0){
System.out.println("Si ests parado porque frenas");
}
else{
System.out.println("El frenado se realiza de golpe");
velocidad=0;
}
menu();
public static void salirCoche(){
if(estado==false){
System.out.println ("No te has subido y ya te bajas");

}
else if(velocidad!=0){
System.out.println("Primero frena y luego baja");

}
else {
System.out.println("Acabas de bajar del coche.");

}
menu();
www.learning.es
public static void main(String args[])throws IOException{
BufferedReader i=new BufferedReader(new InputStreamReader(System.in));

String opcion;
menu();
do{
opcion=i.readLine();
try{
switch(Integer.parseInt(opcion)){
case 1: montar();
break;
case 2: comenzar();
break;
case 3:parar();
break;
case 4: salirCoche ();

System.exit(0);
default:System.out.println("No existe la opcin");
}
}
catch( NumberFormatException e){
System.out.println("La opcin debe ser un nmero");

}
}while (true);
Tipos de clases
abstract
Una clase abstract tiene al menos un mtodo abstracto. Una clase abstracta no se instancia, sino
que se utiliza como clase base para la herencia.
final
Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar
de una clase final. Por ejemplo, la clase Math es una clase final.
www.learning.es
public
Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son
accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros
paquetes, primero tienen que ser importadas.
synchronizable
Este modificador especifica que todos los mtodos definidos en la clase son sincronizados, es decir,
que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de
colocar los flags necesarios para evitarlo. Este mecanismo hace que desde threads diferentes se
puedan modificar las mismas variables sin que haya problemas de que se sobreescriban.
Variables de instancia
La declaracin de una variable dentro de la definicin de una clase por defecto es una variable de
instancia. Con esto queremos decir que todo objeto que instanciemos de esa clase contiene su
propia copia de dicha variable.
Se pueden acceder a las variables de instancia de un objeto de la siguiente manera:
Nombreobjeto.nombrevariabledeinstancia
Estas variables deben ser declaradas fuera de los mtodos y dentro de la clase, y son del tipo global
por lo que las pueden utilizar cualquier mtodo no esttico de esa clase, pero para acceder desde
mtodos estticos es necesario instanciar la clase.
Variables estticas
Si al definir una variable le anteponemos la palabra static conseguimos que todos los objetos de
dicha clase compartan dicha variable. Es decir existe una nica copia de dicha variable, por tanto, si
algn objeto modifica la variable, quedar modificada para todos los objetos.
Si queremos acceder a una variable de clase no es necesario instanciar ningn objeto de dicha clase,
basta con usar:
Nombredeclase.nombredevariableesttica
En este ejemplo definimos una variable esttica para la velocidad mxima a la que puede ir un
coche, accederemos al valor de la variable sin necesidad de crear una variable de instancia:
public class Coche{

static int VMAXIMA=120;//Velocidad mxima a la que podemos circular.
public class Conductor {
www.learning.es
public static void main(String args[]){
System.out.prinln(Coche.VMAXIMA);
}
Variables finales
En Java se usa la palabra clave final para indicar que una variable debe comportarse como si fuese
una constante. Por tanto, no se permitir su modificacin una vez que sea declarada e inicializada.
Poniendo la palabra final con una variable o clase esttica, se crean constantes de clase.
Si intentamos modificar el valor de la variable nos dar error.
En este ejemplo intentaremos modificar la velocidad mxima a la que puede ir un coche. Como la
variable que controla la velocidad mxima es final comprobaremos que nos saltar un error:
public class Coche{

static final int VMAXIMA=120;//Velocidad mxima a la que podemos circular.
public class Conductor {
Coche.VMAXIMA=180;
System.out.prinln(Coche.VMAXIMA);
}
Mtodos de clase
Los mtodos son funciones que pueden ser llamados dentro de la clase o por otras clases.
La implementacin siempre ser de dos partes: la declaracin y el cuerpo:
[ModificadoresAcceso] TipoRetorno nombreMtodo ([lista_de_argumentos]) [excepciones]{

CuerpodelMtodo
}
La lista de argumentos es opcional. Los parmetros o argumentos se usan para pasar informacin al
cuerpo del mtodo. Los parmetros se pararn a la hora de llamarlos.
El tipo de retorno es obligatorio e indica el tipo de dato que devuelve tras realizar su tarea. Si no
devuelve nada se indica mediante la palabra void. Lo recibe la aplicacin que realiz la llamada.
Para devolver un valor se utiliza la palabra clave return.
Si se declara un mtodo anteponiendo la palabra static, ste se convierte en un mtodo esttico o

de clase. Las caractersticas de estos mtodos son:
www.learning.es
Pueden ser invocados sin necesidad de que haya que instanciar ningn objeto de la clase.
NombreClase.nombreMtodo(...)
Los mtodos estticos slo tienen acceso a variables de clase o estticas; no tienen acceso a las
variables de instancia a no ser que se cree un objeto y se acceda a las variables de instancia a
travs de ese objeto.
Sobrecarga de mtodos o polimorfismo

En Java es posible definir dos o ms mtodos dentro de la misma clase que compartan el mismo
nombre pero las declaraciones de sus parmetros deben ser diferentes. A esto es a lo que se conoce
como Sobrecarga de Mtodos.
La Sobrecarga es uno de los procedimientos mediante el cual Java implementa el polimorfismo(en

programacin orientada a objetos es la capacidad que tienen los objetos de una clase de responder
al mismo mensaje o evento en funcin de los parmetros utilizados durante su invocacin).
En este ejemplo definimos una clase con 3 mtodos sobrecargados:

class Principal{
public void Metodo1()
{
System.out.println(Metodo sin Argumentos);
}
public void Metodo1(int edad) // Sobrecarga con un parmetro

{
System.out.print(Metodo con un Argumento:);
System.out.println( edad= +edad);
public void Metodo1(double edad, double ao, double mes) //Sobrecarga con tres
parmetros
{
System.out.print(Metodo con tres Argumentos:);
System.out.println( edad= +edad+ ao= + ao + mes= + mes
);
}
}
class Prueba{
public static void main (String [] var)

{
Principal objeto= new Principal(); //Se crea un Objeto de nombre Objeto para llamar a los Mtodos
Sobrecargados
objeto.Metodo1();
objeto.Metodo1a(30);
objeto.Metodo1(30.2,76.0,8.6);
}
}
Actividades
www.learning.es
Unidad 3 . Identificadores, palabras clave y
tipos
Introduccin
Al igual que el lenguaje natural que utilizamos para comunicarnos, ya sea de forma oral o por
escrito, cualquier lenguaje de programacin dispone de unos elementos y reglas que deben
conocerse a la hora de programar.
- Los elementos del lenguaje natural nos permiten designar cosas (nombres), expresar
cualidades de esas cosas (adjetivos), expresar acciones (verbos), etc.
- Las reglas sintcticas (estructura) y semnticas (significado) permiten el entendimiento entre
las partes que forman la comunicacin.
En los lenguajes de programacin tambin encontramos unas reglas sintcticas que debemos
respetar a la hora de confeccionar los programas y una semntica encargada de resolver el
problema que queremos programar.
Utilizar comentarios en el cdigo fuente

Comentarios en los programas
Un aspecto importante a la hora de confeccionar un programa es comentar lo ms detalladamente
posible lo que significa cada una de las rdenes que forman parte del programa, con el propsito de
poder recordar en un futuro la funcin que realiza cada una de ellas, y facilitar su estudio a personas
ajenas al programa.
Sintaxis.
En java hay tres tipos de comentarios:

Comentario Descripcin
//.......... Comentario para una sola lnea.
/* ........ */ Comentario de una o ms lneas
/** ........*/ Comentario de documentacin de una o ms lneas.
Los comentarios de documentacin, colocados inmediatamente antes de una declaracin de variable
o funcin, indican que ese comentario ha de ser colocado en la documentacin que se genera
automticamente cuando se usa la herramienta javadoc.
Identificadores
En todo lenguaje de programacin surge la necesidad de utilizar una serie de elementos que
debemos designar con algn nombre, por ejemplo:
Elemento Descripcin
Variables - Elementos utilizados para referenciar posiciones de memoria dnde podremos
almacenar datos necesarios para el programa.
Funciones - Elementos utilizados para referenciar posiciones de memoria dnde reside el
cdigo del programa.
Objetos - Elementos que encapsulan variables (propiedades) y funciones (mtodos) de
manera que resulta ms sencillo modelar los problemas que queremos resolver
simplificando el diseo de programas complejos.
etc. - Conforme avancemos iremos conociendo ms elementos de los lenguajes de
programacin.
www.learning.es
Los identificadores sirven para asignar nombre a los diferentes elementos que forman un programa:
variables, mtodos, clases, objetos, etc.; cualquier cosa que el programador necesite identificar y
que est contemplado por el lenguaje de programacin.
En la siguiente tabla se muestran las reglas sintcticas que debemos cumplir a la hora de elegir un
identificador:
Primer carcter Una letra, subrayado ( _ ) o el smbolo de dlar ($).
Siguientes caracteres Pueden ser letras, nmeros o smbolos.
Longitud No hay una longitud mxima establecida.
Maysculas / Minsculas Se distinguen las maysculas de las minsculas.
No se pueden usar Palabras clave.

Palabras reservadas.
Palabras reservadas
En la siguiente tabla tenemos las palabras claves proporcionadas por la documentacin de SUN.
abstract double Int static
Boolean else Interface super
Break extends Long switch
Byte final Native synchronized
Case finally New this
Catch float Null throw
Char for Package throws
Class goto * Private transient
Const * if Protected try
Continue implements Public void
Default import Return volatile
Do instanceof Short while
Convenios para asignar nombres de las clases, variables y mtodos.

Existe un convenio, no obligatorio, a la hora de nombrar las clases, las variables y mtodos. Es
recomendable seguirlo debido a que ayuda a dar claridad a los programas.
Clases e interfaces - Deberan ser un nombre o una concatenacin de ellos. (FacturaEnero)

- Poner en mayscula la primera letra de cada nombre utilizado.
Mtodos - Deberan ser verbos con nombres. (calcularImporte)

- Mismo regla que en clases pero poniendo con minscula la primera letra de
verbo. Se aconseja no usar el smbolo de subrayado.
www.learning.es
Constantes - En maysculas.
- Si se usan varias palabras se aconseja separarlas mediante el smbolo de
subrayado.
Variables - Deberan ser un nombre o una concatenacin de ellos. (cantidadVariable)

- El primero de ellos comenzara en minscula y el resto en maysculas.
Tipos de datos
Tipos primitivos
Java utiliza cuatro tipos de elementos para abarcar todos los posibles datos bsicos que podemos
necesitar en el desarrollo de una aplicacin.
Enteros, reales en coma flotante, booleanos y caracteres.
La siguiente tabla lista los tipos de datos primitivos soportados por Java, sus tamaos y su formato.
Tipo Tamao/Formato Descripcin
(enteros)
byte 8-bit en complemento a 2 Entero con un byte de longitud.
short 16-bit en complemento a 2 Entero corto (de 16 bits)
int 32-bit en complemento a 2 Entero.
long 64-bit en complemento a 2 Entero largo.
(reales en coma
flotante)
float 32-bit IEEE 754 Coma flotante de simple precisin.
double 64-bit IEEE 754 Coma flotante de doble precisin.
(Texto)
Un nico carcter o carcter aislado.

Carcter Unicode de 16 bits - Un valor tipo char debe ir entre comillas
char
sin signo. simples.
- No es un dato primitivo sino una clase pero

por su naturaleza lo incluimos como tipo de
dato.
Cadena de caracteres - Se utiliza para representar secuencias de
String
codificados en Unicode. caracteres y suele traducirse como cadena.
- Un dato de este tipo se delimita entre
comillas dobles.
"Nombre \t Pepe"
(Lgicos)
boolean true o false Un valor booleano (true or false).
www.learning.es
Variables
En programacin, las variables son estructuras de datos que, como su nombre indica, pueden
cambiar de contenido a lo largo de la ejecucin de un programa. Hay varios tipos de variables que
requieren distintas cantidades de memoria para guardar datos.
Siempre las variables tenemos que declararlas antes de usarlas, esta declaracin consiste en una
sentencia en la que figura el tipo de dato y el nombre que asignamos a la variable. Despus de
declararla ya podemos asignarle un valor.
Los tres tipos de variable que podemos utilizar en java son locales, de instancia y de clase.
Variables de instancia: Guardan atributos de un objeto.
Variables de clase: Son muy parecidos a las variables de instancia, con la excepcin de que los
valores que guardan son los mismos para todos los objetos de una determinada clase. En el
siguiente ejemplo, VMAXIMA es una variable de clase y Vactual es una variable de instancia.
VMAXIMA guarda el mismo valor para todos los objetos de la clase Coches, pero la Velocidad actual
de cada coche puede ser diferente
class Coches{
static final int VMAXIMA=120;
int Vactual;
//...
}
Variables locales: Se utilizan dentro de los mtodos. En el siguiente ejemplo Vactual es una variable
local al mtodo mostrarVelocidad en la que guardamos la velocidad actual a la que circula un coche.
Una variable local existe desde el momento de su definicin hasta el final del bloque en el que se
encuentra.
public int mostrarVelocidad(){

int Vactual=velocidad*12;
return Vactual;
}
En el lenguaje Java, las variables locales se declaran en el momento en el que son necesarias. Es
una buena costumbre inicializar las variables en el momento en el que son declaradas.
Operadores
Aritmticos (Suma, resta, multiplicacin, divisin, resto, incremento y decremento).
En la siguiente tabla tenemos las operaciones aritmticas que podemos realizar entre dos
operadores.
Actan sobre enteros y nmeros en coma flotante.
www.learning.es
El operador + tambin se utiliza para concatenar cadenas (strings).
En la siguiente tabla tenemos las operaciones aritmticas sobre un solo operando.
Veamos algunos ejemplos que aclaren estos conceptos:
public class Ejoperadores{

public static void main(String args[])
{
int b=2;
int s=5;
int div1=s/b; // Al convertirlos los operandos en double estas operaciones
tienen prdida
int resto1=s%b; //de precisin, por tanto, obtenemos errores de
compilacin.
double div2=s/b; // Sale mal. Si queremos que salga bien,

//los v1erandos deben ser tipo float o double.
double resto2=s%b;
System.out.println("El valor de "+b+"+"+s+"="+(b+s),20,50);

System.out.println("El valor de "+b+"-"+s+"="+(b-s),20,70);
System.out.println("El valor de "+s+"/"+b+"="+div1,20,90);
System.out.println("El valor de "+s+"%"+b+"="+resto1,20,110);
System.out.println("El valor de "+s+"/"+b+"="+div2,20,130);
System.out.println("El valor de "+s+"%"+b+"="+resto2,20,150);
System.out.println("El valor de "+b+"*"+s+"="+(b*s),20,170);
//Con divisiones es necesario que tanto el resultado como los v1erandos sean datos tipo double o
float
//con el prposito de no obtener resultados errneos
}
}
Operadores relacionales
Operadores condicionales
www.learning.es
Operadores a nivel de bit
Es interesante observar que la funcin AND a nivel de bits es igual que el operador condicional &. La
diferencia est en los tipos de datos con los que se usa (Sobrecarga de operadores).
La funcin AND se usa con datos numricos.
El operador condicional se usa sobre booleanos.
Veamos algunos ejemplos que aclaren estos conceptos:
Definimos dos datos tipos short y realizamos operaciones lgicas a nivel de bit con ellos. Tambin se
realizan diferentes desplazamientos sobre uno de los datos.
public class EjemploOperadores2
{
{
byte b1=127;
byte b2=1;
int i=3;
System.out.println("El valor de "+b1+"&"+b2+" es "+(b1&b2),20,50);
System.out.println("El valor de "+b1+"|"+b2+" es "+(b1|b2),20,70);
System.out.println("El valor de "+b1+"^"+b2+" es "+(b1^b2),20,90);
System.out.println("El valor de ~"+b1+" es "+(~b1),20,110);
System.out.println("El valor de "+b1+"<<"+i+" es "+(b1<<i),20,130);
System.out.println("El valor de "+b1+">>"+i+" es "+(b1>>i),20,150);
System.out.println("El valor de "+b1+">>>"+i+" es "+(b1>>>i),20,170);
}
}
Imprimir en pantalla el cdigo binario de un dato tipo int. Observar que el cdigo sale al revs.
Modificar el cdigo para que salga bien.
public class EjemploOperadores3

{
{
int i=15;
int k=1;
int s=320;
for (int j=0;j<32;++j){
www.learning.es
System.out.println(""+((i>>j)&k),(20+s),50);
s=s-10;
}
}
}
Operadores de asignacin
Una forma de ahorrar tiempo a la hora de escribir expresiones pero que muchas veces lan las cosas
innecesariamente.
Operador ternario if-then-else

Sintaxis:
Expresin ? sentencia 1 : sentencia 2
Si la expresin devuelve como resultado true entonces se ejecuta la sentencia 1, en caso contrario,
se ejecuta la sentencia 2.
Precedencia entre operadores

El orden de precedencia segn SUN se refleja en la siguiente tabla (de ms prioritario a menos).
www.learning.es
Ver Video: Casting o Conversin entre tipos de datos, en la
Unidad 3,en el Mdulo 2, en la plataforma elearning
Laboratorio 1: Definiendo tipos de datos
Objetivo
Comprender el funcionamiento de los tipos primitivos de java.
Enunciado
Crear una clase definir dos variables, la primera ser float y la segunda double. Imprimir el
resultado de las dos variables.
Solucin
public class Ejemplo
{

{
float flt=253.7F;
double doub=234.56e+34;
System.out.println("El valor de f es "+flt);

System.out.println("El valor de d es "+doub);
}
}
Laboratorio 2: Definiendo tipos de datos II
Objetivo
Enunciado
Imprimir el ascii de los 256 primeros caracteres.
Solucin

{
{
System.out.println("Decimal\t\t\t\tCaracter");
System.out.println("-------------------------------------");
for (int i=0; i<256; ++i){
www.learning.es
System.out.println(" "+i+" \t\t\t\t "+(char)i);
}
}
Laboratorio 3: Definiendo tipos de datos III
Objetivo
Enunciado
Declarar dos variables de tipo boolean e imprimir el resultado de ambas variables.
Solucin

{
{
boolean b1=true;
boolean b2=false;
if(b1){
System.out.println("b1 es "+b1);
if(!b2){
System.out.println("b2 es "+b2);
Actividades
www.learning.es
Unidad 4. Expresiones y control de flujo
Introduccin
En la siguiente tabla se resumen las sentencias que proporciona Java para controlar el flujo de un
programa:
Tipos Sentencias
De decisin. if-else, switch-case
Bucles for, while, do-while
Excepciones try-catch-finally, throw
Varios break, continue, label: , return
if-else
Permite seleccionar la ejecucin de distintos fragmentos de cdigo dependiendo del resultado de la

valoracin de una expresin booleana.
Su sintaxis es la siguiente:
if (expresion_booleana) { // La expresin booleana expresa condiciones

...
// cdigo que se ejecuta si la expresin devuelve true
...
} else {
...
// cdigo que se ejecuta si la expresin devuelve false
...
}
El uso de else es opcional.

La expresin booleana puede contener operadores relacionales para encadenar condiciones.
Ejemplo: Detectar si este es par o impar
public class MostrarPares

{

{
int dato=13;
if (dato%2==0){
System.out.println("El dato "+dato+" es par");
}
else{
System.out.println("El dato "+dato+" es impar");
}
}
}
www.learning.es
switch-case
Se utiliza cuando se quieren analizar muchas posibilidades de una nica variable o expresin.
Su sintaxis es la siguiente:
switch (expresin) {
case valor1: sentencias1;

break;
break;
break;
break;
break;
default: sentencias_por_defecto
break;
}
La expresin puede devolver cualquier tipo bsico, y cada uno de los valores especificados en las
sentencias case debe ser un tipo compatible.
La sentencia default es opcional y se ejecutar en todos los casos en el que el valor devuelto por
expresin no coincida con los especificados en los case.
La sentencia break (sin etiqueta) hace que se salga del dominio de la sentencia switch. Con ello se
evita que se valoren todas las opciones que quedan una vez que se ha encontrado la correcta. Es
opcional. Los string no pueden analizarse directamente con switch-case
Ejemplo que nos devuelve el mes dependiendo del valor de un entero
public class MostrarMes {

public static void main(String[] args) {
int mes = 6;
switch (mes) {
case 1: System.out.println("Enero"); break;
case 2: System.out.println("Febrero"); break;
case 3: System.out.println("Marzo"); break;
case 4: System.out.println("Abril"); break;
case 5: System.out.println("Mayo"); break;
case 6: System.out.println("Junio"); break;
case 7: System.out.println("Julio"); break;
case 8: System.out.println("Agosto"); break;
case 9: System.out.println("Septiembre"); break;
case 10: System.out.println("Octubre"); break;
case 11: System.out.println("Noviembre"); break;
case 12: System.out.println("Diciembre"); break;
}
}
}
www.learning.es
for
Este bucle permite establecer la inicializacin de la variable que controla el bucle, su variacin y la
condicin de permanencia, en la propia definicin del for.
Su sintaxis:
for (inicializacin; condicin de permanencia; variacin){
...
sentencias
...
}
La inicializacin hace referencia a la variable de control del bucle.
La condicin de permanencia es una expresin booleana donde debe encontrarse la variable de

control.
La actualizacin hace referencia a la variable de control.
Ejemplo: Imprimir en un bucle for los 10 primeros nmeros naturales.

public class Ejemplo {
public static void main(String[] args) throws IOException{
for (short i=0; i<=10; ++i){
System.out.println("i vale "+i);
}
}
while
Ejecuta repetidamente un conjunto de sentencias mientras una expresin booleana sea verdadera.
Su sintaxis es:
while (Expresin_booleana) { //Condicin de permanencia
...
sentencias;
...
}
Dentro del bucle se deber alterar la variable que controla el bucle de lo contrario nunca se dejar
de cumplir la condicin.
Se puede realizar un bucle infinito pero se debe incluir la salida dentro del bucle.
www.learning.es
Ejercicio: Recoger un nmero por teclado e imprimir todos sus divisores
import java.io.*;
String numero;
BufferedReader teclado=new BufferedReader(new

InputStreamReader(System.in));
System.out.println("Introduzca el nmero a analizar:");
numero=teclado.readLine();
int num=Integer.parseInt(numero);
int i=Integer.parseInt(numero);
while(i>0){
if (num%i==0){
System.out.println(i+" es divisor de "+numero);
--i;
}
System.out.println("Pulse cualquier tecla para salir...");

teclado.read();
}
}
do-while
Igual que el while, pero las sentencias se ejecutan al menos una vez antes de valorar las expresin.
Su sintaxis:
do {
...
sentencias;
www.learning.es
...
} while (Expresin_booleana);
EJEMPLO: Recoger un nmero por teclado e imprimir todos sus divisores.

Podremos seguir mientras pulsemos la letra s.
import java.io.*;

String numero;
String letra;
BufferedReader teclado=new BufferedReader(new

do{
System.out.println("Introduzca nmero:");
int i=Integer.parseInt(numero);
while(i>0){
if (num%i==0){
System.out.println(i+" es divisor de "+numero);
--i;
}
System.out.println("Pulse 's' para continuar...");
letra=teclado.readLine();
System.out.println(letra);
}while (letra.equals("s"));
www.learning.es
}
}
CONTINUE
Permite volver al inicio del bucle para comenzar una nueva iteracin sin que la iteracin actual se
lleve a cabo del todo.
Ejemplo
bf: for ( int i=1; i <5; i++ ) {

for ( int j=1; j<5; j++ ) {
if ( j>i ) {
System.out.println(" ");
continue bf;
}
System.out.print( " " + (i*j) );
}
}
}
}
BREAK
Permite salir del bucle aunque la condicin de permanencia todava se cumpla.
Ejemplo
bf: for( int i=1; i<10; i++ ){

System.out.print(" i="+i);
for( int j=1; j<10; j++ ){
if ( j==5 )
break bf; //Con break salimos de los dos bucles
System.out.print(" j="+j);
}
System.out.print("Este mensaje nunca lo imprimir");
}
}
}
return
Se utiliza en las funciones cuando queremos retornar al cdigo desde el que se llam a la funcin.
En el retorno, se puede devolver algn valor.
www.learning.es
Cuando un mtodo se declara como void se debe usar la forma de return sin indicarle ningn valor
Esto se hace para no ejecutar todo el cdigo del programa:
Ejemplo:
void metodo1(){
if ( condicion == true )
return;
}
Laboratorio: Uso del bucle While

Objetivo
Aprender a utilizar el bucle While de Java
Enunciado
Abrir un proyecto de tipo aplicacin de Java.
Crear un algoritmo que imprima los primos entre 1 y 50.
Solucin
public class Ejercicio {

int n, d;
for(n=1; n < 50; n += 2){

d=3;
while(n % d != 0)
d = d + 2;
if(d == n) System.out.print(n + ", ");
}
System.out.println();
}
}
Ver Video: Sentencias Switch, en la Unidad 4,

en el Mdulo 2, en la plataforma elearning
Ver Video: Sentencias Break, en la Unidad 4,

Actividades
www.learning.es
Unidad 5. Arrays
Introduccin
Un array es una coleccin de elementos del mismo tipo.
Los elementos que puede contener un array pueden ser datos de tipos primitivos u objetos.
Creacin de un array
Un array es una coleccin de elementos del mismo tipo. En principio crearemos arrays de datos de
tipos primitivos, pero se pueden crear arrays de objetos.
Antes de utilizar un array hay que declararlo. En la declaracin debe especificarse el nombre del
array y el tipo de datos que se va a almacenar en l.
Para crear arrays en Java hay dos mtodos bsicos:

int numeros[] = new int[20]; // Define un array de 20 enteros pero sin valores (vaco).
int numeros[]={0,1,2,3,4,5,6,7,8,9,10,11}//Define un array de 12 elementos y los inicializa.
De alguna forma hay que especificar el tamao del array.
Ejemplo en el que definimos una serie de arrays e imprimimos sus valores.

{
public static void main(String args[]) throws IOException

{
int enteros[]=new int[10];

char vocales[]={'a','e','i','o','u'};
String saludos[]={"hola","hello"};
for (int i=0;i<enteros.length;++i){
enteros[i]=i;
}
System.out.println(saludos[0]);
System.out.print("Los nmeros bsicos son: ");
System.out.print(enteros[i]);
System.out.print("Las vocales son: ");
for (int i=0;i<vocales.length;++i){
www.learning.es
System.out.print(vocales[i]);
}
}
}
Ejemplo en el que definimos una serie de arrays e imprimimos sus valores, al no indicarle un
tamao el compilador nos avisar de ello.

{
{
int enteros[]=new int[];
String saludos[]={"hola","hello"};
enteros[i]=i;
}
}
}
}
}
Los arrays en Java no se pueden redimensionar de forma dinmica.

En este ejemplo comprobamos como el compilador nos avisara del error.
Java dispone de las colecciones para redimensionar de forma dinmica.

{
{
int enteros[]=new int[10];

String saludos[]={"hola","adios"};
enteros[10]=10;
enteros[i]=i;
www.learning.es
}
}
}
}
Tambin se pueden crear arrays multidimensionales (arrays de arrays).

int valores[][]=new int[10][5];
int valores[][]={{1,2,3},{4,5,6},{7,8,9}}
Se puede observar el efecto de intentar acceder a elementos fuera de los lmites de un array.
Si declaramos un array de dos dimensiones, no es necesario indicar el tamao de la dimensin

secundaria a la hora de la declaracin del array, sino que puede declararse posteriormente el
tamao de cada uno de los subarrays.
Todos los arrays en Java tienen una funcin miembro: length(), que se puede utilizar para conocer
la longitud del array.
int valores[][] = new int[5][2];
valores.length;
Nos dar 5
valores [0].length;
Nos dar 2
Actividades
www.learning.es
Unidad 6. Diseo de clases
Introduccin
Para poder disear bien un conjunto de clase debemos tener en cuenta los siguientes conceptos:
Un API donde el programador encuentre ya desarrolladas unas funcionalidades bsicas que podr
utilizar en sus aplicaciones.
Un kit de desarrollo donde se encuentren el compilador, el depurador, el intrprete si es necesario y

dems herramientas que permitan la ejecucin de las aplicaciones desarrolladas. Todo este kit
puede estar integrado en un entorno de desarrollo.
Una tecnologa que permita al programador estructurar su aplicacin de la manera ms sencilla

posible de tal forma que su anlisis e implementacin alcancen un nivel de abstraccin tal que su
desarrollo sea lo ms ordenado y claro posible.
Constructores
Es un tipo especfico de mtodo que siempre tiene el mismo nombre de la clase y se utiliza para
construir objetos de esa clase.
No tiene tipo de dato especfico de retorno, ni siquiera void. Esto se debe a que el tipo que debe
devolver un constructor de clase es el propio tipo de clase.
Los constructores pueden sobrecargarse.
Si el programador no declara un constructor el sistema siempre crea un constructor por defecto.
Para inicializar un objeto basta con llamar a su constructor despus de la palabra reservada new y
asignarlo a una referencia declarada previamente. Un constructor es un mtodo que se ejecuta cada
vez que se crea un objeto, el propsito de este procedimiento es el de inicializar los datos del
objeto. El nombre del constructor siempre es igual al nombre de la clase.
Declaracin
class facturar {
int total, importe;
facturar () { total=0; importe=0; } // el constructor
}
Constructor con parmetros

class facturar {
int total, importe;
facturar (String cliente) { total=0; importe=0; }
}
Varios constructores
class facturar {
int total, importe;
facturar () { total=0; importe=0; } // el constructor
facturar (String cliente) { total=0; importe=0; }
}
www.learning.es
Herencia
Java permite el empleo de la herencia, caracterstica muy potente que permite definir una clase
tomando como base a otra clase ya existente. Esto es una de las bases de la reutilizacin de cdigo
y especializacin.
Dentro de un mismo tipo de objetos (por ejemplo, los empleados), existe una variedad de modelos
(administrativos, programador, gerente, etc) que dificulta la definicin de la clase genrica. Por
ejemplo, si defino los mtodos incentivos() y vacacionesNavidad(), estos mtodos slo se podrn
aplicar a aquellos empleados que tengan incentivos y vacaciones en navidad.
Para resolver este tipo de problemas, la programacin orientada a objetos hace uso de la herencia.
La herencia consiste en definir una clase a partir de otra ya existente. De esta forma podemos
definir un empleado genrico y mediante herencia crear otras clases ms especializadas que
respondan a las necesidades de cada tipo de empleado. La profundidad en la jerarqua de clases no
tiene lmite.
La herencia se consigue mediante el uso de extends.

Una clase slo puede heredar de una nica superclase directamente (no existe la herencia mltiple).
Los interfaces (estudiados ms adelante) permitirn simular la herencia mltiple.
public class Empleado {

String rut;
String nombre;
boolean perfil;
String colorperfil;
Empleado()
{
}
Empleado(String nombre){
this.nombre = nombre;
}
public String getNombre()
{
return this.nombre;
}
public void setNombre(String nombre)
{
this.nombre = nombre;
}
}
public class Programador extends Empleado{

String apellido;
public Programador() {
super();
}
public Programador(String nombre)
{
super(nombre);
}
void setApellido(String apellido) {
this.apellido = apellido;
}
public String getNombre() {
www.learning.es
return this.nombre+" "+this.apellido;
}
public static void main (String args[]) {
Programador Programador = new Programador();
Programador.setNombre("Pepe");
Programador.setApellido("Gmez");
Programador ProgramadorDos = new Programador("Pepe");
ProgramadorDos.setApellido("Pillos");
System.out.println("Programador 1 ->\t"+Programador.getNombre());
System.out.println("Programador 2 ->\t"+ProgramadorDos.getNombre());
}}
Variables y mtodos en las subclases

Las subclases heredan el estado (propiedades) y el comportamiento (mtodos) de la superclase.
Sin embargo, las subclases no estn limitadas al estado y comportamiento de la superclases. Las
subclases pueden aadir variables y mtodos que las diferenciaran de las otras subclases.
Adems, las subclases pueden sobrescribir los mtodos que heredan de la superclases, si lo
necesitan, para especializar ms su funcionalidad. Para sobrescribir un mtodo basta con definir en
la subclase uno que se llame igual, tenga el mismo tipo de retorno y la misma lista de parmetros.
Clases y Mtodos finales

Las clases que son declaradas como finales no pueden ser derivadas.
Los mtodos que son declarados como finales, no pueden ser sobrescritos por las subclases.
Clases abstractas
Una clase abstracta es una clase que ha dejado alguno de sus mtodos definido pero no lo ha
implementado. La definicin de un mtodo consiste en especificar su nombre, el tipo de retorno y
los argumentos de entrada.
public abstract class Empleado{

// variables que heredarn las subclases.
//Mtodos comunes que s se implementan en la clase abstracta.
//Mtodos abstractos que debern implementar las subclases.
// Estamos obligando a que todos los empleados
// tengan vacaciones y pagas
public abstract void Vacaciones();
public abstract void pagas();
}
Otros mtodos si pueden estar implementados.

Si una clase tiene un mtodo abstracto, ella tambin tiene que ser declarada abstracta.
De una clase abstracta no se pueden crear objetos porque el compilador no sabra qu hacer con los
mtodos que no estn implementados. Por eso no tiene sentido el constructor.
Las clases abstractas no pueden tener mtodos estticos porque hemos visto que estos quedan tal
cual en el proceso de herencia y no son sobrescritos. El compilador no da error.
No tiene sentido declarar variables privadas en una clase abstracta porque no se podrn usar nunca.
www.learning.es
Paquetes
Cuando se necesita establecer seguridad, o simplemente cuando el nmero de clases que aparecen
es muy grande, resulta necesario organizarlas de alguna manera que no sea el puro azar.
Java utiliza para ello los paquetes. Un paquete es un conjunto de clases e interfaces relacionados
que proporcionan proteccin en el acceso y gestin de nombres.
Las clases se agrupan en paquetes por varios motivos:
Los programadores pueden determinar fcilmente que clases e interfaces estn relacionados.
Se facilita la bsqueda de una clase determinada.
Se evitan conflictos con los nombres de las clases.
Se pueden establecer restricciones de seguridad
Sintaxis
Para decirle al compilador que una clase o un interface pertenece a un paquete en concreto, basta
con indicarlo al comienzo mediante la sentencia package.
package Empleados
En este ejemplo agrupamos las clases empleado y programador en un paquete llamado empleados.
package empleado;
public class Empleado { ..
}
package empleado;
public class Programador extends Empleado{
}
Modificadores de acceso
Mtodo Propiedad Clase
- Para poder invocar al - Cada objeto creado de
de instancia (no
mtodo es necesario crear una clase tiene su propia - No tiene sentido.
static).
objeto. copia de la propiedad.
- Todos los objetos
- Se puede invocar al creados a partir de la
static mtodo a travs del nombre clase comparten las - No se puede usar.
de la clase. propiedades declaradas
as.
- El mtodo puede ser sobre - Se puede extender
- La variable puede
no final escrito en el proceso de por herencia dicha
modificar su valor.
herencia. clase.
- El mtodo no puede ser - La variable es una - La clase no se puede
final sobrescrito en el proceso de constante y su valor no extender ms por
herencia. puede ser modificado. herencia.
- El acceso al mtodo slo - El acceso a la variable
private se puede realizar desde la slo se puede realizar - No se puede usar.
propia clase. desde la propia clase.
- El acceso al mtodo slo - El acceso a la propiedad
se puede realizar desde las slo se puede realizar
protected - No se puede usar.
clases que se encuentren en desde las clases que se
el paquete. encuentre en el paquete.
www.learning.es
- El acceso al mtodo se - El acceso a la propiedad
puede realizar desde se puede realizar desde
cualquier otra clase cualquier otra clase - El que debe aplicarse
public
independientemente del independientemente del sobre la clase.
paquete en el que se paquete en el que se
encuentre. encuentre.
- Este mtodo no tiene - Se aplica sobre las
cuerpo y deber ser clases que tienen
abstract - No est permitido.
implementado en las alguno de sus
subclases. miembros abstractos.
Interfaces
Un interface declara lo mtodos de una clase sin implementarlos (nombres de mtodos, listas de
argumentos, tipos de retorno) los cuales sern implementados por otra clase.
La diferencia entre una interface y una clase abstracta es que la interface es simplemente una lista
de mtodos no implementados, adems puede incluir la declaracin de constantes. Una clase
abstracta puede incluir mtodos implementados y no implementados o abstractos, miembros dato
constantes y otros no constantes.
Una clase solamente puede derivar extends de una clase base, pero puede implementar varios
interfaces. Los nombres de los interfaces se colocan separados por una coma despus de la palabra
reservada implements.
Creacin interface
En este ejemplo creamos una interface con los mtodos que queremos que se implementen.
interface InterfazCoche{
public void montar();
public void comenzar();
public void bajar();
public int verVMaxima();
public void cambiarVMaxima(int VMAXIMA);
public void bajar();
public void usar() throws IOException;
public void menu();
}
Implementacin de la interface
Si una clase quiere implementar un interface debe usar la palabra clave implements. Si queremos
heredar e implementar al mismo tiempo, debemos colocar primero extends seguido del nombre de
la clase y a continuacin implements seguido del nombre de la clase.
Sintaxis:
public class NombreClase extends SuperClase implements Interfaz1, Interfaz2,... {

//Cuerpo de la clase
}
Ejemplo:
public abstract class Conductor implements InterfazCoches{
..
}
Actividades
www.learning.es
Unidad 7. Caractersticas Avanzadas de
Clases
Introduccin
En java podemos realizar operaciones muy complejas con clases. Podremos realizar acciones ms
all de los conceptos bsicos en el diseo de las clases.
this y super
Java incluye un valor de referencia especial llamado this, que se utiliza dentro de cualquier mtodo
para referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el
mtodo actual. Se puede utilizar this siempre que se requiera una referencia a un objeto del tipo de
una clase actual. Si hay dos objetos que utilicen el mismo cdigo, seleccionados a travs de otras
instancias, cada uno tiene su propio valor nico de this.
Un ejemplo muy habitual es construir un objeto y que este llame a otro constructor.
Facturar() {
this( 23, Pepe );
}
La palabra reservada super sirve para indicar que una variable o un mtodo es de la superclase. Es
decir, que si queremos hacer referencia a una variable o mtodo de la clase que heredamos
utilizaremos super.
En el siguiente ejemplo vemos como podemos imprimir el valor de la edad del padre y el valor de la
edad del hijo:
class Clase1 {
int edad;
void asignarValor() {
edad = 35;
}
}
class Clase2 extends Clase1 {

int edad;
void asignarValor() {
edad = 5;
super.asignarValor();
System.out.println("La variable de la clase actual es " + edad);

System.out.println("LEl valor de la variable de la superclase es: " + super.edad);
}
}
En el siguiente ejemplo tambin podemos apreciar como llamamos al constructor de la superclase B
imprimiendo en pantalla el valor 43.
class A {
public String toString() {
www.learning.es
return "4";
}
}
class B extends A {
public String toString() {
return super.toString() + "3";
}
}
public class Prueba {
System.out.println(new B());
}
}
Destruccin de objetos
La destruccin de los objetos
La destruccin de un objeto se le denomina a la accin que realizamos al destruir un objeto que se
deja de utilizar, siempre que un objeto se deja de utilizar el espacio de memoria que utiliza se debe
liberar.
En aplicaciones Java se puede destruir un objeto de forma automtica o bien personalizada.
Destruccin automtica
En el lenguaje Java no es necesario liberar la memoria reservada, el recolector de basura (garbage
collector) se encarga de hacerlo por nosotros, liberando al programador de una de las tareas que
ms quebraderos de cabeza le producen, olvidarse de liberar la memoria reservada.
El recolector de basura se encargar de liberar una zona de memoria dinmica que haba sido
reservada mediante el operador new, cuando el objeto ya no va a ser utilizado ms durante el
programa.
El sistema de recogida de basura se ejecuta peridicamente, buscando objetos que ya no estn

referenciados.
Podramos forzar la ejecucin del recolector de basura para decidir nosotros que lo haga en un
determinado momento mediante el mtodo gc de la clase System.
System.gc();
Destruccin personalizada
El mtodo finalize es llamado justo antes que el Garbage Collector libere la memoria. En este
instante se puede aprovechar para realizar otras operaciones.
class Prueba{
Prueba() { // Constructor
// Reserva del recurso no Java o recurso compartido
protected void finalize() {
// Liberacin del recurso no Java o recurso compartido
www.learning.es
}
}
El intrprete de Java llama al mtodo finalize(), si existe cuando vaya a reclamar el espacio de ese
objeto, mediante la recogida de basura.
Debe observarse que el mtodo finalize() es de tipo protected void y por lo tanto deber siempre lo
debemos sobrescribir de la misma manera.
Crear y usar tipos enumerados

Los tipos enumerados se incorporaron con la versin 1.5 de java y sirven para restringir la seleccin
de valores a algunos previamente definidos.
Un ejemplo sera una aplicacin java donde queramos crear jugadores de ftbol. Si queremos que
las posiciones de los jugadores sean exclusivamente: PORTERO, DEFENSA, CENTROCAMPISTA y
DELANTERO podramos crear un enumerado como el siguiente:
import java.util.*;
class Enumerados
{
static public enum posicion{ PORTERO,DEFENSA, CENTROCAMPISTA,DELANTERO };
public static void main(String [] params)
{
posicion actual = posicion.DEFENSA;
System.out.println("La posicion es: " + actual );
}
}
Importaciones estticas
Las importaciones estticas nos permiten llamar a un mtodo o propiedad esttica sin necesidad de
hacer referencia al nombre de su clase.
Para acceder a atributos de clase es necesario hacer referencia a la clase en la que se definen. La
importacin esttica ha de usarse cuando sea necesario acceder frecuentemente a atributos de clase
(estticos).
Sintaxis
Un solo mtodo o propiedad
import static paquete. NombreClase.metodo_o_propiedad_static;
Todos los elementos estticos de la clase
import static paquete.NombreClase.*;
Ejemplo
El siguiente ejemplo podemos apreciar como no es necesario acceder a las variables estticas
predicindolas del nombre de la clase.
Supongamos que tenemos una clase llamada Jugador con tres propiedades: nombre, edad y
posicin.
package ejemplos;
class Jugador{
public static String nombre = "Casillas";
public static int edad= 29;
www.learning.es
public static String posicion= "PORTERO";
}
Ahora crearemos una clase llamada impresin que nos permita acceder a los miembros estticos de
esta clase.
import static ejemplos.Jugador.*;
public class Impresion{
public Impresion(){
nombre+=" ,Iker";
System.out.println(nombre);
}

new Impresion();
}
}
No ha sido necesario acceder a la propiedad nombre anteponiendo el nombre de la clase:

Jugador.nombre.
Laboratorio: Clase Objeto cadena
Objetivos:
Diseo de clases eficiente.
Enunciado:
Realizar una clase que contenga algunos mtodos de la clase String, pero esta vez debemos
tratarla como un objeto desde otra clase externa.
Los mtodos que tendr sern convertirMayusculas, convertirMinusculas, longitud, isNumeric.
Solucin:
CLASE UTILIZARCADENA
import java.io.*;
public class UtilizarCadena

{
{
String cad="123a";
CadenaObjeto c=new CadenaObjeto("Hola Mafsundo");
if (c.isNumeric(cad.toCharArray())==true)
System.out.println("Es un Numero");
else
System.out.println("NO SON Numeros");
www.learning.es
System.out.println(c.convertirMayusculas());
System.out.println(c.convertirMinusculas());
}
}
CLASE CADENAOBJETO
import java.lang.*;
public class CadenaObjeto

{
public String palabra;
public CadenaObjeto(String palabra)

{
this.palabra=palabra;
}
public static void menu()

{
System.out.println("1.-Convertir a Mayusculas");
System.out.println("2.-Longitud");
System.out.println("3.-Convertir a Minusculas");
System.out.println("4.-Comprobar si son numeros");
System.out.println("5.-Salir");
}
public String convertirMayusculas()

{
return this.palabra.toUpperCase();
}
public String convertirMinusculas()

{
return this.palabra.toLowerCase();
}
public int longitud()

{
return this.palabra.length();
}
public static boolean isNumeric(char letras[])

{
int num;
try
{
for (int i=0;i<letras.length;i++)
{
num=Integer.parseInt(String.valueOf(letras[i]));
}
return true;
}
catch (NumberFormatException e)
{
www.learning.es
return false;
}
}
}
Ver Video: Organizando de Clases, en la Unidad 7,

Actividades
www.learning.es
Unidad 8. Excepciones y aserciones
Introduccin
Java implementa excepciones y aserciones con el propsito de conseguir cdigo robusto.
En esta unidad veremos los pasos necesarios para poder controlar los posibles errores en nuestra
aplicacin en tiempo de diseo y/o programacin.
try-catch-finally
Cuando ocurre un error en un programa, el cdigo que encuentra el error lanza una excepcin que
se puede capturar desde la aplicacin con el propsito de recuperarse de ella.
Existen dos modos de tratar las excepciones:
No tratarlas de forma detallada dejando a la mquina virtual de Java que realice la tarea que tenga
programada por defecto. Esto se realiza mediante la clusula throws.
Tratamiento de la excepcin
No tratando la excepcin
public static void main(String args[]) throws IOException,... {

Cdigo que puede lanzar las excepciones especificadas;
}
Tratando la excepcin
public static void main(String args[]) {
try{
Cdigo que puede lanzar las excepciones
}
catch( Excepcin esperada) {
}
catch(Otra Excepcion esperada){
}
finally{
Cdigo que se ejecuta siempre, aunque se lance la excepcin
}
}
La sentencia finally es opcional.
Ejemplo de excepcin con la sentencia Finally:

public class Principal {
try{
int matriz[]={1,2,3};
for (int i=0; i<4;i++){

System.out.println("Salida"+ matriz[i]);
}
System.out.println("Despues del for");
System.exit(0);
}
www.learning.es
catch(ArrayIndexOutOfBoundsException e)
//Asigno la excepcion a la variable e
{
//Cuando se produzca la excepcion hace esto
System.out.println("No hay ms elementos");
}
finally{
System.out.println("El Finally se ejecuta siempre");
}
}
Se pueden asociar varios catch con un nico try para los casos en el que un mismo cdigo pueda
lanzar varias excepciones.
Necesidad de conocer las excepciones asociadas a cada clase que utilicemos. Todas las excepciones
que se pueden generar, salvo las del paquete java.lang, sern avisadas por el compilador
Creacin de excepcin propia:

En Java podemos crear una excepcin propia creando una clase que extienda de la clase Exception.
En este ejemplo creamos una exception llama OpcionErroneaException que hereda de la clase
exception.
public class OpcionErroneaException extends Exception{

public OpcionErroneaException(){
}
public String mensaje(){
return("OPCION ERRONEA");
}
}
Podemos crear una clase en Java que lance la excepcin creada por el programador.
public class LeerDatos3{

public static void main(String args[]) throws IOException{
BufferedReader teclado=new BufferedReader(new InputStreamReader(System.in));
String numero="";
String continua="";
try{
do{
System.out.println("Introduzca un numero:");
if (num%2==0){
System.out.println("El numero: "+ num +" es par");
}else{
System.out.println("El numero: "+ num +" es impar");
}
System.out.println("Desea continuar (s/n)?");
www.learning.es
continua= teclado.readLine();
if(!continua.equals("s") && !continua.equals("n")){

throw new OpcionErroneaException();
}
}while (continua.equals("s") || continua.equals("S"));

//Para compara se pone .equals
}catch (NumberFormatException e){

System.out.println("Debe introducir numeros");
}catch (OpcionErroneaException e){

System.out.println(e.mensaje());
teclado.readLine();
}
}
}
ASERCIONES
La tcnica de las aserciones consiste en sembrar el cdigo de chequeos de integridad, de cosas que
suponemos, de forma que si algo no es normal, lo detectemos lo antes posible, por s mismo, en vez
de tener que estar trazando marcha atrs las causas que han llevado a un fallo.
USO DE LAS ASERCIONES:

Distintas formas de utilizar una asercin:
assert dato > 15;
afirme dato==x+1;
assert Conectar();
Todas estas expresiones deben devolver un boolean. Si la condicin que evaluamos es verdad, la
ejecucin contina normalmente, si no se lanza un AssertionError.
ACTIVAR/DESACTIVAR ASERCIONES:
Java no chequea las aserciones salvo que le indiquemos explcitamente que queremos que lo haga:
java -ea miPrograma
activa las aserciones de mi programa
java -da miPrograma
las desactiva
java -ea:class miPrograma
activa las aserciones de mi programa; pero slo en la clase class
java -da:class miPrograma
desactiva las aserciones de la clase class
java -ea:package... miPrograma
activa las aserciones de mi programa; pero slo en el paquete package
java -da:package... miPrograma
desactiva las aserciones del paquete package
EJEMPLO:
www.learning.es
public class EjemploAserciones {
double x= 100.0;
double y= x/2;
assert x == y*2 : "Traza 1. Error al dividir " + x + " entre 2: " + y;
System.out.println("El resultado de n es :"+x);
}
}
Resultado:
CON ERROR:
public class EjemploAserciones {
double x= 100.0;
double y= x/2;
assert x == y*3 : "\nTraza 1. Error al dividir " + x + " entre 2: " + y;
System.out.println("El resultado de n es :"+x);
}
}
Resultado:
Ver Video: Excepciones . Control de errores,en la Unidad 8,

Actividades
www.learning.es
Unidad 9. API Colecciones y genricos
Introduccin
Las colecciones en Java de clases e interfaces para guardar colecciones de objetos.
Como corresponde a un lenguaje tan orientado a objetos, estas clases e interfaces estn
estructuradas en una jerarqua. A medida que se va descendiendo a niveles ms especficos
aumentan los requerimientos y lo que se le pide a ese objeto que sepa hacer.
A partir de la versin 5 de Java se implementan los genricos, gracias a los genricos ya no ser
necesario hacer casting de objetos.
Colecciones
En Java las principales interfaces que disponemos para trabajar con colecciones son: Collection, Set,
List, Queue y Map.
El paquete Java Collections Framework (JCF)

Contiene un conjunto de clases e interfaces del paquete java.util para gestionar colecciones de
objetos.
Collection. Un grupo de elementos individuales, frecuentemente con alguna regla aplicada a ellos.
List. Elementos en una secuencia particular.
Set. No puede haber duplicados. Coleccin sin duplicados

Queue: Coleccin ordenada con extraccin por el principio e insercin por el principio (LIFO) o por el
final (FIFO)
Map. Un grupo de pares objeto llave-valor. Un mapa es tambin llamado un array asociativo.
La desventaja principal de un contenedor es que no trata con tipos desconocidos. Un contenedor

toma referencias a Object, por lo que no hay restriccin sobre lo que se coloca en dicho contenedor.
Sin embargo se debe hacer un cast para cada elemento del contenedor.
Iteradores
Un iterador es un objeto cuya misin es la de recorrer a travs de una secuencia de objetos y
seleccionar cada objeto en esa secuencia sin que el programador pueda conocer o tenga cuidado
sobre la estructura subyacente de esa secuencia. Un iterador es llamado un objeto de peso ligero.
Los iteradores separan a los algoritmos del tipo especfico de contenedor con el cual un algoritmo
puede trabajar.
Los iteradores son la parte central para usar algoritmos.
Collection
En este primer ejemplo veremos que cualquiera de de los mtodos podramos utilizarlos con List,
Queue o Set ya que extienden de collection pero que pueden incluir alguna restriccin.
import java.util.*;
public class EjemploColecciones {
Collection<String> col1 = new HashSet<String>();
www.learning.es
Collection<String> col2 = Arrays.asList("valor1", "valor2");
Collection<String> col3 = Collections.singleton("valor3");
// add() y addAll() devuelven true si cambian
// la coleccin. Importa en conjuntos
if (col1.add("cero"))
System.out.println ("col1 modificada");
if (col1.addAll(col2))
System.out.println ("col1 modificada");
// Copiamos usando un copy constructor
Collection<String> copia = new ArrayList<String>(col1);
col1.remove("cero"); // eliminar un elemento
col1.removeAll(col3); // eliminar los elementos en e de c
col1.retainAll(col2); // elimina de c los que no estn en d
col1.clear(); // eliminar todos
boolean b =col1.isEmpty(); // b == true
int s = col1.size(); // s == 0
// Recuperamos en c la copia
b = col1.addAll(copia); // b == true
b = col1.contains("cero"); // b == true
b = col1.containsAll(col2); // b == true;
// Recorremos col1
Iterator<String> iterador = col1.iterator();
while(iterador.hasNext())
System.out.println(iterador.next());
for(Iterator<String> i = col1.iterator(); i.hasNext();)

System.out.println(i.next());
// Recorremos de col1
for(String word : col1) System.out.println(word);
// Las colecciones tienen toString()
System.out.println(col1);
// Copia en un Array
Object[] elementos = col1.toArray();
// Obtenemos una copia
String[] strings = col1.toArray(new String[col1.size()]);
//Sin necesidad de saber el tamao
strings = col1.toArray(new String[0]);
}
}
Resultado:
Los mtodos ms interesantes de una coleccin son:
Los elementos de una coleccin pueden pasarse a un array mediante
www.learning.es
List
El orden es la caracterstica ms importante de una lista, ya que mantiene elementos en una
secuencia particular. Podemos movernos en ambas direcciones de la lista a travs de un ListIterator.
Son muy similares a un array, pero con tamao cambiante.
Le diferencia de los conjuntos en que puede haber duplicados.
Para construir la lista utilizaremos uno de los tres constructores:
Existen dos implementaciones de una es ArrayList. La ventaja de ArrayList sobre un array es que se
puede redimensionar. La principal ventaja es que el tiempo de acceso a un elemento en particular es
nfimo. La desventaja es que si queremos eliminar un elemento del principio, o del medio, la clase
debe mover todos los que le siguen a la posicin anterior, para cubrir el hueco que deja el elemento.
Esto hace que sacar elementos del medio o del principio sea costoso.
La segunda implementacin es LinkedList . En sta, los elementos son mantenidos en una serie de
nodos atados entre s como eslabones de una cadena. Cada uno de estos nodos apunta a su
antecesor y al elemento que le sigue. Esta implementacin de List necesita entonces empezar desde
el comienzo, la desventaja es que usar el elemento diez implica realizar diez movimientos. La
ventaja es que es posible eliminar elementos del principio de la lista y del medio de manera muy
eficiente. Provee un ptimo acceso secuencial con rapidez de insercin y borrado en medio de la
lista.
Ejemplo de List:
import java.util.*;
public class Main {
List lista1 = new LinkedList();

lista1.add("Madrid");
lista1.add("Sevilla");
lista1.add("Valencia");
Iterator iterador = lista1.iterator();
while (iterador.hasNext()) {
String elemento = (String) iterador.next();
System.out.print(elemento + " ");
}
List lista2 = new ArrayList();
lista2.add("Madrid");
lista2.add("Sevilla");
lista2.add("Valencia");
Iterator iterador2 = lista2.iterator();
System.out.println("--LinkedList--");
while (iterador2.hasNext()) {
String elemento = (String) iterador2.next();
System.out.print(elemento + " ");
}
System.out.println("--ArrayList--");
}
www.learning.es
}
Set
Coleccin sin duplicados. Cada elemento que se agregue a un conjunto debe ser nico, por lo que
todo elemento duplicado no se agregar. No puede haber dos referencias al mismo objeto.
Por regla general, cuando se redefine equals(), se debe redefinir hashCode().

Es necesario redefinir hashCode() cuando la clase definida ser colocada en un HashSet.
Los mtodos add(o) y addAll(o) devuelven false si o ya estaba en el conjunto
Map
En un mapa se pueden buscar objetos utilizando otro objeto. Tabla que asocia claves a valores. No
utiliza la interfaz Collection.
Los principales mtodos son: put(), get(), remove()

HashMap se basa en una tabla hash, por lo que es preferible utilizar HashMap en vez de HashTable.
TreeMap se basa en una implementacin de rboles rojo-negro.
EJEMPLO:
import java.util.*;
{
{
// Definir un HashMap
HashMap global = new HashMap();
// Insertar valores "key"-"value" al HashMap

global.put("Laura", "667895789");
global.put("Pepe", "645895756");
global.put("Abelardo", "55895711");
global.put("Daniel", "667111788");
global.put("Arturo", "667598623");
// Definir Iterator para extraer/imprimir valores
for( Iterator it = global.keySet().iterator(); it.hasNext();) {

String s = (String)it.next();
String s1 = (String)global.get(s);
System.out.println("Alumno: "+s + " - " + "Telefono: "+s1);
}
}
}
hashCode()
El cdigo hash es una manera de tomar parte de la informacin de un objeto y convertirla en un
entero nico relativo con lo que las bsquedas se pueden hacer con mucha rapidez.
Un cdigo hash debe estar basado en el contenido del objeto.
Queue:
Es una coleccin ordenada de elementos con mtodos para extraer elementos del principio de la
cola, en orden. A diferencia de List, no hay acceso aleatorio: se extrae por el principio y se inserta
por el principio o por el final.
www.learning.es
El orden de insercin puede ser por el final (FIFO) o por el principio
(LIFO o pila).
Se permiten elementos duplicados (en Set no)
En lugar de elevar excepciones cuando est vaca o llena, Queue proporciona mtodos para
interrogar, que devuelven null. Por ello no se suele permitir insercin de null como valor
BlockingQueue: put()/take() se bloquean hasta que hay espacio/hay elementos.
Para aadir elementos

add() : en BoundedQueue eleva excepcin si est llena
offer() : devuelve false si est llena, no eleva excepcin
put() : Es de BlockinQueue y se bloquea si est llena
Para extraer elementos
remove() : extrae el elemento del principio. Excep. si vaco
poll() : como remove() pero si est vaca devuelve ull
take() : Es de BlockinQueue y se bloquea si est vaca
drainTo() : Es de BlockinQueue: vaca y devuelve coleccin
Para consultar sin extraer
element() : Devuelve, sin extraerlo, el primer elemento. Excep. si vaca
peek() : Como element() pero devuelve null si vaca
Implementaciones:
LinkedList: FIFO sin lmite de capacidad. Permite elementos null.
PriorityQueue mantiene ordenados los elementos de menor a mayor
En java.util.concurrent hay implementaciones para BlockingQueue
Otras colecciones
singleton(), singletonList(), singletonMap()

Devuelven conjunto, lista y mapa inmutables, con un nico
elemento. tiles para pasar un elemento a un mtodo que espera
una coleccin.
Interface Comparator y Comparable

Para que un objeto sea comparable, su clase debe implementar la interfaz java.lang.Comparable.
Esto quiere decir, que si queremos que una lista de objetos - o un conjunto - tenga sus elementos
ordenados, y esos objetos son de una clase que hemos hecho, es necesario que nuestra clase
implemente la interfaz java.lang.Comparable.
Un comparador es una clase de apoyo que ser utilizada para los mtodos de ordenamiento. Esto se
logra implementando la interfaz java.util.Comparator.
Cuando nosotros creamos una clase de algn tipo, podemos especificar el orden natural de los
objetos de esa clase cuando se encuentran en una lista, simplemente implementando el interfaz
Comparable que declara el mtodo:
int compareTo(Object o)
El mtodo compareTo () devuelve un entero con las siguientes caractersticas:
Negativo -> Si thisObject <anotherObject

Cero -> Si thisObject == anotherObject
Positivo -> Si thisObject> anotherObject
Por lo tanto las dos posibles soluciones para comparar

Ejemplo: En este ejemplo comparamos cadenas ignorando maysculas y minsculas e imprimiendo
lo resultado por orden alfabtico.
www.learning.es
Clase Principal
import java.util.*;
TreeSet ts = new TreeSet(new Comparacion ());
ts.add("Alonso");
ts.add("alonso");
ts.add("Conchi");
ts.add("Emilio");
ts.add("Gmez");
ts.add("manuela");
ts.add("Manuela");
System.out.println(ts);
}
}
Clase Comparacion
import java.util.*;
class Comparacion implements Comparator {
public int compare(Object o1, Object o2) {
return ((String) o1).compareToIgnoreCase((String) o2);
//Compara cadenas ignorando las may/min
}}
Ejemplo: En este ejemplo utilizamos la interface Comparable para comprobar objetos iguales.
Clase Principal
import java.util.*;

TreeSet ts = new TreeSet();
ts.add(new Persona("Pepe", "Perez"));
ts.add(new Persona("Pipi", "Perez"));
ts.add(new Persona("Manolito", "Cascos"));
ts.add(new Persona("Pipi", "Perez"));
ts.add(new Persona("Sara", "Alonso"));
System.out.println(ts);
}
}
Clase Persona
import java.util.*;
www.learning.es
public class Persona implements Comparable {
private String Nombre, apellido;
public Persona(String Nombre, String apellido) {
if (Nombre==null || apellido==null)
throw new NullPointerException();//Comprobar los nulos
this.Nombre = Nombre;
this.apellido = apellido;
}
public String Nombre(){return Nombre;}
public String apellido() {return apellido;}
public boolean equals(Object o) {
if (!(o instanceof Persona))
return false;//mtodo equals retorna false si argumento
Persona n = (Persona)o;//no es del tipo adecuado o es nulo
return n.Nombre.equals(Nombre) &&
n.apellido.equals(apellido);
}
public int hashCode() {
return 31*Nombre.hashCode() + apellido.hashCode();
}//hashcode tiene en cuenta ambos campos
public String toString() {return Nombre + " " + apellido;}
public int compareTo(Object o) {
Persona n = (Persona)o;//arroja ClassCastException si argumento no
int lastCmp = apellido.compareTo(n.apellido);//es del tipo Name
return (lastCmp!=0 ? lastCmp :
Nombre.compareTo(n.Nombre));
//primero comparamos los apellidos y si son iguales
//los nombres
}
}
Genricos
Los tipos genricos permiten forzar la seguridad de los tipos, en tiempo de compilacin, en las
colecciones (u otras clases y mtodos que utilicen tipos parametrizados).
En este ejemplo definimos dos objetos de tipo String:
public class Main {

List objetos = new ArrayList();
objetos.add(new String("Deportes"));
objetos.add(new String("Lectura"));
for(int i = 0; i < objetos.size(); i++)
{
String temp = (String) objetos.get (i);
System.out.println (temp);
}
}}
www.learning.es
Sin colecciones genricas tendramos que resolver el ejemplo de la siguiente manera:
import java.util.ArrayList;
import java.util.List;
List lista = new ArrayList();
lista.add("Deportes");
String cadena = (String) lista.get(0);
System.out.println(cadena);
}
}
Un permite almacenar objetos T o cualquier subtipo del mismo. (T tambin puede ser
una interface).
Cuando se utilizan colecciones genricas, no es necesario castear los objetos cuando se obtienen de
la misma.
Se puede pasar una coleccin genrica como parmetro a un mtodo que toma una coleccin no
genrica, pero los resultados pueden ser inesperados.
Compilar sin ningn error no es lo mismo que compilar sin ninguna advertencia. Una advertencia de
compilacin no es considerado un error de compilacin.
La informacin genrica de tipo no existe en tiempo de ejecucin, es solo para la seguridad de tipos
en tiempo de compilacin. Mezclando genricos con cdigo legal se puede compilar correctamente,
pero dicho cdigo puede arrojar una excepcin.
Las asignaciones polimrficas aplican solo al tipo base, no al parmetro de tipo genrico:
List<Deportes> l = new ArrayList< Deportes >(); // vlido

List< Deportes > l = new ArrayList<Futbol>(); // invalido
La regla de asignacin polimrfica aplica en cualquier lugar en donde se pueda realizar una
asignacin:
void foo(List< Deportes > l) { } // no puede tomar un argumento List< Futbol >
List< Deportes > bar() { } // no puede devolver un List< Futbol >
La sintaxis comodn permite a un mtodo genrico, aceptar subtipos (o supertipos) de un tipo
declarado_
como argumento de mtodo: List<? extends Deportes >
Cuando se utiliza un comodin <? extends Futbol>, la coleccin puede ser accedida pero no
modificada.
Cuando se utiliza el comodin List<?>, cualquier tipo genrico puede ser asignado a la referencia,
pero solo_
para acceso, no para modificaciones.
List<?> es igual a List<? extends Object>.
Las convenciones de declaracin utilizan la letra T para tipos y E para elementos de una coleccin.
Se puede utilizar ms de un tipo parametrizado en una declaracin.

Se puede declarar un tipo genrico utilizando un tipo que no est definido en la clase:
public <T> void makeList(T t) { }
Por convencin los tipos parametrizados son letras solitarias maysculas, sin esta convencin sera
difcil leer el cdigo y decir la diferencia entre una variable parametrizada y una clase ordinaria o un
nombre de una interface.
www.learning.es
E Elemento (Usado extensivamente en las colecciones en java)
K Key
N Number
T Type
V Value
S, U, V etc. 2nd, 3rd, 4th types
Ejemplo de convenciones:
import java.util.*;
public class Principal<T>

{
private T t;
public void add(T t) {
this.t = t;
}
public T get()
{
return t;
}
public <U> void inspeccion (U u)
{
System.out.println("T: " + t.getClass().getName());
System.out.println("U: " + u.getClass().getName());
}
Principal<Integer> integerBox = new Principal<Integer>();
integerBox.add(new Integer(10));
integerBox.inspeccion("una cadena de texto");
}
}
Actividades
www.learning.es
Unidad 10. Principios bsicos de E/S
Introduccin
En java todas las operaciones que constituyen un flujo de informacin del programa se les denomina
Entrada/Salida.
Siempre que hablemos de E/S podemos estar haciendo referencia a la E/S por teclado desde el
equipo de un usuario o a la E/S a travs de ficheros.
El paquete en java encargado del tratamiento de los datos de E/S es el java.io. Gracias a este
paquete podremos hacer referencia a todas las clases relacionadas con E/S de informacin.
Argumentos de la lnea de comandos

Para copilar un programa en Java utilizamos el comando javac seguido del nombre del archivo java
que queremos compilar. Al ejecutar un programa en la ventana de comandos el programador deber
utilizar el comando java.
Este comando puede tener argumentos como se explica en el siguiente ejemplo:

java Miprograma Pepe Riesgo 25
Los argumentos "Pepe", "Riesgo" y "25" se reciben en un Array de strings en el main:

public static void main(String[] args) { ... }
args[0] es "Pepe"
args[1] es "Riesgo"
args[2] es "25"
El siguiente ejemplo imprime en pantalla los parmetros que enviamos al ejecutar el programa.
Java impresiones Madrid Valencia Sevilla
El cdigo de impresiones.java es:

public class impresiones {
public static void main (String[] args) {
for (int i=0; <args.length; i++)
System.out.println(Parametros: +args[i]);
}
}
Propiedades del Sistema

En ocasiones es importante conocer las caractersticas del sistema donde ejecutamos nuestros
programas para evaluar el rendimiento que ste pueda tener o simplemente para propsitos
informativos. La clase System del paquete java.lang nos permite hacer uso del mtodo getProperty
paraobtener la siguiente informacin:
java.version : Versin del entorno de desarrollo de Java (JRE).

java.vendor : Nombre de la distribucin del JRE.
java.home: Directorio de instalacin de la mquina virtual.
os.name: Nombre del sistema operativo.
www.learning.es
os.arch: Arquitectura del sistema operativo.
os.version: Versin del sistema operativo.
user.name : Nombre de usuario del sistema.
user.home : Ruta del directorio del usuario del sistema.
java.vm.name: Nombre de la mquina virtual instalada.
java.vm.version: Versin de la mquina virtual instalada.
El siguiente ejemplo mostrar informacin de nuestra mquina con WindAows 2003

String propSO = "Nombre: " + System.getProperty("os.name");

propSO += System.getProperty("line.separator") + "Version: " + System.getProperty("os.version");
propSO += System.getProperty("line.separator") + "Arquitectura: " +
System.getProperty("os.arch");
propSO += System.getProperty("line.separator") + "Directorio Temporal: " +
System.getProperty("java.io.tmpdir");
propSO += System.getProperty("line.separator") + "Separador de Ficheros: " +
System.getProperty("file.separator");
propSO += System.getProperty("line.separator") + "Separador de Path: " +
System.getProperty("path.separator");;
propSO += System.getProperty("line.separator") + "Usuario: " +
System.getProperty("user.name");
System.out.println(propSO);
}
}
CLASE PROPERTIES
La clase Properties permite manejar el conjunto de propiedades de un programa.
Las clase Properties representa un conjunto de propiedades persistentes.
La clase Properties es una tipo especial de tabla hash con las siguientes caractersticas:
La clave y el valor de la tabla son strings

La tabla puede ser grabada y recuperada de un stream con slo una operacin
Valores por defecto pueden ser definidos en una tabla secundaria
Debido a que Properties hereda de Hashtable , los mtodos put y putAll se pueden
aplicar a un objeto Properties .
Mtodos de la clase Properties
getProperty ( String key): Devuelve un string con el valor de la clave especificada.

setProperty ( String key): Devuelve un string con el valor de la clave especificada.
propertyNames ():Returns an enumeration of all the keys in this property list, including distinct keys
in the_
www.learning.es
default property list if a key of the same name has not already been found from the main properties
list._
Devuelve una enumeracin de todas las claves del archivo de propiedades.
Creacin de archivo de propiedades

Siempre un archivo de propiedades lo guardaremos con extensin .PROPERTIES, .XML, .CONFIG o
un .TXT, ya que es la mejor forma de reconocerlos.
Guardaremos en C:\configuracion.properties la siguiente informacin:

# Nombre del servidor
servidor.nombre=PC9915
# Usuario para la conexin
servidor.usuario=Pepe
# Password para la conexin
servidor.password=poijasfr
Recuperacin de la informacin de un archivo de propiedades

Para poder hacer uso del archivo de propiedades recurriremos a la clase Properties del paquete
java.util.
Una vez instanciada esta clase podremos acceder a las claves y valores del fichero de propiedades
accediendo por el nombre de la clave, o bien recorrer todas las claves si no conocemos el nombre de
la misma.
import java.io.*;
import java.util.*;
Properties prop = new Properties();

InputStream is = null;
try {
is=new FileInputStream("c:\\configuracion.properties");
prop.load(is);
} catch(IOException e) {
System.out.println(e.toString());
}
// Acceder a las propiedades por su nombre

System.out.println("Propiedades por nombre:");
System.out.println("-----------------------");
System.out.println(prop.getProperty("servidor.nombre"));
System.out.println(prop.getProperty("servidor.password"));
System.out.println(prop.getProperty("servidor.usuario"));
// Recorrer todas sin conocer los nombres de las propiedades
System.out.println("Recorrer todas las propiedades:");
System.out.println("-------------------------------");
for (Enumeration e = prop.keys(); e.hasMoreElements() ; ) {

// Obtenemos el objeto
Object obj = e.nextElement();
System.out.println(obj + ": " + prop.getProperty(obj.toString()));
}
}
www.learning.es
}
Ficheros
Dispositivos de soporte magntico que se utilizan para guardar informacin de forma persistente de
los programas java.
La informacin dentro de un fichero se guarda:
Por campos: Son cada una de las variables miembro

Por registros: Son cada uno de los objetos
Existen cuatro operaciones bsicas para trabajar con ficheros:
Apertura del fichero

Lectura de la informacin
Escritura sobre el fichero
Cierre del fichero.
El trabajo con ficheros se realiza a travs de flujos.
Los flujos son clases de java que proporcionan los mecanismos necesarios para el intercambio de
informacin entre objetos.
Esta informacin puede estar codificada de dos formas:

Byte
Caracteres
CLASES DEL PAQUETE IO

CLASE READER
Clase base que permite la lectura de la informacin de cualquier soporte de caracteres.
CLASE WRITER
Clase base que permite la escritura de la informacin en cualquier soporte de caracteres.
CLASE INPUTSTREAM
Clase base que permite leer la informacin de cualquier objeto en bytes
CLASE OUTPUTSTREAM
Clase base que permite escribir la informacin de cualquier objeto en bytes
TIPOS DE FICHEROS
Ficheros secuenciales: Se caracterizan por manejar informacin de distinta longitud. En un operacin
de lectura inicialmente se lee todo el contenido del fichero de principio a fin, la escritura se puede
hacer al principio o al final del fichero.
www.learning.es
Ficheros aleatorios o de registro: Se caracterizan por manejar informacin que tiene la misma
longitud. Las operaciones de lectura y/o escritura se pueden realizar en cualquier parte del fichero.
Ficheros secuenciales
CLASE FILE
Se utiliza para manipular ficheros y/o carpetas que pueden o no existir dentro del sistema de
archivos.
Constructores:
File(String, String): Crea un objeto de la clase que es un fichero. Se encuentra en la ruta que
se indica en el primer argumento y cuyo nombre se pasa como segundo argumento.
File(File, String): Crea un objeto de la clase que es un fichero. El path se indica en el objeto
File que se pasa en el primer argumento y cuyo nombre se pasa como cadena en el segundo
argumento.
File(String): Crea un objeto de la clase que es un fichero. La ruta o nombre se pasa como
argumento.
Cuando se crea un objeto de la clase File el fichero no se crea directamente en el sistema, para que
se cree hay dos mtodos:
Utilizando la funcin createNewFile().

Escribir al menos un byte de informacin.
EJEMPLOS:
- File carpeta= new File(C:\\Ejemplos)
Crea una carpeta ejemplos dentro de la unidad C.
- File archivo= new File(carpeta,Ejemplo1.txt)
Crea un fichero llamado ejemplo1 dentro de c:\Ejemplos.
- File archivo2 = new File(C:\\Ejemplos,Ejemplo2.txt)
- File archivo3= new File(C:\\Ejemplos\\Ejemplo2.txt)
- File carpeta= new File(Ejemplos)
Al no poner ruta crea la carpeta donde se est ejecutando la aplicacin.
- File archivo3= new File(Ejemplo3.txt)
Al no poner ruta crea el fichero donde se est ejecutando la aplicacin.
Mtodos:
canRead(): Boolean. True si se puede hacer una operacin de lectura en un fichero o carpeta.
canWrite(): Boolean. True si se puede hacer una operacin de escritura en un fichero o
carpeta.
canNewFile(): Permite crear en el sistema un fichero o carpeta que inicialmente est vacio.
delete(): Boolean. Se utiliza para eliminar un fichero o carpeta. Devuelve true si se puede
eliminar.
deleteOnExit(): Permite eliminar un fichero o carpeta al finalizar la aplicacin.
equals(): Boolean.True si son iguales los ficheros que se comparan.
exists(): Boolean. True si el fichero o carpeta existe.
getAbsolutePath(): Devuelve una cadena indicando la ruta completa donde se encuentra el
archivo o carpeta.
getName(): Indica el nombre del fichero o carpeta.
isDirectory(): Devuelve true cuando el objeto File es una carpeta.
isFile(): Devuelve true cuando el objeto File es un fichero.
isHidden(): Devuelve true cuando el objeto File est oculto.
length(): Devuelve la longitud del fichero en bytes.
list(): Devuelve una matriz de tipo string con el nombre de todos los archivos y carpetas que
haya dentro de otra carpeta.
www.learning.es
mkdir(): Crear una carpeta. Devuelve true si se puede crear. En el caso de que la carpeta
este dentro de un path absoluto que no exista en el sistema, solo crea la primera carpeta.
mkdirs(): Crear una carpeta. Devuelve true si se puede crear. En el caso de que la carpeta
este dentro de un path absoluto que no exista en el sistema, se crea de manera completa.
Ejemplo: Con mkdir C:\Nueva\Ejemplo solo creara Nueva y com mkdirs nueva y ejemplo.
renameTo(): Permite cambiar el nombre de un fichero o carpeta por el del objeto que se pasa
como argumento. Devuelve true si lo ha cambiado.
setReadOnly(): Para establecer un fichero o carpeta de solo lectura.
Constantes:
pathSeparator: Devuelve un string indicando el carcter que se utiliza dentro del sistema
para separar cada una de las cadenas de la variable path. En Windows es ;.
pathSeparatorChar: Idem del anterior pero lo devuelve como carcter.
separator: Devuelve un string indicando el carcter que se utiliza dentro del sistema para
establecer la ruta a los recursos. En Windows es \.
separatorChar: Idem del anterior pero lo devuelve como carcter.
En el siguiente ejemplo mostramos todos los ficheros exe que tenemos en la carpeta trabajos.
import java.io.*;
public class FicherosExe {
//separador alamacena el tipo de separador utilizado en la plataforma, en windows \
String separador= File.separator;
//En carpeta almaceno el path de la carpeta que quiero mirar sus subelementos
File carpeta= new File("c:" +separador+ "Trabajos");
//En elementos almaceno la matriz con todos los nombres de los archivos y carpetas dentro_
de la carpeta que le indiqu
String[] elementos=carpeta.list();
//Mostramos el nmero de carpetas dentro de la que le dije

System.out.println("Los ficheros .exe son:\n");
for (int i=0;i<elementos.length;i++){

if (elementos[i].endsWith("exe") || elementos[i].endsWith("EXE")){
System.out.println("\t"+carpeta.getAbsolutePath()+_
separador+elementos[i]);
}
}
}
Laboratorio: Uso de la clase File

Objetivo
Utilizar las propiedades y mtodos ms interesantes de la clase File.
Enunciado
Crear en la unidad c de vuestra mquina una carpeta con el nombre TrabajosCurso.
Desarrollar una clase que nos permita recorrer y mostrar el nmero de ficheros que tenemos en esta
carpeta.
Solucin
import java.io.*;
www.learning.es
public class NumeroFicheros {
String separador= File.separator;
//En carpeta almaceno el path de la carpeta que quiero mirar sus

subelementos
File carpeta= new File("c:" +separador+ "TrabajosCurso");
//En elementos almaceno la matriz con todos los nombres de los archivos y_
carpetas dentro de la carpeta que le indiqu
String[] elementos=carpeta.list();
//Mostramos el numero de carpetas dentro de la que le dije

System.out.println("La carpeta " + carpeta.getAbsolutePath() +_
" tiene "+ elementos.length + " subelementos");
}
CLASE FILEOUTPUTSTREAM
Se utiliza para escribir informacin en formato byte.
Constructores:
FileOutputStream(String): Abre un flujo de escritura al fichero cuyo path y/o nombre se pasa
como argumento. El path puede ser absoluto o relativo. En el caso de que el fichero no exista
lo crea automticamente y en el caso de que exista lo sobrescribe.
FileOutputStream (File): Abre un flujo de escritura al fichero creado previamente que se pasa
en el objeto File como argumento. En el caso de que el fichero no exista lo crea
automticamente y en el caso de que exista lo sobrescribe.
FileOutputStream (String,boolean): Abre un flujo de escritura al fichero cuyo path y/o

nombre se pasa como primer argumento. En el caso de que el fichero no exista lo crea
automticamente y en el caso de que exista si el segundo argumento es true aade, y si es
falso sobrescribe.
Los tres constructores propagan una excepcin IOException.
Mtodos:
void write(byte[],int,int): El primer argumento es una matriz de tipo byte con la informacin
que se va a escribir en el fichero, el segundo argumento es la posicin dentro de la matriz a
partir de la cual voy a escribir en el fichero y el tercero y ltimo es el nmero de byte de la
matriz que se van a escribir.
void close(): Cierra el flujo de escritura a un fichero. Si el flujo de escritura no se cierra, la

informacin del fichero no se escribe y puede perder su contenido.
CLASE FILEINPUTSTREAM
Se utiliza para abrir un flujo de lectura en byte asociado a un fichero.
Constructores:
www.learning.es
FileInputStream(String): Crea un objeto, flujo de lectura en bytes asociado a un fichero.
Este constructor propaga la excepcin FileNotFoundException(se genera cuando el fichero al que se

va a asociar el flujo no existe o no est disponible).
FileInputStream (File): Crea un objeto que permite la lectura en bytes del fichero que se pasa como
objeto file en el argumento.
Mtodos:
int read(byte[],int,int): El primer argumento es una matriz de tipo byte con la informacin leida del
fichero, el segundo argumento es la posicin dentro de la matriz a partir de la cual voy a leer y el
tercero y ltimo es el nmero de byte de la matriz que se van a leer.
Devuelve el nmero de byte leidos por del fichero.
Propaga excepcin IOException.

void close(): Cierra el flujo de lectura a un fichero. Si el flujo de lectura no se cierra, para el resto
de lecturas que queramos hacer el fichero aparecer vacio.
El siguiente ejemplo nos permite abrir un fichero mediante la clase FileOutputStream y escribir en el
fichero llamado Nombres.dat.
import java.io.*;
public class Escribir_fich{
static FileOutputStream fescritura;
public static void main (String[] args){
String nombre="PEPE SANCHEZ";
try{
File carpeta=new File("ficheros");
if(!carpeta.exists()){
carpeta.mkdir();
}
File archivo= new File (carpeta,"Nombres.dat");
fescritura= new FileOutputStream(archivo);
}catch (IOException ioe){
System.out.println("ERROR GRAVE EN EL SISTEMA DE E/S EN EL

ACCESO");
}
try{
fescritura.write(nombre.getBytes(),0,nombre.length());
System.out.println("SE HA ESCRITO EN EL FICHERO");

System.out.println("ERROR DE ENTRADA SALIDA DE DATOS");
www.learning.es
}finally{
if(fescritura !=null){
try{
fescritura.close();
System.out.println("ERROR GRAVE DE E/S DE DATOS");
}
}
}
}
}
El siguiente ejemplo nos permite abrir un fichero mediante la clase FileInputStream y leer en el
fichero llamado Nombres.dat.
import java.io.*;
public class Leer_fich{
static FileInputStream flectura;
static File archivo;
try{
archivo = new File("Ficheros"+ File.separator + "Nombres.dat");
flectura=new FileInputStream( archivo );
}catch (FileNotFoundException e){

System.out.println("ERROR GRAVE: El fichero " + archivo.getAbsolutePath()+
_
"no esta disponible");
return;
}
try{
byte[] matriz = new byte[ (byte) archivo.length()] ;

int leidos = flectura.read(matriz,0,matriz.length);
System.out.println(new String (matriz,0, leidos));

System.out.println("ERROR DE ENTRADA SALIDA DE DATOS");
}finally{
if (flectura!=null){
try{
flectura.close();
System.out.println("ERROR GRAVE DE E/S DE DATOS");
}
}
}
}
}
www.learning.es
Laboratorio: Uso de las clases FileOutputStream y
FileInputStream
Objetivo
Aprender a escribir y leer sobre ficheros.
Enunciado
Crear un men como el que se muestra en la imagen.
----------------------------------------------------
1.- ESCRITURA EN FICHERO
2.- LECTURA EN FICHERO
3.- SALIR
----------------------------------------------------
Introduce una opcion:

Podremos escribir en un fichero elegido un texto y posteriormente recuperar el contenido escrito en
el fichero.
INTRODUCE EL NOMBRE DEL FICHERO DONDE ESCRIBIR: datos.txt
INTRODUCE TEXTO EN EL FICHERO:

Hola
----------------------------------------------------
1.- ESCRITURA EN FICHERO
2.- LECTURA EN FICHERO
3.- SALIR
----------------------------------------------------
Introduce una opcion: 2
INTRODUCE EL NOMBRE DEL FICHERO A LEER: datos.txt
EL CONTENIDO DEL FICHERO datos.txt

es:
Hola
Solucin:
import java.io.*;
class Trabajar_Ficheros{
static File archivo; //Para trabajar con el fichero con el que voy a escribir o del que voy a
leer
static FileOutputStream fescritura;
static FileInputStream flectura;
public static void main (String [] args) throws IOException{
int opc= Integer.MIN_VALUE;

boolean agregar = false ; //para saber cuando hay que aadir o sobreescribir
do{
www.learning.es
System.out.println("----------------------------------------------------
");
System.out.println("\t1.- ESCRITURA EN FICHERO");
System.out.println("\t2.- LECTURA EN FICHERO");
System.out.println("\t3.- SALIR");
\n");
do{
System.out.print("Introduce una opcion: ");

opc = Integer.parseInt( new BufferedReader (new
InputStreamReader _
(System.in)).readLine().trim());
}while (opc==Integer.MIN_VALUE);
if (opc==1){
System.out.print("\n INTRODUCE EL NOMBRE DEL FICHERO

DONDE _
ESCRIBIR: ");
String fichero = new BufferedReader (new InputStreamReader
(System.in))_
.readLine().trim();
archivo = new File (fichero);
if (archivo.exists()){
System.out.println("\n EL FICHERO YA EXISTE. QUIERE _

SOBREESCRIBIRLO (S)I (N)O?");
String resp= new BufferedReader (new
InputStreamReader (System.in))._
readLine().trim();
if (resp.compareToIgnoreCase("S")==0) {
agregar = false;
}else{
agregar = true;
}
}
System.out.println ("\nINTRODUCE TEXTO EN EL FICHERO:");

String cadena = new BufferedReader (new InputStreamReader _
(System.in)).readLine().trim();
cadena = cadena +"\n";
byte[] matriz = cadena.getBytes();
try{
fescritura = new FileOutputStream
(archivo.getName(),agregar);
fescritura.write(matriz,0,matriz.length);
}catch (IOException e){
System.out.println("No se ha podido escribir la
informacin en el fichero "+ _
archivo.getName());
}finally{
www.learning.es
try{
if(fescritura!=null){
fescritura.close();
}
}catch(IOException e){
System.out.println("No se ha podido cerrar
correctamente _
el flujo de escritura asociado al fichero "+ archivo.getName());
}
}
}else if (opc ==2){
System.out.print("\nINTRODUCE EL NOMBRE DEL FICHERO A

LEER: ");
String fichero = new BufferedReader (new InputStreamReader
(System.in))._
readLine().trim();
archivo = new File (fichero); //Creo un objeto File asociado a ese
nombre
byte [] matriz= new byte [(int) archivo.length()];
try{
flectura= new FileInputStream(archivo);
int leidos = flectura.read(matriz,0,matriz.length);
System.out.println("\nEL CONTENIDO DEL FICHERO "+_
archivo.getName()+"\n es: \n");
System.out.println(new String(matriz,0,leidos));

System.out.println("No se ha podido establecer
comunicacion con el fichero "+_
archivo.getName());
System.out.println("No se ha podido leer la informacion
del fichero "+_
archivo.getName());
}finally{
try{
if(flectura!=null){
flectura.close();
}
System.out.println("No se ha podido cerrar
correctamente _
el flujo asociado al fichero "+ archivo.getName());
}
}
}
}while(opc!=3);
}
}
CLASE FILEWRITER
www.learning.es
Clase que se utiliza para crear un flujo que te permite escribir informacin que va en caracteres en
un fichero.
Constructores:
FileWriter(File): Crea un objeto que permite escribir en el fichero File que se pasa como
argumento. En el caso de que el fichero no exista lo crea automticamente y en el caso de
que exista lo sobrescribe.
FileWriter (String): Crea un objeto que permite escribir en el fichero cuyo nombre y/o path se
pasa en el argumento. En el caso de que el fichero no exista lo crea automticamente y en el
caso de que exista lo sobrescribe.
FileWriter (String, boolean): Crea un objeto que permite escribir en el fichero cuyo nombre
y/o path se pasa en el argumento. En el caso de que el fichero no exista lo crea
automticamente y en el caso de que exista lo sobrescribe.
Mtodos:
void write(char[],int,int): El primer argumento es una matriz de tipo char con la informacin
que se va a escribir en el fichero, el segundo argumento es la posicin dentro de la matriz a
partir de la cual voy a escribir en el fichero y el tercero y ltimo es el nmero de byte de la
void write(String): til para escribir la cadena que se pasa como argumento en el fichero.

informacin del fichero no
se escribe y puede perder su contenido.
Los tres mtodos propagan una excepcin IOException.
CLASE FILEREADER
Clase que se utiliza para crear un flujo que te permite leer informacin que va en caracteres en un
fichero.
Constructores:
FileReader(File): Abre un flujo para leer informacin del fichero que se pasa como objeto file
en el argumento.
FileReader (String): Crea un objeto para poder leer del fichero cuyo path y/o nombre se pasa
como argumento.
Cualquiera de los dos constructores propaga una excepcin de la clase
FileNotFoundException.
Mtodos:
int read(char[],int,int): El primer argumento es una matriz de tipo char en donde se gurda la
informacin leda del fichero, el segundo argumento es la posicin dentro de la matriz a partir
de la cual voy a escribir en el fichero y el tercero y ltimo es el nmero de caracteres de la
void close(): Cierra el flujo de lectura a un fichero. Si el flujo de escritura no se cierra, la

Los dos mtodos propagan una excepcin IOException.
CLASE DATAOUTPUTSTREAM
Se utiliza para crear flujos de escritura que permiten manejar los tipos primitivos de java y la clase
String.
Constructor:
www.learning.es
DataOutputStream(OutputStream): Esta clase OutputStream es una clase abstracta. Es la clase
base que se utiliza para crear cualquier flujo de escritura en bytes.
Mtodos:
void writeUTF(String): Para escribir la cadena que se pasa como argumento. Este formato
incluye informacin sobre la longitud exacta de la cadena, nos permite recuperar la cadena
con facilidad debido a que conocemos la longitud del fichero.
void writeBoolean(boolean): Para escribir la variable de tipo boolean que se pasa como
argumento.
void writeByte(int): Para escribir como byte el tipo int que se pasa como argumento.
void writeDouble(double): Para escribir como byte el tipo double que se pasa como
argumento.
void writeShort(int): Para escribir como short el tipo int que se pasa como argumento.
void writeInt(int): Para escribir como entero el tipo int que se pasa como argumento.
void writeFloat(float): Para escribir como float el tipo float que se pasa como argumento.
void writeChar(char): Para escribir como carcter el tipo entero que se pasa como
argumento(el cdigo ASCII del caracter).
El siguiente ejemplo permite escribir con la clase DataOutputStream.
import java.io.*;
public class Escribir_Fich{

static DataOutputStream flujoescritura;
String respuesta="";
System.out.println("INTRODUCE EL FICHERO DE CLAVES POR TECLADO") ;
try{
String nombrefich= new BufferedReader (new InputStreamReader
(System.in))._
readLine().trim();
archivo= new File (nombrefich) ;
if (archivo.exists()){
System.out.println ("EL FICHERO YA EXISTE DESEA
SBOREESCRIBIR (SI/NO)?");
respuesta= new BufferedReader (new InputStreamReader
}
//compareToIgnoreCase es que compare sin distinguir mayusculas

y minusculas
if (respuesta.compareToIgnoreCase("si")==0){
flujoescritura = new DataOutputStream ( new
FileOutputStream(nombrefich));
}else{
flujoescritura= new DataOutputStream (new
FileOutputStream(nombrefich,true));
}
www.learning.es
System.out.println ("INTRODUCE EL NOMBRE DE USUARIO POR
TECLADO: ");
String nombre= new BufferedReader (new InputStreamReader
System.out.println ("INTRODUCE EL CODIGO DE USUARIO POR

TECLADO: ");
int codigo = Integer.parseInt(new BufferedReader (new
InputStreamReader (System.in))._
readLine().trim());
flujoescritura.writeInt(codigo);
flujoescritura.writeUTF(nombre);

System.out.println("NO SE HA PODIDO ESCRIBIR LA
INFORMACION EN EL FICHERO " + _
archivo.getName());
}finally{
try{
if (flujoescritura!=null){
flujoescritura.close();
}
System.out.println("NO SE HA PODIDO CERRAR
CORRECTAMENTE EL FLUJO _
DEL FICHERO EL FICHERO " + archivo.getName());
}
}
}
}
CLASE DATAINPUTSTREAM
Para crear un flujo que permite leer informacin y recuperarla directamente comom un tipo primitivo
de java, incluyendo la clase String.
Constructor:
DataInputStream(InputStream): La clase InputStream es una clase abstracta, es la clase base para

cualquier tipo de flujo que lea informacin de los tipos primitivos de java, incluyendo la clase String.
Mtodos:
Tiene los mismos mtodos que la clase anterior:
writeUTFreadUTF
write...read....
...................
Los mtodos propagan una excepcin IOException.

Hay una excepcin EOFExeption cuando intentas leer de un fichero que ya no tiene informacin.
Para leer la informacin a travs de la clase DataInputStream, obligatoriamente esa informacin

tiene que haber sido escrita con DataOutputStream.
El orden en que se va escribiendo es el orden en que se va leyendo.
www.learning.es
El siguiente ejemplo nos permite escribir con la clase DataInputStream.
import java.io.*;
public class Leer_Fich{

static DataInputStream flujolectura;
System.out.println("INTRODUCE EL FICHERO DE CLAVES POR TECLADO") ;
try{
archivo= new File (new BufferedReader (new InputStreamReader
(System.in))._
readLine().trim());
flujolectura= new DataInputStream (new

FileInputStream(archivo));
//Ojo el orden al leer tiene que ser el mismo que al escribir

while (true){
System.out.println ("CODIGO DE USUARIO: "+
flujolectura.readInt());
System.out.println ("NOMBRE DE USUARIO: "+
flujolectura.readUTF());
}

System.out.println("NO SE HA PODIDO ENCONTRAR EL FICHERO
"+_
archivo.getName());
}catch (EOFException e){
System.out.println("NO SE HA PODIDO LEER LA INFORMACION EN
EL FICHERO " + _
archivo.getName());
}finally{
try{
if (flujolectura!=null){
flujolectura.close();
}
CORRECTAMENTE EL _
FLUJO DEL FICHERO " + archivo.getName());
}
}
}
}
CLASE OBJECTOUTPUTSTREAM
Flujo que se utiliza para poder escribir objetos de cualquier clase java a cualquier otro objeto.
www.learning.es
Constructores:
ObjectOutputStream(): Para crear un objeto que permite escribir objetos de java sobre
cualquier dispositivo.
ObjectOutputStream(OutputStream): Crea un flujo que permite escribir objetos de java en el
objeto outputstream que se pasa como argumento.
Mismos mtodos que DataOutputStream mas:

void writeObject(Object): Para escribir a travs del flujo que est asociado al objeto que se pasa
como argumento.
Propagan la excepcin IOException.
Para poder utilizar este flujo los objetos han de ser PERSISTENTES: Aquel que al ser escrito a travs
de un flujo se encarga de almacenar los valores de sus variables miembro.
La serializacin es el proceso por el cual un objeto o una coleccin de objetos se convierten en una
serie de bytes que pueden ser almacenados en un fichero y recuperado posteriormente para su uso.
Se dice que el objeto u objetos tienen persistencia. Cuando serializamos un objeto, almacenamos la
estructura de la clase y todos los objetos referenciados por esta.
Los objetos persistentes son aquellos que pertenecen a las clases que implementan la interface
serializable, esta interface que pertenece al paquete IO de java no tiene mtodos, nicamente avisa
al compilador que los objetos que pertenecen a esa clase se encargan ellos mismos de guardar la
informacin que contienen.
Si una clase tiene como variable miembro un objeto de otra clase, a su vez debe implementar la
interface serializable.
La clase ObjectOutputStream permite la escritura de cualquier nmero de objetos a travs del flujo.
En el caso particular de que el objeto destino sea un fichero, solo va a permitir una operacin de
lectura.
Si se utilizan flujos de lectura y escritura de objetos en distintas aplicaciones, las clases de dichos
objetos tienen que estar obligatoriamente en un paquete. Estas clases no pueden estar en el mismo
fichero que la aplicacin.
CLASE OBJECTINPUTSTREAM
Es la clase que representa un flujo de lectura de objetos java que previamente han sido escritos con
el flujo ObjectOutputStream.
Constructores:
ObjectInputStream(): Para crear un objeto que permite leer objetos de java sobre cualquier
dispositivo.
ObjectInputStream (InputStream): Crea un flujo que permite leer objetos de java en el
objeto InputStream que se pasa como argumento.
Mtodos:
Mismos mtodos que DataOutputStream mas:
object readObject(): Para leer un objeto asociado al flujo y devolverlo de tipo Object. Hay que hacer
obligatoriamente in cast a la clase a la que lo vamos a convertir.
Persona obj=(Persona) flujolectura.readObject();
Todos los mtodos propagan una excepcin de la clase IOException.
www.learning.es
El mtodo readObject propaga la excepcin ClassNotFoundException(Cuando se intenta hacer un
cast al objeto que se ha ledo de una case que no es), y la excepcin
StreamCorruptedException(cuando se intenta hacer ms de una operacin de lectura a travs de la
clase ObjectInputStream).
Ejemplo
Creamos la clase persona en el paquete utilidades. La clase Persona implementar la clase
serializable, y ser la encargada de guardar la informacin serializada.
package Utilidades;
public class Persona implements java.io.Serializable{
private String m_nombre, m_apellidos, m_telefono, m_email;
public Persona(){}
public Persona (String a,String b,String c, String d){
m_nombre = a ;
m_apellidos = b;
m_telefono = c ;
m_email = d;
}
public String Obtener_Nombre() {return m_nombre ;}

public String Obtener_Apellidos() {return m_apellidos ;}
public String Obtener_Telefono() {return m_telefono ;}
public String Obtener_Email() {return m_email ;}
Creamos la clase Escritura, esta clase ser la encargada de guardar la informacin de los clientes en
un fichero de texto. La escritura la realizaremos a travs de la creacin de un objeto Persona.
package ejemplos;
import java.io.*;
import Utilidades.*;
class Escritura {
static ObjectOutputStream flujoescritura;
static File archivo, carpeta;
carpeta= new File ("Clientes");
if (!carpeta.exists()){
carpeta.mkdir();
}
archivo = new File (carpeta, "Correos.txt");
try{
flujoescritura = new ObjectOutputStream ( new FileOutputStream (archivo));
flujoescritura.writeObject( new Persona ("Pepe", "Salas Prez",
"919622314","pepeSalas@yahoo.es"));
System.out.println("SE HA ESCRITO EN EL FICHERO "+ archivo);
System.out.println("NO SE HA PODIDO ESCRIBIR LA INFORMACION EN EL FICHERO "+
archivo);
}finally{
try {
www.learning.es
if (flujoescritura!=null){
flujoescritura.close();
}
CORRECTAMENTE _
EL FLUJO ASOCIADO AL FICHERO "+ archivo);
}
}
}
}
La clase Lectura utilizar un objeto ObjectInputStream para realizar la lectura de la informacin

serializada.
package ejemplos;
import java.io.*;
import Utilidades.*;
public class Lectura {
static ObjectInputStream flujolectura;
public static void main (String args[]){

archivo = new File ("Clientes","Correos.txt");
try{
flujolectura = new ObjectInputStream (new FileInputStream
(archivo));
Persona obj = (Persona) flujolectura.readObject();

System.out.println("NOMBRE "+obj.Obtener_Nombre()+ "
APELLIDOS "+_
obj.Obtener_Apellidos());
System.out.println("TELEFONO "+obj.Obtener_Telefono()+ "
EMAIL "+ _
obj.Obtener_Email());
}catch(ClassNotFoundException e){
System.out.println("NO SE HA PODIDO CONVERTIR LA
INFORMACION");
System.out.println("NO SE HA PODIDO LEER LA INFORMACION
DEL FICHERO");
}finally{
try{
if(flujolectura!=null){
flujolectura.close();
}
System.out.println("NO SE HA PODIDO CERRAR CORECTAMENTE
_
EL FLUJO ASOCIADO AL FICHERO");
}
}
www.learning.es
}
CLASE RANDOMACCESSFILE
Es la clase encargada de crear ficheros aleatorios, son los ms fciles de tratar ya que nos permiten
movernos hacia la derecha, hacia la izquierda, saltar posiciones,
Se puede escribir partes del fichero sin necesidad de cerrarlo y aadir informacin al final del
fichero.
Cuando queramos abrir un fichero de acceso aleatorio tendremos que crear un objeto de tipo
RandomAccessFile y en constructor indicaremos la ruta del fichero y el modo de apertura: slo
lectura "r", o lectura/escritura "r/w".
RandomAccessFile Fichero = new RandomAccessFile ("datos.txt","rw");
En el siguiente ejemplo crearemos una aplicacin que nos permita guradar datos de los alumnos de
un curso en un fichero de texto con RandomAccesFile.Crearemos un men para poder seleccionar
entre las opciones: Introducir nota, Listado completo, Ver notas de un alumno, Modificar nota y
Salir.
package ejemplos;
import java.io.*;
public class FicherosAleatorios {
private static final int TAM_MAX=50;
private static final int NOMBRE_MAX=30;
private static final int MODULO_MAX=15;
private static RandomAccessFile nota;
//---------------------------------------------------------------
public static void Listar (String[] opc){
System.out.println("--------------------------------------------------------");
for (int i=1; i<=opc.length ; i++){
System.out.println("\t\t"+i+".- "+opc[i-1]);
}
System.out.println("--------------------------------------------------------");
//---------------------------------------------------------------
public static String Datos(String s){
try{
----");
System.out.print(s);
return (new BufferedReader (new InputStreamReader
(System.in)))._
readLine().trim();
System.out.println("\nError interno en sistema de
entrada/salida\n");
}
return "";
www.learning.es
//---------------------------------------------------------------
public static void meterNotaEnFichero(){
try{
String aux="";
nota.seek( NumRegistros()* TAM_MAX);
do{
aux=Datos("Introduce nombre: ");
if (aux.length()>=NOMBRE_MAX){
System.out.println("\nNombre demasiado largo\n");
System.out.println("------------------------------------------
--------------");
}
}while(aux.length()>=NOMBRE_MAX);
nota.writeUTF(aux);
do{
aux=Datos("Introduce modulo: ");
if (aux.length()>=MODULO_MAX){
System.out.println("\nNombre de modulo demasiado
largo");
System.out.println("------------------------------------------
--------------");
}
}while(aux.length()>=MODULO_MAX);
nota.writeUTF(aux);
----");
otro:do{
try{
aux=Datos("Introduce nota: ");
nota.writeInt(Integer.parseInt(aux));

System.out.println("Debes introducir un numero");
continue otro;
}
}while(false);
}catch(IOException ioe){
System.out.print("\nError "+ioe.toString());
}
}
//---------------------------------------------------------------
www.learning.es
public static void listadoCompleto(){
if (NumRegistros()!=0){
System.out.println("\n\t LISTADO COMPLETO\n----------------------------------
-----------");
System.out.println("\n---------------------------------------------");
try{
for (int i=0; i<NumRegistros();i++){

nota.seek(i* TAM_MAX);
System.out.println("\nNombre: "+ nota.readUTF());
System.out.println("Modulo: "+ nota.readUTF());
System.out.println("Nota: "+ nota.readInt());
System.out.println("\n----------------------------------------
-----");
}
System.out.println("\nError "+ioe.toString());
}
}else{
System.out.println("\nNo hay registros introducidos");
}
//---------------------------------------------------------------
public static void notasDe1Alumno(){

String aux="";
boolean esta=false;
if (NumRegistros()>0) {
aux = Datos("Introduce el nombre de un alumno: ");
try{

if
(aux.compareToIgnoreCase(nota.readUTF())==0){
System.out.println("\n------------------------
---------------------");
System.out.println("Nombre: "+
nota.readUTF());
System.out.println("Modulo: "+
nota.readUTF());
System.out.println("Nota: "+
nota.readInt());
esta=true;
}
}
if (esta==false){
www.learning.es
System.out.println("\nEse alumno no se encuentra");
}
}
}else{
System.out.println("No hay datos en el fichero");
}
}
//---------------------------------------------------------------
public static void modificarNota(){
String aux="";
String aux2="";
boolean esta=false;
if (NumRegistros()>0) {
aux = Datos("Introduce el nombre de un alumno: ");
aux2 = Datos("Introduce el modulo: ");
String opcion="";
try{

if
(aux.compareToIgnoreCase(nota.readUTF())==0){
if
(aux2.compareToIgnoreCase(nota.readUTF())==0){
System.out.println("Nombre: "+
nota.readUTF());
System.out.println("Modulo: "+
nota.readUTF());
opcion = Datos("Introduce la nueva

nota: ");
nota.writeInt(Integer.parseInt(opcion));
esta=true;
}
}
}
if (esta==false){
System.out.println("Esos datos no se encuentra");
}
}
}else{
System.out.println("No hay datos en el fichero");
}
www.learning.es
//---------------------------------------------------------------
private static int NumRegistros(){
try{
return (int)Math.ceil ((double)nota.length()/ (double)TAM_MAX);
System.out.println("ERROR GRAVE DE ENTRADA/SALIDA");
return 0;
}
}
//---------------------------------------------------------------
String[] menu1={"Introducir nota", "Listado completo","Ver notas de un

alumno",_
"Modificar nota","Salir"};
String opcion;
try{
nota=new RandomAccessFile ("notas.txt","rw");
fin:do{
Listar(menu1);
opcion = Datos("Introduce una opcion: ");
try{
switch (Integer.parseInt(opcion)){
case 1: meterNotaEnFichero();
break;
case 2: listadoCompleto();
break;
case 3: notasDe1Alumno();
break;
case 4: modificarNota();
break;
case 5: break fin;
default: System.out.println("Opcion
erronea");
}
System.out.println("La opcion tiene que ser un numero");
}
}while(true);
www.learning.es
}finally{
try{
if (nota!=null){
nota.close();
}
}
}
}
}
Ver Video: ObjectOutputStream y ObjectlnputStream, en la

Unidad 10,en el Mdulo 2, en la plataforma elearning
Actividades
www.learning.es
Unidad 11. E/S de consola y E/S de archivos
Introduccin
En esta unidad trataremos la E/S de los datos del usuario desde su equipo, datos introducidos por
teclado, sin interactuar ninguna interface tipo Swing, pgina web, applet,
El acceso a la entrada y salida estndar de datos en Java es controlado por tres objetos que se
crean automticamente al iniciar la aplicacin: System.in, System.out y System.err.
LOS InputStream: EL OBJETO System.in
Al igual que Java nos ofrece System.out para escribir en pantalla, tenemos System.in para leer de
ella. System.in es un objeto de una clase de java que se llama InputStream.
Para java, un InputStream es cualquier cosa de la que se leen bytes. Puede ser el teclado, un
fichero, un socket, o cualquier otro dispositivo de entrada. Esto, por un lado es una ventaja. Si todas
esas cosas son InputStream, podemos hacer cdigo que lea de ellas sin saber qu estamos leyendo.
Por otro lado, es una pega. Como un InputStream es para leer bytes, slo tiene mtodos para leer
bytes. Nosotros queremos leer palabras o nmeros del teclado, no bytes. Si escribimos en el teclado
una A mayscula y la leemos con System.in, obtendremos un entero de valor 65, que es el valor del
byte correspondiente a la A.
LOS Reader
Para java, una clase Reader es una clase que lee caracteres. Esto se parece ms a lo que queremos.
Un Reader tiene mtodos para leer caracteres. Con esta clase ya podriamos trabajar. La pena es que
seguimos teniendo System.in, que es un InputStream y no un Reader.
Cmo convertimos el System.in en Reader?. Hay una clase en java, la InputStreamReader, que nos
hace esta conversin. Para obtener un Reader, nicamente tenemos que instanciar un
InputStreamReader pasndole en el constructor un InputStream. El cdigo es el siguiente
InputStreamReader isr = new InputStreamReader(System.in);
Estamos declarando una variable "isr" de tipo InputStreamReader. Creamos un objeto de esta clase
haciendo new InputStreamReader(...). Entre parntesis le pasamos el InputStream que queremos
convertir a Reader, en este caso, el System.in
InputStreamReader es un Reader. Se comporta igual que in Reader y se puede poner en cualquier
sitio que admita un Reader. Es decir, podemos leer de l caracteres.
Al constuirlo le hemos pasado un InputStream, en concreto, System.in. InputStreamReader de
alguna forma se lo guarda dentro.
Cuando a InputStreamReader le pedimos caracteres, l le pide al InputStream que tiene guardado
dentro los bytes, los convierte a caracteres y nos los devuelve.
LA CLASE BufferedReader
Con la clase InputStreamReader podramos apaarnos. La pega es que nos da los caracteres
sueltos. Si estamos leyendo de teclado, el que usa el programa puede escribir 10 caracteres o 20 o
13. Si usamos InputStreamReader, como lee caracteres sueltos, Tenemos que decirle cuntos
queremos (que no lo sabemos), o bien ir pidiendo de uno en uno hasta que no haya ms.
La clase BufferedReader posee el mecanismo para obtener un BufferedReader a partir de otro

Reader cualquiera (por ejemplo el InputStreamReader), es similar al que usamos antes. Lo
instanciamos pasndole en el construtor el Reader. El cdigo es
BufferedReader br = new BufferedReader (isr);
El funcionamiento de esta clase es igual que el InputStreamReader. Cuando le pedmos una lnea
completa de caracteres (un String), ella se lo pide al Reader que tenga dentro, los convierte en
String y nos lo devuelve.
www.learning.es
Para pedirle un String, se usa el mtodo readLine(). Este mtodo lee todos los caracteres tecleados
(recibidos si fuera otro dispositivo de entrada) hasta que encuentra la pulsacin de la tecla
o como quieras llamarla.
String texto = br.readLine();
Objetivos
Conocer los objetos que implementan la salida estndar en java
Trabajar con la E/S de datos por consola y archivos
System.in
La clase System.in nos permite acceder a la lectura de caracteres. Para la lectura de los caracteres
tendremos que utilizar un Buffer de lectura, la clase encargada de esto ser BuffererReader.
Las aplicaciones que tengan que hacer una lectura de streams, en este caso por la consola, lo
realizarn mediante wrapping de clases. Es decir, sobre la consola, montamos un
InputStreamReader, y sobre este un BufferedReader.
Ejemplo:
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
Mtodos ms impotantes:
skip(n): Ignora los n caracteres siguientes de la entrada.
read():Si no se ha introducido ningn carcter por el teclado devuelve el valor
1. Devuelve el carcter que se ha introducido por el teclado leyndolo del buffer de entrada y lo
elimina del buffer para que en la siguiente lectura sea ledo el siguiente carcter.
En el siguiente ejemplo recogemos un nmero por teclado y mostramos en pantalla si el nmero es

par o impar.
import java.io.*;

String numero;
int dato=Integer.parseInt(numero);
if (dato%2==0){
else{
www.learning.es
}
}
Introduzca nmero:
5
El dato 5 es impar
System.out
Este objeto implementa la salida estndar. Se pueden utilizar los mtodos print() y println() con
cualquier tipo bsico Java como argumento.
Una de las novedades desde la versin 1.5 de java es el famoso printf tan usado en C. Este mtodo
nos permite definir como representar multitud de tipos de datos sin mucho trabajo.
En este ejemplo obligamos la salida a 14 posiciones, con el smbolo y cuatro decimales.
import java.util.*;
public class EjPrint
{
public static void main(String [] params)
{
float valor = 10.23f;
System.out.printf("El valor es %+14.4f",valor);

}
}
La salida ser:
System.err
En java podemos implementar el objeto System.err para la salida de errores.
Las funciones que tenemos en System.out son idnticas a las proporcionadas por System.out.
Es muy habitual imprimir el error en un fichero de texto dedicado a ir guardado los mensajes de
error que se produzcan.
En el siguiente ejemplo recogemos un nmero por teclado y mostramos en pantalla si el nmero es
par o impar. Si el nmero es impar lanzamos un System.err.
import java.io.*;

String numero;

int dato=Integer.parseInt(numero);
if (dato%2==0){
}
else{
www.learning.es
System.err.println( "Dato impar no se puede realizar la operacin" );
}
}
}
Introduzca nmero:
3
Dato impar no se puede realizar la operacin
El dato 3 es impar
Actividades
www.learning.es
Unidad 12. Creacin de interfaces grficas
con el API Swing
Introduccin
La base de la programacin grfica se encuentra en estos dos elementos fsicos del ordenador, los
cuales se disearon de forma conjunta con el propsito de presentar informacin al usuario. El
comprender su funcionamiento ayuda a conocer lo que estamos haciendo cuando diseamos un
entorno grfico.
Monitor y tarjeta grfica

El CRT (Tubo de Rayos Catdicos) est formado por los siguientes elementos:
- Ctodos: Aqu se generan tres haces de electrones cuya energa corresponden con los tres
colores bsicos, a partir de los cuales podemos obtener el resto de colores.
- Sistema de enfoque: Mediante un sistema de electroimanes (campos magnticos generados
a partir de seales elctricas) enfocamos los tres haces de electrones sobre un punto de la
pantalla. Este sistema es el encargado tambin de realizar el desplazamiento de dichos haces
con el propsito de formar la imagen.
- Pantalla: Est formada por un material fosforescente que desprende los fotones que llegan
hasta el ojo cuando los electrones chocan contra l. Adems mantiene la impresin de los
haces durante un tiempo que junto con la persistencia de nuestra retina nos da la sensacin
de permanencia.
A partir de este funcionamiento podemos definir una serie de parmetros:

- Pixel: la unidad bsica de informacin de la imagen. Se corresponde con uno de los puntos
donde convergen los tres haces de electrones. El tamao actual es de 0.28mm. Cuanto ms
pequeo sea el pixel, mayores resoluciones podramos obtener con el mismo tamao de la
pantalla.
- Resolucin vertical y horizontal (resolucin): Es el nmero de pxeles que se estn
representando de forma vertical (lneas) y de forma horizontal (nmero de puntos en una
lnea). Resoluciones tpicas son: 640x480, 800x600, 1024x768.
- Frecuencia de cuadro: Es el nmero de imgenes que se presentan por segundo. Esta
frecuencia se coge directamente de la frecuencia de la seal de red (50Hz) y debe ser valores
que eviten el parpadeo.
- Entrelazado: Tecnologa que permite representar primero las lneas impares y posteriormente
las lneas pares con lo que se consigue que la vista se canse menos.
- Profundidad de color: Los colores que es capaz de representar el monitor viene directamente
dado por la capacidad que tenga el monitor de cambiar las intensidades de los tres haces de
electrones. Esta variacin es analgica dentro del monitor, por tanto, podramos conseguir
infinidad de colores, sin embargo, los circuitos que controlan estas intensidades (situados en
la tarjeta grfica) manejan datos digitales que posteriormente se convierte a analgico con la
correspondiente prdida de niveles.
La evolucin de los monitores:

- CGA
- EGA
- VGA
- SVGA
Tarjeta grfica. Este es el elemento que controla todas las seales que necesita el monitor para
presentar informacin en pantalla. En concreto:
- Seales de temporizacin para el movimiento de los haces.
- Seales RGB para el control de la intensidad de los haces (colores).
www.learning.es
La informacin de los colores son datos binarios situados en la memoria que tiene la propia tarjeta
grfica. Un conjunto de posiciones de memoria alberga la informacin para cada pixel. Por tanto, la
resolucin y nmero de colores que podemos obtener depende de la memoria que disponga la
tarjeta.
Conclusin: Por tanto cuando aparece un elemento grfico en pantalla, tan slo se han situado en la
zona de memoria correspondiente un conjunto de datos binarios que codifican los colores del
conjunto de pxeles de la zona de pantalla en concreto.
El sistema de coordenadas.
A la hora de disear los programa de bajo nivel que faciliten a los programadores su trabajo con el
entorno grfico, es necesario establecer algn sistema de referencia que ponga orden en el mar de
pxeles de la pantalla. Se acord que el origen de coordenadas (0,0) sera la esquina superior
izquierda, la coordenada x seran las lneas, y la coordenada y seran las columnas.
Ahora bien, los lenguajes de programacin pueden manejar coordenadas relativas o absolutas.
- Coordenadas absolutas: Cualquier elemento que se site sobre la pantalla (por ejemplo,
un botn) tendr su origen de coordenadas en la esquina superior izquierda y tendrn los
valores que correspondan con la coordenada (0,0).
- Coordenadas relativas: Cualquier elemento que se coloque sobre la pantalla tendr su
propio sistema de coordenadas, es decir, la coordenada de su esquina superior izquierda ser
la (0,0). El compilador del lenguaje ser el encargado de realizar la transformacin de
coordenadas.
Java usa coordenadas relativas, es decir, cada uno de los componentes de Java tiene su propio
sistema de coordenadas, que va desde la coordenada (0,0) (esquina superior izquierda), hasta la
posicin determinada por su anchura y altura totales, menos una unidad.
La unidad de medida son los pxeles.
A la hora de un pintar un Componente, se debe tener en cuenta, adems del tamao ya comentado,
el tamao del borde del Componente, si lo tuviera. Por ejemplo, un borde que ocupar un pixel
alrededor del componente, hara que la coordenada de la esquina superior izquierda pasase de ser
(0,0) a (1,1) y reducira adems la anchura y altura totales del Componente es dos pxeles, uno por
cada lado.
Clases de Java para la programacin grfica y su evolucin.

Al enfrentarse con el desarrollo de una aplicacin grfica, el programador debe conocer las
herramientas que le ofrece el lenguaje de programacin que va a utilizar. Java dispone de una serie
de clases para este menster. Estas clases se encuentran en los siguientes paquetes:
Java.awt: El AWT (Abstract Window Toolkit) es el primer paquete que diseo Sun para el desarrollo
de entornos grficos.
Se comenta que se desarroll en unos pocos meses y que esto fu la causa de sus carencias y
defectos.
Javax.swing: Este paquete se distribuye en la nueva plataforma Java2.
Programacin grfica con Swing

Swing hay que verlo como una extensin de AWT, por tanto, no hay que olvidar lo aprendido en
AWT. Es ms, en la mayora de los casos es suficiente con aadir una "J" al componente AWT para
que se convierta en un componente Swing.
En Swing, los componentes de la interfaz grfica son Beans. Todos los componentes son "ligeros"
(lightweight), es decir, ya no se usan componentes dependientes del sistema operativo.
Se utiliza slo el nuevo modelo de Delegacin de eventos.
Son muchas las ventajas que ofrece el uso de Swing:
www.learning.es
- La navegacin con el teclado es automtica, es decir, cualquier aplicacin Swing se puede
usar sin el ratn sin tener que aadir lneas de cdigo adicionales.
- Las etiquetas de informacin ("tool tips") se pueden crear con una sola lnea de cdigo. Estas
etiquetas de informacin son las que aparecen cuando nos situamos con el ratn sobre un
componente del interfaz grfico.
Con respecto al AWT, Swing incorpora muchos aspectos que permiten mejorar el entorno grfico.
Paquete javax.swing
Las clases principales de Swing se encuentran en este paquete.
Tenemos que seguir distinguiendo entre Gestores de trazado, Contenedores y Componentes.
A continuacin pasamos a describir las nuevas clases agrupadas segn lo que sean:
Sumario de clases del paquete javax.swing
BoxLayout Un gestor de trazado nuevo que permite a mltiples componentes ser
colocados segn un eje horizontal o vertical.
JRootPane El componente fundamental en la jerarqua de contenedores.
JWindow Una representacin de una ventana.
JApplet Una versin extendida de java.applet.Applet que aade nuevas
funcionalidades, por ejemplo, pueden aadirse barras de men de
Swing.
JDialog La clase principal para crear una ventana de dilogo.
JFrame Una versin extendida de java.awt.Frame que aade funcionalidades
extras.
JPanel JPanel es un contenedor ligero genrico.
JInternalFrame Un objeto ligero que proporciona muchas de las caractersticas de
una ventana nativa, incluyendo "pinchar y arrastrar", cerrado,
iconizado, redimensionado, ttulo y barra de men.
JComponent La clase base para los componentes Swing.
AbstractButton Define el comportamiento comn de las clases JButton,
JToggleButton, JCheckbox y JRadioButton. Es una clase abstracta y,
por tanto, no pueden crearse objetos.
AbstractListModel La definicin abstracta para el modelo de datos que proporciona una
lista con sus contenidos.
JButton Un botn Swing.
JCheckBox Un CheckBox Swing.
JRadioButton Una implementacin de un botn tipo radio
JToggleButton Una implementacin de un botn de dos estados.
ButtonGroup Esta clase permite crear un grupo de botones con exclusin mltiple.
JLabel Un rea para visualizar un texto corto, una imagen o ambos.
JComboBox Implementacin de Swing de un ComboBox -- Un ComboBox es una
combinacin de una caja de tecto y una lista desplegable que permite
a un usuario o introducir un valor mediante teclado o seleccionar de
la lista.
JList Un componente que permite al usuario seleccionar uno o ms objetos
de una lista.
ImageIcon Una implementacin del interface Icon que permite pintar iconos a
partir de imgenes.
JTextField Una implementacin de una caja de texto..
JPasswordField JPasswordField es un campo de texto tipo password.
JTextArea Una implementacin de un textarea.
JScrollPane Un contenedor que permite aadir barras de desplazamiento a otros
componentes.
JProgressBar Un componente que representa un valor entero dentro de un
intervalo limitado.
JSlider Un componente que permite al usuario seleccionar grficamente un
www.learning.es
Sumario de clases del paquete javax.swing
valor desplazando una barra dentro de un intervalo.
JMenuBar Una implementacin de una barra de men.
JMenu Una implementacin de un men.
JMenuItem Una implementacin de un MenuItem.
JPopupMenu Una implementacin de un men emergente
JRadioButtonMenuItem Una implementacin de un item de men tipo radio.
JCheckBoxMenuItem Un item de un men Swing que puede ser seleccionado o no.
JSeparator Una implementacin de un separador de opciones de men.
JToolBar Una implementacin de una barra de herramientas.
JColorChooser Esta clase proporciona un panel de controles diseado para permitir
al usuario manipular y seleccionar un color.
JFileChooser JFileChooser proporciona un mecanismo simple para seleccionar un
fichero.
JOptionPane JOptionPane facilita el despliegue de una caja de dilogo estndar
que pregunta al usuario acerca de un valor o le informa de algo.
JEditorPane Un componente de texto para editar diversas clases de contenidos.

JTextPane Un componente de texto con capacidad de representacin grfica.
JScrollBar Una implementacin de una barra de desplazamiento.
JTabbedPane Un componente que permite al usuario desplazarse entre un grupo
de componentes pulsando el tabulador con un ttulo y/o icono dado.
JSplitPane JSplitPane se usa para dividir dos (y slo dos) componentes.
JTable JTable es un componente que permite presentar datos en formato de
tabla de dos dimensiones.
JTree Un control que visualiza un conjunto de datos organizados
jerarquicamente en forma de rbol.
Ejemplos con algunas de las clases de Swing

Posicionar controles en un formulario.
Insertar dos controles JButton sobre un Frame de Swing.
Al pulsar sobre el JButton Rojo cambiaremos el color del contenedor a Rojo y lo mismo con el
Jbutton de Verde.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class EjSwing extends JFrame{
Container cont;
//------------------------------------------------
www.learning.es
new EjSwing();
}
//------------------------------------------------
public EjSwing(){
cont = getContentPane();
JButton boton1= new JButton("Rojo");

boton1.setBounds(20,50,100,20);
boton1.addActionListener(new ActionListener(){
public void actionPerformed (ActionEvent ae){
cont.setBackground (Color.red);
}
});
cont.add(boton1);
JButton boton2= new JButton("Verde");

boton2.setBounds(180,50,100,20);
boton2.addActionListener(new ActionListener(){
cont. setBackground (Color.green);
}
});
cont.add(boton2);
cont.setLayout(new BorderLayout());
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent we){
System.exit(0);
}
});
setSize(300,200);
setLocation(100,100);
setTitle("Ejemplo de javax.swing.JFrame");
setResizable(false);
setVisible(true);
}
}
Contenedor JFrame y controles en ejecucin.

Realizar un programa que permita modificar dinmicamente el nmero de controles que contiene un
contenedor en un JFrame.
Al pulsar sobre agregar, iremos agregando botones hasta el mximo de diez botones.
Al pulsar sobre Eliminar, iremos eliminando botones del contenedor de uno en uno.
Con el botn eliminar todos, borraremos todos los botones del contenedor.
www.learning.es
import java.awt.*;
int contador=0;
public EjSwing()
{
final Panel p_central =new Panel();
Panel p_sur=new Panel();
int i=0;
Button btn_agregar= new Button ("Agregar");
Button btn_eliminar=new Button ("Eliminar");_
Button btn_eliminar_todos=new Button ("Eliminar todos");
final Button[] botones= new Button[10];
setLayout(new BorderLayout());
for (i=0;i<botones.length;i++)
{
botones[i]=new Button("Boton " +(i+1));
}
btn_agregar.addActionListener(new ActionListener()_
{
public void actionPerformed(ActionEvent e)
{
if (contador < botones.length)
{
p_central.add(botones[contador++]);
validate();_
}
}
});
btn_eliminar.addActionListener(new ActionListener()
{
www.learning.es
{
if (contador > 0)
{
contador--;_
p_central.remove(contador);
validate();
}
}
});
btn_eliminar_todos.addActionListener(new ActionListener()
{
{
p_central.removeAll();
contador=0;
validate();
}
});
p_sur.add(btn_agregar);
p_sur.add(btn_eliminar);
p_sur.add(btn_eliminar_todos);
add(p_central, BorderLayout.CENTER);
add(p_sur, BorderLayout.SOUTH);
setSize(300,300);
public static void main (String Args[])

{
EjSwing f=new EjSwing();
f.setVisible(true);
}
}
Clase JTree
En este ejemplo realizaremos una aplicacin con un control Jtree en el que podremos insertar
nuevos elementos, ver elementos seleccionados, Eliminar elementos y Modificar elementos.
www.learning.es
import java.awt.*;
import javax.swing.event.*;
import javax.swing.tree.*;
DefaultTreeModel modelo;
JTree arbol=new JTree();
JButton btn=new JButton("Insertar");
JButton btnsel=new JButton("Seleccionado");
JButton btneli=new JButton("Eliminar");
JButton btnmod=new JButton("Modificar");
JLabel lbl=new JLabel();
JTextField txt=new JTextField();
Container cont;
JScrollPane scroll;
DefaultMutableTreeNode raiz;
DefaultMutableTreeNode nnodo;
DefaultMutableTreeNode equipo;
DefaultMutableTreeNode jugador;
public EjSwing()
{
cont=getContentPane();
raiz=new DefaultMutableTreeNode("Clientes");
modelo=new DefaultTreeModel(raiz);
crearNodos();
arbol.setModel(modelo);
arbol.setBounds(10, 20, 150, 200);
scroll=new JScrollPane(arbol);
lbl.setBounds(10, 210, 300, 50);
lbl.setBackground(Color.green);
btn.setBounds(180, 20, 100, 30);
txt.setBounds(180, 70, 100, 30);
btnsel.setBounds(180, 110, 120, 30);
btneli.setBounds(180, 140, 120, 30);
www.learning.es
btnmod.setBounds(180, 180, 120, 30);
//cont.add(arbol);
scroll.setBounds(10, 20, 150, 200);
cont.add(scroll);
cont.add(btn);
cont.add(txt);
cont.add(lbl);
cont.add(btnsel);
cont.add(btneli);
cont.add(btnmod);
cont.setLayout(new BorderLayout());
arbol.addTreeSelectionListener(new TreeSelectionListener()
{
public void valueChanged(TreeSelectionEvent e)
{
}
});
btn.addActionListener(new ActionListener()
{
{
nnodo=new DefaultMutableTreeNode(txt.getText());
raiz.add(nnodo);
modelo.reload();
}
});
btneli.addActionListener(new ActionListener()
{
{
int indice=0;
DefaultMutableTreeNode nodo;
DefaultMutableTreeNode padre;
nodo=(DefaultMutableTreeNode)(arbol.getSelectionPath()._
getLastPathComponent());
padre=(DefaultMutableTreeNode)nodo.getParent();
//padre.remove(nodo);
nodo.removeFromParent();
//padre.setUserObject((Object)(txt.getText()));
modelo.reload();
}
});
btnmod.addActionListener(new ActionListener()
{
{
DefaultMutableTreeNode nodo;
nodo=(DefaultMutableTreeNode)(arbol.getSelectionPath()._
nodo.setUserObject((Object)(txt.getText()));
modelo.reload();
}
www.learning.es
});
btnsel.addActionListener(new ActionListener()
{
{
lbl.setText("NODO..." +arbol.getSelectionPath()._
}
});
setSize(500, 500);
setVisible(true);
}

{
EjSwing f=new EjSwing();
}
public void crearNodos()

{
equipo=new DefaultMutableTreeNode("Madrid");
raiz.add(equipo);
jugador=new DefaultMutableTreeNode("Pepe");
equipo.add(jugador);
jugador=new DefaultMutableTreeNode("Yumio");
jugador=new DefaultMutableTreeNode("Tiner s.l");

equipo=new DefaultMutableTreeNode("Sevilla");
raiz.add(equipo);
jugador=new DefaultMutableTreeNode("FGT s.a");

jugador=new DefaultMutableTreeNode("Polos s.l");

jugador=new DefaultMutableTreeNode("Yahiza");
}
Laboratorio: Manejo de los cuadros de dilogo

Objetivo
Utilizar los cuadros de dilogo de Swing.
Enunciado
www.learning.es
- Realizar una aplicacin en la que cargaremos los distintos cuadros de dialogo que nos
proporciona Swing.
- En el botn de maximizar, haremos la ventana tan grande como la pantalla.
- En el botn de dialogo, mostraremos una ventana que nos indique la versin de la aplicacin
y as con cada uno de los dilogos disponibles.
Dialogo..
www.learning.es
Archivo
import java.io.*;
import java.awt.*;
public class CuadrosDialogo extends javax.swing.JFrame {
/** Creates new form CuadrosDialogo */

public CuadrosDialogo() {
initComponents();
}
private void btndialogoActionPerformed(java.awt.event.ActionEvent evt) {

final JDialog ventana = new JDialog(this, "Acerca de..", true);
ventana.getContentPane().add(new JLabel("Aplicacion SWING", JLabel.CENTER), _
BorderLayout.CENTER);
JButton btncerrar = new JButton("Cerrar");
ventana.getContentPane().add(btncerrar, _
BorderLayout.SOUTH);
btncerrar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {

ventana.setVisible(false);
}
www.learning.es
});
ventana.setSize(200, 200);
ventana.setLocation(100, 100);
ventana.setVisible(true);
}
private void btncolorActionPerformed_

(java.awt.event.ActionEvent evt) {
Color col;
col = JColorChooser.showDialog(this,_
"Color de fondo", btncolor.getBackground());
if (col != null) {
btncolor.setBackground(col);
}
}
private void btnmaximizarActionPerformed_

int ancho, alto;
ancho = getToolkit().getScreenSize().width;
alto = getToolkit().getScreenSize().height - 30;
this.setSize(ancho, alto);
this.setLocation(0, 0);
}
private void btnframeActionPerformed(java.awt.event.ActionEvent evt) {

JFrame fr;
fr = new JFrame();
fr.setVisible(true);
}
private void btnarchivoActionPerformed(java.awt.event.ActionEvent evt) {

JFileChooser fd;
fd=new JFileChooser();
int respuesta=-1;
respuesta = JOptionPane.showConfirmDialog(this, "Desea abrir?");
if (respuesta == JOptionPane.OK_OPTION)
{
//ABRIR
fd.setDialogType(JFileChooser.OPEN_DIALOG);
fd.setDialogTitle("Abrir archivo");
fd.setCurrentDirectory(new File("C:\\"));
respuesta = fd.showOpenDialog(this);
if (respuesta == JFileChooser.APPROVE_OPTION) {
this.lblmsj.setText("Archivo abierto " + fd.getSelectedFile());
} else
{
this.lblmsj.setText("Accin CANCELADA");
}
} else if_
(respuesta == JOptionPane.CANCEL_OPTION) {
//GUARDAR
fd.setDialogType(JFileChooser.SAVE_DIALOG);
fd.setDialogTitle("Guardar archivo");
fd.setApproveButtonText("Guardar como...");
respuesta = fd.showSaveDialog(this);
www.learning.es
if (respuesta == JFileChooser._
APPROVE_OPTION)
{
this.lblmsj.setText("Archivo Guardado " + fd.getSelectedFile());
} else
{
this.lblmsj.setText("Accin CANCELADA");
}
}
}
private void btnOptionPaneActionPerformed_

int icono = -1;
String titulo, mensaje;
titulo = this.txttitulo.getText();
mensaje = this.txtmensaje.getText();
if (this.rdbadvertencia.isSelected())
{
icono = JOptionPane.WARNING_MESSAGE;
}
else if (this.rdbinformacion.isSelected())
{
icono = JOptionPane.INFORMATION_MESSAGE;
}
else if (this.rdbinterrogacion.isSelected())
{
icono = JOptionPane.QUESTION_MESSAGE;
}
else if (this.rdbsinicono.isSelected())
{
icono = JOptionPane.PLAIN_MESSAGE;
}
else
{
icono = JOptionPane.ERROR_MESSAGE;
}
if (this.rdbconfirmacion.isSelected())
{
JOptionPane.showConfirmDialog(this, mensaje, titulo, _
JOptionPane._
YES_NO_CANCEL_OPTION);
}
else if (this.rdbentrada.isSelected())
{
//Primero muestra una ventana que captura un_
texto y luego lo muestra en otra
String s="";
s = JOptionPane.showInputDialog(this, mensaje, titulo, icono);
JOptionPane.showMessageDialog(this, s, titulo, icono);
}
else
{
JOptionPane.showMessageDialog(this, mensaje, titulo, icono);
}
}
www.learning.es
}
Ver Video: Aplicaciones basadas en Interfaz Grfica,

en la Unidad 12, en el Mdulo 2, en la plataforma elearning
Actividades
www.learning.es
Unidad 13. Control de eventos generados por
la interfaz grfica
Introduccin
El modelo antiguo de eventos est basado en la herencia.

Para que un programa capture eventos de una interfaz grfica, los componentes deben ser
subclases de la interfaz y sobreescribir los mtodos action() y handleEvent().
Cuando uno de los mtodos devuelve true, el evento ya no es procesado ms all, en caso contrario,
el evento se propaga a travs de la jerarqua de componentes de la interfaz hasta que sea tratado o
alcance al jerarqua de componentes.
Hay dos elecciones para estructurar el cdigo de gestin de eventos:
Cada componente individual puede hacerse subclase para manejar especficamente un conjunto de
eventos.
Todos los eventos son manejados por un contenedor determinado (tendr que analizar sobre que
componente se ha producido).
Inconvenientes:
No se pueden filtrar eventos: los eventos son recibidos por los componentes, los manejen o no.
Problema de rendimiento con los eventos que se producen con mucha frecuencia.
Modelo nuevo de delegacin. (Source, Listener,

Adapter).
Los eventos ahora estn organizados en jerarquas de clases de eventos.
El nuevo modelo hace uso de:
Fuentes de eventos (source):

Son objetos que tiene la capacidad de detectar eventos y notificar a los receptores de eventos que
se han producido esos eventos.
Fuentes de Eventos Descripcin

Es la clase raz de la cual derivarn todos los eventos.
Tiene dos mtodos de inters que son:
EventObject Object getSource() --> Devuelve el objeto sobre el que se ha
producido el evento.
String toString() -->Da una representacin en forma de String.
Es la clase raz de la cual derivan todos los eventos del AWT.
Es una clase abstracta.
De inters son:
AWTEvent - Sus campos estticos que almacenan los valores para diferentes tipos
de eventos.
- El mtodo int getID() que devuelve un nmero entero que se
corresponde con el tipo de evento que se ha producido.
Evento de bajo nivel que indica que un componente se ha movido, ha
cambiado de tamao, ...
Deriva de AWTEvent.
ComponentEvent
Estos eventos se producen slo con propsitos de notificacin. El AWT
sigue funcionando correctamente aunque no se traten.
El evento es pasado a todos los ComponentListener o AdapterListener
www.learning.es
que se hayan registrado para recibir este tipo de eventos. Para
registrar un listener se usa el mtodo addComponentListener sobre el
objeto sobre el cual queremos recibir los eventos.
Son de inters:
- Sus campos que almacenan los valores que indican lo que ha
sucedido a nivel de componente: Si se ha movido, si se ha ocultado, ...
- El mtodo Component getComponent() para obtener el componente
en forma de objeto sobre el que se produjo el evento.
Se genera por objetos tipo Container cuando se aade o se quita un
objeto de l.
El evento es pasado a cada ContainerListener o AdapterListener que se
haya dado de alta mediante el mtodo addContainerListener() del
objeto sobre el que queremos obtener los eventos.
ContainerEvent (hereda
Caben destacar:
de ComponentEvent)
- Sus campos que almacenan el valor de lo que puede suceder: un
componente se ha aadido, se ha quitado, ...
- Sus mtodos: Container getContainer() que permite obtener el
contenedor sobre el que se produjo el evento y Component getChild()
obtiene el componente que lo produjo (al ser aadido, quitado, ...).
Fuente de eventos de bajo nivel que indica si la ventana ha cambiado
de estado (abrir, activar, minimizar, ...)
WindowEvent (hereda de El evento es pasado a cada WindowListener o WindowAdapter que se
ComponentEvent). haya registrado mediante el mtodo addWindowListener() para ser
notificados.
El mtodo getWindow() devuelve la ventana que gener el evento.
Es el evento raz de todos los eventos de entrada a nivel de
componente.
InputEvent (hereda de Sus dos fuentes de eventos hijas son: KeyEvent (para eventos
ComponentEvent). relacionados con el teclado) y MouseEvent (para eventos relacionados
con el ratn).
A continuacin vemos MouseEvent.
Indica que una accin de ratn ha sucedido sobre un componente.
Eventos de ratn
- Un botn del ratn es presionado.
- Un botn del ratn es liberado
- Un botn del ratn es clickeado (presionado y liberado)
- El cursor del ratn entra en un componente.
- El cursor del ratn sale del componente.
MouseEvent
Mouse Motion Events
- El ratn es movido.
- El ratn es arrastrado con botn pulsado (dragged)
Estos eventos se envan a los MouseListener y MouseAdapter que se
hayan registrado mediante el mtodo addMouseListener().
Dispone de una serie de mtodos tipo get (getX, getY, getPosition,
getClickCount para recoger informacin del evento).
Es un evento de alto nivel que indica que algo ha sucedido sobre un
componente. Algunos componentes usan este tipo de eventos en vez
de usar los de bajo nivel.
El protocolo para implementar correctamente este evento es mediante
ActionEvent
un ActionCommand.
Los componente disponen de un mtodo setActionCommand (string)
para asociarles un ActionCommand en concreto.
El evento dispone de un getActionCommand() mediante el cual poder
www.learning.es
identificar el ActionCommand.
Este evento se pasa a los ActionListener o ActionAdapter que se han
dado de alta mediante el mtodo addActionListener() para poder
recibir eventos de este tipo.
Ejemplos con eventos

ActionListener y WindowListener
Realizar un programa para cambiar el color de fondo de un Frame pulsando sobre los botones de
accin.
En este ejemplo vemos como generamos eventos para los cinco JButton.
import java.awt.*;

Button boton1,boton2,boton3,boton4,boton5;
public static void main(String[] args)
{
new EjSwing();
}
public EjSwing()
{
setLayout(new BorderLayout (20,20));
boton1=new Button ("Rojo");

//------------------
boton1.addActionListener( new ActionListener(){

getContentPane().setBackground (Color.red);
}
});
//------------------
add(boton1,BorderLayout.NORTH);
boton2= new Button("Verde");
//------------------

getContentPane().setBackground (Color.green);
}
});
//------------------
www.learning.es
add(boton2,"South");
boton3= new Button("Amarillo");
//------------------

getContentPane().setBackground (Color.yellow);
}
});
//------------------
add(boton3,"Center");
boton4= new Button("Azul");
//------------------

getContentPane().setBackground (Color.blue);
}
});
//------------------
add(boton4,"East");
boton5= new Button("Negro");
//------------------

getContentPane().setBackground (Color.black);
}
});
//------------------
add(boton5,BorderLayout.WEST);
setSize(300,200);
setResizable(false);
setLocation(100,100);
setBackground(Color.cyan);
setTitle("Ejemplo Eventos");
setVisible(true);
addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e)
{
System.exit(0);
dispose();
}
});
}
}
Clase SwingWorker
La clase SwingWorker es una clase de utilidad incluida en Java SE 6 que soluciona el problema de
utilizar un hilo (thread) separado al de Swing para realizar tareas de larga duracin.
El objetivo de esta clase es la de implementar en un hilo/thread separado, cualquier funcionalidad
que pudiera requerir mucho consumo de tiempo.
www.learning.es
Definiendo un SwingWorker
En el siguiente ejemplo veremos una forma de poder haber background sobre un componente.
private void jBtnCambiarActionPerformed(ActionEvent evt) {
_
ClaseWorker sw = new_
ClaseWorker ();
sw.addPropertyChangeListener(new _
PropertyChangeListener(){
public_
void propertyChange(PropertyChangeEvent evt) {
_
if(evt.getPropertyName().equals(Correcto))_
// Aqu podramos ir actualizando el cdigo del componente a modificar.

}
}
});
}_
class ClaseWorker extends javax.swing.SwingWorker_

{
protected Object doInBackground()_

throws Exception {
firePropertyChange_
(Correcto, null, NEW VALUE);
_
return null;
}
};
Laboratorio 1: Movimiento entre frames
Objetivo
Trabajar con ms de un Frame en un proyecto.
Enunciado
- Realizar una aplicacin en la que podremos movernos entre diferentes Frames que hayamos
creado previamente en nuestra aplicacin.
- Tendremos 3 ventanas JFrame, en cada una de las ventanas podremos pasar a la siguiente o
la anterior, dependiendo de la posicin del conjunto.
- En la ventana final podremos cerrar la aplicacin, o movernos entre las diferentes ventanas
que tengamos.
- Crearemos una clase principal que se encargar de iniciar la aplicacin, del movimiento y de
terminar la aplicacin.
www.learning.es
- Pondremos un control JProgressBar para saber dnde estamos posicionados en el conjunto
de ventanas.
CLASE PRINCIPAL PARA ADMINISTRAR LOS MOVIMIENTOS
En sta clase, los objetos sern compartidos (static) para poder acceder a ellos sin necesidad_
de crear instancias de objeto.
public class ClasePrincipalFrames {
static VariosFormularios f1 = new VariosFormularios();

static VariosFormularios2 f2 = new VariosFormularios2();
static VariosFormularios3 f3 = new VariosFormularios3();
public static void cambiarFrame(JFrame framenuevo, JFrame frameantiguo)

{
framenuevo.setVisible(true);
frameantiguo.setVisible(false);
}
public static void cerrarAplicacion()

{
System.exit(0);
}
public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
f1.setVisible(true);
www.learning.es
}
});
}
}
FRAME NUMERO 1
import java.awt.*;
public class VariosFormularios extends javax.swing.JFrame {
/** Creates new form VariosFormularios */

public VariosFormularios() {
initComponents();
this.setTitle("FRAME NUMERO 1");
this.getContentPane().setBackground(Color.YELLOW);
this.jProgressBar1.setValue(1);
}
private void btnsiguienteframeActionPerformed(java.awt.event.ActionEvent evt) {

ClasePrincipalFrames.cambiarFrame(ClasePrincipalFrames.f2, ClasePrincipalFrames.f1);
}
}
FRAME NUMERO 2
import java.awt.*;
public class VariosFormularios2 extends javax.swing.JFrame {
/** Creates new form VariosFormularios2 */

public VariosFormularios2() {
initComponents();
this.getContentPane().setBackground(Color.BLUE);
}
private void btnanteriorframeActionPerformed(java.awt.event.ActionEvent evt) {

}
private void btnsiguienteframeActionPerformed(java.awt.event.ActionEvent evt) {

}
}
FRAME NUMERO 3
import java.awt.*;
public class VariosFormularios3 extends javax.swing.JFrame {
www.learning.es
/** Creates new form VariosFormularios3 */
public VariosFormularios3() {
initComponents();
this.getContentPane().setBackground(Color.MAGENTA);
}
private void btnfinalActionPerformed(java.awt.event.ActionEvent evt) {

ClasePrincipalFrames.cerrarAplicacion();
}
private void btnanteriorActionPerformed(java.awt.event.ActionEvent evt) {

}
private void btnirframeActionPerformed(java.awt.event.ActionEvent evt) {

int indice;
indice = this.cmbframes.getSelectedIndex();
if (indice == 0)
{
}
else
{
}
}
}
Laboratorio 2: Cargador de imgenes

Objetivo
Trabajar con componentes grficos.
Enunciado
- Realizar una aplicacin para cargar imgenes dinmicamente desde una ruta dada.
- Tendremos la posibilidad de cambiar el tamao de la imagen a nuestra conveniencia,
dependiendo si queremos darle un tamao fijo (300,300) o queremos darle uno
personalizado con las cajas TextField.
- Al pulsar sobre Cargar Imagen, abriremos un cuadro de dialogo de Ficheros para
seleccionar el archivo de imagen a cargar.
- Crearemos una clase JIMAGENPANE para dibujar la imagen sobrescribiendo el mtodo
paintComponent de la clase super.
www.learning.es
import java.awt.*;
import java.io.*;
public class DibujarImagenes extends javax.swing.JFrame {

JImagenPane pimg;
/** Creates new form DibujarImagenes */
public DibujarImagenes() {
initComponents();
String fichero = "C:\\CARTELES\\dostontosmuytontos.jpg";
pimg = new JImagenPane(fichero);
pimg.setSize(300, 300);
this.getContentPane().add(pimg);
this.setTitle("Cargador de Imagenes");
validate();
}
private void btncargarimagenActionPerformed(java.awt.event.ActionEvent evt) {

int alto, ancho;
JFileChooser fd;
String archivoimagen = "";
fd = new JFileChooser();
int respuesta = -1;
fd.setDialogType(JFileChooser.OPEN_DIALOG);
fd.setDialogTitle("Abrir archivo");
fd.setCurrentDirectory(new File("C:\\"));
respuesta = fd.showOpenDialog(this);
if (respuesta == JFileChooser.APPROVE_OPTION) {
archivoimagen = fd.getSelectedFile().getAbsolutePath();
alto = 300;
ancho = 300;
if (this.rdbfijo.isSelected()) {
pimg.setSize(300, 300);
this.pimg.nuevaImagen(archivoimagen);
} else {
alto = Integer.parseInt(this.txtalto.getText());
ancho = Integer.parseInt(this.txtancho.getText());
pimg.setSize(ancho, alto);
this.pimg.nuevaImagen(archivoimagen, alto, ancho);
}
}
}
Realizar despus la prctica con un JLABEL y utilizando el mtodo setIcon()
www.learning.es
private ImageIcon getIcono(String ico,Dimension tam)
{
int ancho=tam.width;
int alto=tam.height;
ImageIcon img = new ImageIcon(ico);
img = new ImageIcon(img.getImage().getScaledInstance(ancho, alto,
Image.SCALE_AREA_AVERAGING));
return img;
}
CLASE JIMAGENPANE
import java.awt.*;
public class JImagenPane extends JPanel {
private Image im; //imagen a pintar
public JImagenPane(String fichero) {

im = this.getToolkit().getImage(fichero);
}
public void paintComponent(Graphics g) {

super.paintComponent(g);
g.drawImage(im, 0, 0, this);
}
public void nuevaImagen(String fichero) {

im = im.getScaledInstance(this.getWidth(), this.getHeight(),Image._
SCALE_AREA_AVERAGING); repaint();
}
public void nuevaImagen(String fichero, int alto, int ancho) {

im = im.getScaledInstance(ancho, alto,Image.SCALE_AREA_AVERAGING);
repaint();
}
}
Actividades
www.learning.es
Unidad 14. Aplicaciones basadas en la
interfaz grfica
Introduccin
En Swing disponemos de cuatro calse importantes para la creacin de interfaces basadas en la
creacin de menes que son: JMenu, JMenuBar, JMenuItem y JPopupMenu. Un men en una
aplicacin no es ms que un JMenuBar en el que hay varios mens como veremos en esta unidad.
En esta imagen podemos apreciar las diferentes secciones a las que hacen referencia las clases
relacionadas con mens de Java:
Objetivos
Conocer las principales clases en la elaboracin de mens con java
Aprender a realizar un toolbar con java
Creacin de un men
Las tres clases ms importantes para crear un men son las siguientes:
JMenuBar
Representa la barra en la que voy a guardar mis menus.
JMenu
Son las opciones del men que insertaremos sobre el JMenBar, normalmente llamamos men por
ejemplo el men "Archivo", "Insertar", "Formato", etc.
JMenuItem
Los elementos de un men se representan mediante la clase JMenuItem.
Ejemplo guardar, guardar como del Jmenu de Archivo.
Jerarqua de clases para realizar un men:
www.learning.es
Ejemplo de creacin de un Men:
En el siguiente ejemplo crearemos un Men con las opciones archivo y editar como se muestra en la
imagen.
public EjSwing(){
//Creacin de un JMeunuBar, clase principal.
JMenuBar menuPrincipal = new JMenuBar();
JMenu menuArchivo = new JMenu("Archivo");
JMenu menuEditar = new JMenu("Editar");
menuPrincipal.add(menuArchivo);
menuPrincipal.add(menuEditar);
//Construimos los JMenuItem del JMenu de Archivo
JMenuItem Guardar = new JMenuItem("Guardar");

JMenuItem GuardarC = new JMenuItem("Guardar como");
JMenuItem Imprimir = new JMenuItem("Imprimir");
JMenuItem Cerrar = new JMenuItem("Cerrar");
menuArchivo.add(Guardar);
menuArchivo.add(GuardarC);
menuArchivo.add(Imprimir);
menuArchivo.add(new JSeparator());
menuArchivo.add(Cerrar);
//Agregamos el Men al JFrame.
setJMenuBar(menuPrincipal);
}
new EjSwing().setVisible(true);}
}
www.learning.es
Creacin de un Toolbar
Un objeto JToolBar crea una barra de herramientas para la insercin de componentes dentro de una
fila o una columna. Normalmente las barras de herramientas proporcionan acceso a funcionalidades
que tambin se encuentran en tems de mens.
En esta figura se aprecia un toolbar creado en una aplicacin distribuida
Ejemplo de creacin de un Toolbar:

En el siguiente ejemplo crearemos una barra de herramientas con tres botones dentro de la barra
como se muestra en la imagen.
static JFrame formulario = new JFrame();
//Creamos un toolbar con nombre y orientacion horizontal.
static JToolBar jtb1 = new JToolBar("Barra de Herramientas",0 );
static JButton bot1 = new JButton("Abrir");
static JButton bot2 = new JButton("Guardar");
static JButton bot3 = new JButton("Imprimir");
// parte principal de programa

public static void main(String[] args)
{
formulario.setTitle("Ejemplo Toolbar");
formulario.setDefaultCloseOperation(formulario.EXIT_ON_CLOSE);
//Insertamos los componentes en el Toolbar.
jtb1.add(bot1);
jtb1.add(bot2);
jtb1.add(bot3);
// Insertamos el Toolbar en el formulario
formulario.getContentPane().add(jtb1);
formulario.pack();
formulario.setVisible(true);
}
}
Tambin podemos insertar iconos en la barra de herramientas:
www.learning.es
ImageIcon ImagenGuardar=new ImageIcon("guardar.gif");
bot1.setIcon(ImagenGuardar);
Sus propiedades ms comunes son:

Autoscrolls(), Background(), Border(), Bounds(), Cursor(), Enabled(), Font(),
Foreground(),Floatable(), Insets(), Layout(), Margin(), Name(), Opaque(), Orientation(),
ToolTipText(), Visible(), VisibleRect().
Sus eventos ms comunes son:

WINDOW:
WindowActivated(), WindowClosed(), WindowClosing(), WindowDeactivated(), WindowOpened().
MOUSE:
MouseClicked(), MouseDragged(),MouseEntered(), MouseExited(),MouseMoved(), MousePressed(),
MouseReleased().
KEY:
KeyPressed(), KeyReleased(), KeyTyped().
JPopupMenu
Un JPopupMenu es conocido con el nombre de menu contextual, este es el menu que sale
normalmente al dar clic derecho en el escritorio o en casi cualquier programa.
Creacin de un JPopupMenu
// Demostracin de los objetos JPopupMenu

import java.awt.*;
public class PruebaContextual extends JFrame {

private JRadioButtonMenuItem elementos[];
private final Color valoresColor[] =
{ Color.BLUE, Color.YELLOW, Color.RED };
private JPopupMenu menuContextual;
// configurar GUI
public PruebaContextual()
{
super( "Uso de objetos JPopupMenu" );
ManejadorEventos manejador = new ManejadorEventos();
www.learning.es
String colores[] = { "Azul", "Amarillo", "Rojo" };
// establecer men contextual y sus elementos

ButtonGroup grupoColores = new ButtonGroup();
menuContextual = new JPopupMenu();
elementos = new JRadioButtonMenuItem[ 3 ];
// construir cada elemento de men y agregarlo al men contextual; adems

// permitir el manejo de eventos para cada elemento de men
for ( int cuenta = 0; cuenta < elementos.length; cuenta++ ) {
elementos[ cuenta ] = new JRadioButtonMenuItem( colores[ cuenta ] );
menuContextual.add( elementos[ cuenta ] );
grupoColores.add( elementos[ cuenta ] );
elementos[ cuenta ].addActionListener( manejador );
}
getContentPane().setBackground( Color.WHITE );
// declarar un objeto MouseListener para la ventana que muestra

// un objeto JPopupMenu cuando ocurre el evento de desencadenamiento del men contextual
getContentPane().addMouseListener(
new MouseAdapter() { // clase interna annima
// manejar evento de oprimir botn del ratn

public void mousePressed( MouseEvent evento )
{
checkForTriggerEvent( evento );
}
// manejar evento de soltar el botn del ratn

public void mouseReleased( MouseEvent evento )
{
checkForTriggerEvent( evento );
}
// determinar si evento debe desencadenar el men contextual

private void checkForTriggerEvent( MouseEvent evento )
{
if ( evento.isPopupTrigger() )
menuContextual.show(
evento.getComponent(), evento.getX(), evento.getY() );
}
} // fin de la clase interna annima
); // fin de la llamada a addMouseListener
setSize( 300, 200 );

setVisible( true );
} // fin del constructor de PruebaContextual
public static void main( String args[] )

{
JFrame.setDefaultLookAndFeelDecorated(true);
PruebaContextual aplicacion = new PruebaContextual();
www.learning.es
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
// clase interna privada para manejar eventos de elemento de men

private class ManejadorEventos implements ActionListener {
// procesar selecciones de elementos de men

public void actionPerformed( ActionEvent evento )
{
// determinar cul elemento de men fue seleccionado
for ( int i = 0; i < elementos.length; i++ )
if ( evento.getSource() == elementos[ i ] ) {
getContentPane().setBackground( valoresColor[ i ] );
return;
}
}
} // fin de la clase interna privada ManejadorEventos
} // fin de la clase PruebaContextual
Ver Video: Creacin de un Toolbar, en la Unidad 14,

Actividades
www.learning.es
Unidad 15 . Hilos
Introduccin
Todos los ejemplos que hemos realizado hasta este punto han sido desarrollados con un solo hilo de
ejecucin, es decir, nicamente realizamos una tarea.
La programacin multihilo o multitarea permitir lanzar varias acciones dentro de un mismo
programa, de esta manera podremos realizar distintas tareas simultneamente. El sistema con el
que estemos trabajando se encargar de la ejecucin concurrente de ambas tareas.
Es importante comentar que cada thread se ejecutar de forma absolutamente independiente. Cada
uno trabaja como si tuviese un microprocesador para el solo. Por lo que si tenemos una zona de
datos compartida entre varios threads de modo que puedan intercambiar informacin entre ellos, es
necesario usar algn sistema de sincronizacin para evitar que uno de ellos acceda a un grupo de
datos que pueden estar a medio actualizar por otro thread.
Clases para trabajar con thread
CLASE DEFINICIN
Un objeto Thread representa a una tarea en ejecucin. Aqu se implementan
Thread
mtodos que van a permitir gestionar tareas individualmente.
Un objeto de este tipo representa a un conjunto de Threads y proporciona mtodos
ThreadGroup
para gestionar dicho grupo.
Ciclo de vida de un thread
Inicio tarea
Cuando se crea una nueva tarea, sta no se arranca automticamente sino que hay que usar el
mtodo start().Hasta que no se arranca la tarea, sta permanece en el estado Nueva tarea.
Ejecutar la tarea
Cuando iniciamos una tarea se desencadena la llamada a dos mtodos:
start() : Mtodo que crea los recursos necesarios para que la tarea se pueda ejecutar. No
conviene sobreescribir este mtodo, el cual se implementa en la clase Thread.
run(): Mtodo equivalente al main de las aplicaciones que hemos realizado hasta ahora. En
este mtodo es dnde el programador deber poner el cdigo que desea que se ejecute en la
tarea.
Detener la tarea
Una tarea se puede detener por los siguientes motivos:

Llamando al mtodo sleep().
Cuando la tarea usa su mtodo wait() para esperar a que se cumpla una condicin.
Cuando la tarea queda bloqueada en algn proceso de E/S.
Cada una de esas entradas al estado Parada, tiene su vuelta al estado
Si paramos una tares se puede volver a ejecutar de la siguiente manera:

Si se par con sleep(), pasado el tiempo especificado.
www.learning.es
Si se par por una operacin de E/S, cuando dicha operacin se realice.
Si se par por wait(), llamando al mtodo notify() o notifyAll() y que la condicin por la que
se espera se cumpla. Se llamar por tanto a alguno de esos mtodos cuando la variable que
controla condicin vare.
Primer ejemplo de hilos

En el siguiente ejemplo creamos tres clases, la clase principal(Ejemplo1.java) lanza la segunda clase
que es un programa que muestra la hora(hora.java), adems lanzar la tercera clase que es un
programa que solicita informacin por teclado(teclado.java).
Ejemplo1.java
public class Ejemplo1{

{
Teclado t1=new Teclado();

Hora t2=new Hora();
t2.start();
new Thread(t1).start();
Hora.java
import java.util.*;
public class Hora extends Thread{
public Hora(){
System.out.println("Constructor de Hora");
public void run(){
Date fecha=new Date();
System.out.println("Mtodo Run de Teclado");
try{
for (int i=0;i<15;++i){
System.out.println("Fecha: "+ fecha.toString());

sleep(5000);
}
}
catch(InterruptedException e){
System.out.println("ERROR");
www.learning.es
}
}
Teclado.java
import java.io.*;
public class Teclado implements Runnable{
BufferedReader bin;
public Teclado(){
System.out.println("Constructor de Teclado");
bin=new BufferedReader(new InputStreamReader(System.in));
}
public void run(){
String linea="";
System.out.println("Mtodo Run de Teclado");
try{
for (int i=0;i<15;++i){
System.out.println("Introduzca lnea de texto:");

linea=bin.readLine();
System.out.println("Usted escribi: "+linea);
}
}
catch(IOException e){
}
}
}
SALIDA DEL PROGRAMA:
www.learning.es
Mtodos de la clase Thread
start()
Este mtodo indica al intrprete de Java que cree un contexto del hilo del sistema y comience a
ejecutarlo. A continuacin, el mtodo run() de este hilo ser invocado en el nuevo contexto del hilo.
Hay que tener precaucin de no llamar al mtodo start() ms de una vez sobre un hilo determinado.
run()
El mtodo run() constituye el cuerpo de un hilo en ejecucin. Este es el nico mtodo del interfaz
Runnable. Es llamado por el mtodo start() despus de que el hilo apropiado del sistema se haya
inicializado. Siempre que el mtodo run() devuelva el control, el hilo actual se detendr.
stop()
Este mtodo provoca que el hilo se detenga de manera inmediata. A menudo constituye una manera
brusca de detener un hilo, especialmente si este mtodo se ejecuta sobre el hilo en curso. En tal
caso, la lnea inmediatamente posterior a la llamada al mtodo stop() no llega a ejecutarse jams,
pues el contexto del hilo muere antes de que stop() devuelva el control. Una forma ms elegante de
detener un hilo es utilizar alguna variable que ocasione que el mtodo run() termine de manera
ordenada
currentThread()
Este mtodo devuelve el objeto thread que representa al hilo de ejecucin que se est ejecutando
actualmente.
sleep( long )
El mtodo sleep() provoca que el intrprete ponga al hilo en curso a dormir durante el nmero de
milisegundos que se indiquen en el parmetro de invocacin. Una vez transcurridos esos
milisegundos, dicho hilo volver a estar disponible para su ejecucin. Los relojes asociados a la
mayor parte de los intrpretes de Java no sern capaces de obtener precisiones mayores de 10
milisegundos, por mucho que se permita indicar hasta nanosegundos en la llamada alternativa a
este mtodo.
yield()
Este mtodo hace que el intrprete cambie de contexto entre el hilo actual y el siguiente hilo
ejecutable disponible. Es una manera de asegurar que nos hilos de menor prioridad no sufran
inanicin.
suspend()
El mtodo suspend() es distinto de stop(). suspend() toma el hilo y provoca que se detenga su
ejecucin sin destruir el hilo de sistema subyacente, ni el estado del hilo anteriormente en ejecucin.
Si la ejecucin de un hilo se suspende, puede llamarse a resume() sobre el mismo hilo para lograr
que vuelva a ejecutarse de nuevo.
resume()
El mtodo resume() se utiliza para revivir un hilo suspendido. No hay garantas de que el hilo
comience a ejecutarse inmediatamente, ya que puede haber un hilo de mayor prioridad en ejecucin
actualmente, pero resume() ocasiona que el hilo vuelva a ser un candidato a ser ejecutado.
www.learning.es
getPriority()
Este mtodo devuelve la prioridad del hilo de ejecucin en curso, que es un valor comprendido entre
uno y diez.
setPriority( int )
El mtodo setPriority() asigna al hilo la prioridad indicada por el valor pasado como parmetro. Hay
bastantes constantes predefinidas para la prioridad, definidas en la clase Thread, tales como
MIN_PRIORITY, NORM_PRIORITY y MAX_PRIORITY, que toman los valores 1, 5 y 10,
respectivamente. Como gua aproximada de utilizacin, se puede establecer que la mayor parte de
los procesos a nivel de usuario deberan tomar una prioridad en torno a NORM_PRIORITY. Las tareas
en segundo plano, como una entrada/salida a red o el nuevo dibujo de la pantalla, deberan tener
una prioridad cercana a MIN_PRIORITY. Con las tareas a las que se fije la mxima prioridad, en
torno a MAX_PRIORITY, hay que ser especialmente cuidadosos, porque si no se hacen llamadas a
sleep() o yield(), se puede provocar que el intrprete Java quede totalmente fuera de control.
getName()
Este mtodo devuelve el valor actual, de tipo cadena, asignado como nombre al hilo en ejecucin
mediante setName().
setName( String )
Este mtodo permite identificar al hilo con un nombre menmnico. De esta manera se facilita la
depuracin de programas multihilo. El nombre mnemnico aparecer en todas las lneas de trazado
que se muestran cada vez que el intrprete Java imprime excepciones no capturadas.
Uso de Wait y Notify

Los mtodos wait(), notify() y notifyAll() deben ser llamados desde un contexto sincronizado.
El mtodo wait() permite a un hilo pausar su ejecucin hasta que se le notifique que ocurri algo de
lo que se tiene que encargar.
El mtodo notify() se utiliza para enviar una seal a un y solo un hilo que se encuentra esperando.
El mtodo notify() no permite especificar que hilo en espera se va a notificar.
El mtodo notifyAll() funciona del mismo modo que notify, a diferencia que enva seales a todos los
hilos esperando por un objeto.
Ejemplo del uso de estos mtodos
En el siguiente ejemplo usamos los mtodos wait() y notify() con el objetivo de hacer esperar al
lector hasta que el escritor rellene los nuevos campos.
Principal.java
import java.io.*;
public class Principal{
public static void main (String args[]) throws IOException{
Ficha f1=new Ficha("hola","hola","hola",1);
Ficha[] fichas={f1};
www.learning.es
Actualiza ac=new Actualiza(fichas);
Leer le=new Leer(fichas,ac);
ac.start();
le.start();
Leer.java
import java.io.*;
public class Leer extends Thread{
Ficha[] fichas;
Actualiza ac;
public Leer(Ficha[] fichas, Actualiza ac){
System.out.println("Constructor de Leer");
this.fichas=fichas;
this.ac=ac;
public void run(){
System.out.println("Mtodo Run de Leer");

leer();
public void leer(){
try{
ac.sincronizar(true);
System.out.println(fichas[0].texto());
sleep(5000);
}
}
www.learning.es
}
Ficha.java
/** Objeto que contiene los datos y operaciones de una Ficha de la Agenda. */
public class Ficha implements java.io.Serializable

{
protected String nombre;
protected String apellidos;
protected String direccion;
protected int telefono;
/** Construye una Ficha nueva con sus datos. */

public Ficha(String nombre, String apellidos, String direccion, int telefono)
{
this.nombre=nombre;
this.apellidos=apellidos;
this.direccion=direccion;
this.telefono=telefono;
}
/** Devuelve el texto con el contenido de esta Ficha. */

public String texto()
{
String texto="________________________________________\n"+
"Nombre : "+nombre+"\n"+
"Apellidos: "+apellidos+"\n"+
"Direccion: "+direccion+"\n"+
"Telefono : "+telefono+"\n"+
"________________________________________\n";
return texto;
}
}
Actualiza.java
import java.io.*;
public class Actualiza extends Thread{
BufferedReader bin;
Ficha [] fichas;
public Actualiza(Ficha[] fichas){
System.out.println("Constructor de Actualiza");
bin=new BufferedReader(new InputStreamReader(System.in));
this.fichas=fichas;
public void run(){
System.out.println("Mtodo Run de Actualiza");
www.learning.es
actualiza();
// El mtodo wait() y notify() deben estar dentro de un mtodo

// sincronizado. Con una variable boolena controlamos si hay
// que ejecutar wait o notify.
public synchronized void sincronizar(boolean b){
if (b){
try{
wait();
}
}
}
else{
notifyAll();
}
public void actualiza(){
String linea="";
System.out.println("Comenzando la actualizacin");
try{
System.out.println("Introduzca nombre:");
fichas[0].nombre=bin.readLine();
System.out.println("Introduzca apellidos:");
fichas[0].apellidos=bin.readLine();
System.out.println("Introduzca direccion:");
fichas[0].direccion=bin.readLine();
System.out.println("Introduzca telefono:");
fichas[0].telefono=Integer.parseInt(bin.readLine());
sincronizar(false);
}
}
}
}
www.learning.es
Sincronizacin
Uso
La cuestin cuando se trabaja con threads es que la ejecucin avanza en varias partes del programa
a la vez. Cada una de esas ejecuciones simultneas pueden tocar los mismos objetos.
Los mtodos synchronized previenen que ms de un hilo acceda al cdigo de un mtodo crtico
simultneamente.
Para sincronizar un bloque de cdigo, se debe especificar un argumento que es el objeto que se
utilizara como cerradura para la sincronizacin.
Se puede utilizar la palabra clave synchronized como un modificador de un mtodo, o como un
iniciador de un bloque de cdigo sincronizado.
Mientras que solo un hilo puede acceder al cdigo sincronizado de una instancia en particular,
mltiples hilos pueden acceder al cdigo no sincronizado de una misma instancia.
Cuando un hilo se duerme, su cerradura no se encuentra disponibles para otros hilos.
Ejemplo de sincronizacin
En el ejemplo anterior podemos modificar la clase Ficha de tal manera que las operaciones de
lectura queden bloqueadas hasta que terminen las de escritura.
import java.io.*;
public class Ficha implements java.io.Serializable

{
protected String nombre;
protected String apellidos;
protected String direccion;
protected int telefono;
/** Construye una Ficha nueva con sus datos. */

public Ficha(String nombre, String apellidos, String direccion, int telefono)
{
this.nombre=nombre;
this.apellidos=apellidos;
this.direccion=direccion;
this.telefono=telefono;
}
/** Devuelve el texto con el contenido de esta Ficha. */

public String texto()
{
String texto="________________________________________\n"+
"Nombre : "+nombre+"\n"+
"Apellidos: "+apellidos+"\n"+
"Direccion: "+direccion+"\n"+
"Telefono : "+telefono+"\n"+
"________________________________________\n";
return texto;
}
public synchronized void operar(int opcion){
BufferedReader bin=new BufferedReader(new

switch (opcion){
case 1: try{
www.learning.es
System.out.println("Introduzca nombre:");
this.nombre=bin.readLine();
System.out.println("Introduzca apellidos:");
this.apellidos=bin.readLine();
System.out.println("Introduzca direccion:");
this.direccion=bin.readLine();
System.out.println("Introduzca telefono:");
this.telefono=Integer.parseInt(bin.readLine());
}
break;
case 2: System.out.println(this.texto());
break;
System.out.println("Saliendo del mtodo operar");

}
Actividades
www.learning.es
Unidad 16. Programacin en red
Introduccin
Java tiene como ventaja frente a otros lenguajes de programacin el que puede programarse en
red.
Al igual que las personas tenemos nuestro DNI para identificarnos, los ordenadores dentro de la red
tienen un identificador la DIRECCIN IP.
La comunicacn entre los equipos se realiza mediante dos protocolos de transmisin:

TCP/IP: Transmisin Control Protocol / Internet Protocol.
UDP: UserDatagramProtocol.
Un PROTOCOLO es un conjunto de normas que si se cumple nos asegura una comunicacin.

Dependiendo de lo que vaya a hacer usare un protocolo u otro.
TCP/IP: Mas seguro. Enva informacin de una maquina a otra. Esta informacin se enva en tramas
que son bloques de informacin que van codificadas en bytes(0 y 1).
Este protocolo enva las tramas, en el caso de producirse perdidas reenviarlas y una vez llegadas al
destino ordenarlas.
Adems de protocolo se necesita un puerto. Son numricos. Es el mecanismo por el que entra
informacin en la maquina o por el que la maquina enva informacin.
UDP: Es el protocolo universal de datos. Es el mas rpido y menos seguro. A una direccin manda
informacin y no se preocupa de que la direccin exista, le llegue, etc. Valido para intranets. Las
tramas si se pierden no se retransmiten y no las ordenan a la llegada.
Clase InetAddress
Esta clase que pertenece al paquete java.Net podemos capturar las direcciones o nombres de las
mquinas.
Ejemplo
//Este ejemplo nos dice la direccion de la maquina donde estamos trabajando

import java.net.*;
public class EjemploInetAddress{

try{
InetAddress mimaquina = InetAddress.getLocalHost();
System.out.println("Mi maquina es "+mimaquina);
}catch(UnknownHostException e){
System.out.println("No encuentro el servidor");
e.printStackTrace(); //Escribe el error que genera
}
}
}
Mtodos de la clase
getLocalHost(): Devuelve el nombre de la maquina y la direccin IP. Para llamarlo

InetAddress.getLocalHost().
www.learning.es
getHostAddress(): Devuelve una cadena con la direccin IP. Para llamarlo
nombre_objeto.getHostAddress().
getHostName(): Devuelve una cadena con el nombre de la mquina. Para llamarlo

nombre_objeto.getHostName().
getByName( String): Determina la direccin IP del host a partir del nombre del host. Para llamarlo
InetAddress getByName(nombre).
getAddress(): Mete la direccin IP en una matriz byte.

Para llamarlo miarray= nombre_objeto.getAddress();
getAllByName(): Devuelve todas las direcciones IP en una matriz a partir del nombre del host. Por
ejemplo Sun puede tener con un nombre muchas direcciones IP. Para llamarlo:
nombrearray= objetoInetAddres.getAllByName().
Realizar Laboratorio: Uso de la clase InetAddress
Objetivos
Manejar los mtodos ms importantes de la clase InetAddress.
Enunciado
Crear un clase que utilice los mtodos ms importantes de la clase InetAddress y muestre la
informacin siguiente:
Mi maquina es .getLocalHost() Pc001/192.168.1.55

Direccion .getHostAddress() 192.168.1.34
Nombre .getHostName() Pc001
Nombre .getByName( nombre)Pc001/192.168.1.55
Con la matriz .getAddress() 192

Solucin:
public class Enjemplo{
InetAddress mimaquina;
byte matriz[];
try{
//Muestro nombre-ip
mimaquina = InetAddress.getLocalHost();
System.out.println("Mi maquina es .getLocalHost() "+mimaquina);
//Muestro solo la ip
System.out.println("Direccion .getHostAddress() "+
mimaquina.getHostAddress());
//Muestro el nombre
String nombre= mimaquina.getHostName();
System.out.println("Nombre .getHostName() "+nombre);
www.learning.es
//Muestro un host a partir de un string
mimaquina= InetAddress.getByName( nombre);
System.out.println("Nombre .getByName( nombre)"+mimaquina);
//Muestro la direccion que meti en una matriz
matriz= mimaquina.getAddress();
System.out.println("Con la matriz .getAddress()"+ new
String(matriz));
for (int i=0; i<matriz.length;i++){

System.out.println("Con la matriz .getAddress() "+_
((matriz[i]+256)%256));
//Tambien vale System.out.println("Con la matriz .getAddress() "+ ((matriz[i]&255)));
}
e.printStackTrace(); //Escribe el error que genera
}
}
}
Socket
Un Socket es un mtodo para la comunicacin entre un programa del cliente y un programa del
servidor en una red. Un socket se define como el punto final en una conexin El Socket es donde el
cliente o el servidor escriben la informacin que transferimos.
Las clases Socket y ServerSocket del paquete java.net proporcionan un canal de comunicacin
independiente del sistema utilizando TCP, cada una de las cuales implementa el lado del cliente y el
servidor respectivamente.
Ejemplo
En el siguiente ejemplo nos encargamos de leer la informacin que nos est entrando.
import java.net.*;
import java.io.*;
public class ejSocket{
try{
Socket misocket = new Socket("Servidor ",13);
//Creacin de flujo para recibir datos

BufferedReader in = new BufferedReader(new InputStreamReader(
misocket.getInputStream()));
String texto;
while ((texto=in.readLine())!=null){
System.out.println(texto);
}
//Cerrar el Socket que hemos abierto
misocket.close();
}catch (UnknownHostException uhe){
www.learning.es
System.out.println("Error entrada salida");
}
}
}
Mtodos de la clase Socket
getInputStream() : Abrir el canal de entrada de informacin
getOutputStream(): Abrimos el canal salida
close() : Cerramos el Socket
InetAddress getInetAddress() : Devuelve un objeto InetAddress con el nombre y la direccin de la

maquina a la que estamos conectados.
InetAdress ia:nombre_socket.getInetAdress();
int getPort(): Devuelve el numero de puerto al que estamos conectados.

int puerto = n_socket.getPort();
InetAdress getLocalAddress() : Devuelve nuestra direccin.

InetAdress a = nom_socket.getLocalAddress().
int getLocalPort() : Devuelve el puerto desde el que nos conectamos

int puerto = n_socket.getLocalPort();
Ejemplo de utilizacin de algunos de los mtodos
import java.io.*;
import java.net.*;
public class Cliente{
try{
Socket misocket = new Socket("200.200.1.12",8810);

BufferedReader in = new BufferedReader(new InputStreamReader( misocket.getInputStream()));
//Leer
String texto= in.readLine();
System.out.println(texto);
PrintWriter out = new PrintWriter

(misocket.getOutputStream(),true);
out.println("Hola");
InetAddress a = misocket.getInetAddress();
System.out.println("misocket.getInetAdrress() "+a);
System.out.println("Puerto al que estamos conectados_
"+misocket.getPort());
a=misocket.getLocalAddress();
System.out.println("misocket.getLocalAdress()="+a);
System.out.println("Puerto desde el que estamos_
conectados "+misocket.getLocalPort());
www.learning.es
//Siempre hay que cerrar el Socket que hemos abierto
misocket.close();
}catch (UnknownHostException uhe){
System.out.println("Error entrada salida");
}
}
}
Podemos limitar el tiempo de espera del cliente a recibir del servidor, si no conecta o no recibe nada
salta la excepcin y se desconecta, para que no est esperando infinitamente y que se desconecte
tras el si no ha conseguido conectarse.
setSoTimeout( tiempo_milisegundo);
//Intento de connexion a un servidor

import java.net.*;
import java.io.*;
import java.util.*; //Para la fecha
public class hora {

try{
System.out.println("La hora de Madrid es: "+new Date()); _
//Muestro la hora de mi equipo
Socket miSocket = new Socket("www.whitehouse.net",13); _

//El puerto que da la hora es el 13
miSocket.setSoTimeout(10000); //Si no conecto en _
10 segundos me salgo
//Abro el flujo de comunicacin
BufferedReader in = new BufferedReader(new
InputStreamReader_
( miSocket.getInputStream()));
//Muestro lo que nos llega
System.out.println("La hora de la Casa Blanca: "+in.readLine());
}catch (InterruptedIOException e){
//Si en 10 segundos no conecta lanza esta excepcion
System.out.println("Interrupted");
e.printStackTrace();
System.out.println("IO");
}
}
}
CLASE URL
Gracias a la clase URL vamos a tener la posibilidad de descargarnos el cdigo fuente de una pgina
html. Luego podemos hacer un programa que interprete ese cdigo y los transforme en elementos
java.
www.learning.es
Tambin nos va a permitir obtener informacin del servidor al que nos conectamos.
URL: Localizador Uniforme de Recursos. Con esto nos vamos a poder descargar cualquier recurso de
la red.
Posibilidades:
Descargarnos cualquier recurso de la web.
Informacin del servidor: fecha de creacin....
Comunicacin de varios ordenadores
Cmo creamos un objeto URL?
URL miurl = new URL (*);

Hay muchos constructores, dependiendo de lo que pongamos en vez de *:
http://java.sun.com/index.html. La direccin de la pgina, un archivo.
http://java.sun.com/products. Con un directorio.
(nombre_protocolo, nombreHost, puerto, nombre_archivo)

(http,java.sun.com,80,FAQ.html)
Ejemplo de como podramos unir dos direcciones
import java.net.*;
public class ejemplo_constructor_URL {

try{
URL url_principal = new URL ("http://java.sun.com/index.html");
URL url_absoluta= new URL (url_principal,"products/jsse/index_103.html");
//Con eso juntaria las dos
//Otra podria ser URL url_absoluta= new URL (url_principal,"FAQ.html");
System.out.println(url_absoluta.toString());
}catch(MalformedURLException e){
System.out.println("URL mal formada");
}
}
}
Mtodos de la clase URL
String getProtocol() : Devuelve el protocolo del URL.

String getHost():Devuelve el Host del objeto URL.
int getPort(): Nos devuelve el puerto del URL. Si no hemos inicializado el URL con el puerto, nos
devuelve 1.
String getFile(): Devuelve el archivo especificado en el URL. Devuelve null si no lo he especificado.
Ejemplo del uso de estos mtodos
import java.net.*;
www.learning.es
public class ejemplo_constructor_URL {
try{
URL url_principal = new URL ("http://java.sun.com/principal.html");
URL url_absoluta= new URL (url_principal,"products/jjj/index5555.html");
System.out.println(url_absoluta.toString());
System.out.println("Protocolo = "+url_absoluta.getProtocol());
System.out.println("Host = "+url_absoluta.getHost());
System.out.println("Puerto = "+url_absoluta.getPort());
System.out.println("File = "+url_absoluta.getFile());
}catch(MalformedURLException e){
System.out.println("URL mal formada");
}
}
}
CLASE URLConnetion
Con la clase URLConnection podemos crearnos una conexin como la del Socket pero ms completa.
Podremos pedir ms informacin al servidor: fecha de creacin, tipo de fichero al que vamos a
acceder...
Pasos para crear una conexin

Creamos un objeto de la clase URL
Creamos un objeto de la clase URLConnection con el mtodo openConnection del objeto url
URL miurl = new URL (http://www.yahoo.com);
URLConnection conexion = miurl.openConnection();
Especificaciones de la conexin:
Registrarnos
Podemos indicar si queremos tener abiertos canales de entrada y salida.
Conectarnos a partir de una fecha (por si queremos que la pgina est actualizada).
Para indicar que queremos tener abiertos los canales de entrada y salida se usan:
setDoInput (boolean); Entrada
setDoOutput(boolean); Salida
Conectarnos con el mtodo connect();
Ejemplo
import java.io.*;
public class Agenda{

try{
URL miurl = new URL ("http://www.marca.com");
//Abrimos la conexion
URLConnection conexion= miurl.openConnection();
conexion.setDoInput (true);
//Miro si ha sido modificada
www.learning.es
conexion.setIfModifiedSince(100000000);
//Nos conectamos
conexion.connect();
//Abrimos el canal de entrada
BufferedReader in = new BufferedReader( new InputStreamReader _
( conexion.getInputStream()));
String cadena;
while((cadena=in.readLine())!=null){
System.out.println(cadena);
}
}
}
}
CLASES DatagramPacket y DatagramSocket

En bloque anteriores hemos visto como enviamos informacin son el protocolo TCP/IP y si esta
informacin llegaba mal la volvamos a enviar.
Con los datagramas podemos enviar informacin ms rpida, pero como desventaja la informacin
se puede perder.
La clase DatagramPacket nos permite elaborar paquetes de informacin. La clase DatagramSocket

sirve para enviar y recibir la informacin.
Trabajo con los paquetes
Pasos para el envio de paquetes
1 .Contruimos un paquete con la clase DatagramPacket
2. Creamos un objeto de la clase DatagramSocket. Al hacer el paquete incluimos la direccin y el

puerto, no como en Socket que se hace directamente.
DatagramSocket dtSocket= new DatagramSocket();
3. Usamos el mtodo send( DatagramPacket paquete) de DatagramSocket.

DtSocket.send (paquete);
Para recibir un paquete:
Creamos un paquete con la clase DatagramPacket vacio. (Lo llamamos otropaquete).
Crear un objeto de la clase DatagramSocket. Ahora si que debemos indicarle el puerto por el que va
la informacin.
DatagramSocket otroSocket = new DatagramSocket(puerto);
Recibimos el paquete con el mtodo receive ( nombre_paquete);

OtroSockect.receive(otropaquete);
Ejemplo de datagramas
/ /Este programa envia una cadena y recibe el eco, recibe lo mismo que envia.
www.learning.es
// El cliente envia un paquete al servidor y recibe otro
// Clase Cliente
import java.net.*;
import java.io.*;
public class ejemploDatagramasCliente{

String servidor="10.32.1.10";
int puerto = 5000;
String cadenaUDP = "Prueba ejemplo datagramas" ; //Cadena a enviar
byte[] envio = cadenaUDP.getBytes();
try{
InetAddress direccion = InetAddress.getByName(servidor);
DatagramPacket paquete = new DatagramPacket( envio, envio.length, _
direccion,puerto);
//Creamos objeto DatagraSocket
DatagramSocket midatagramSocket = new DatagramSocket();
//Enviamos la informacion
midatagramSocket.send (paquete);
byte[] recepcion = paquete.getData(); //Lo inicializo con _

la informacion mandada
//Lo sobreescribo
for(int i=0; i<paquete.getLength(); i++){
recepcion[i]= (byte)'x'; //Lo lleno de x
}
System.out.println( new String (paquete.getData())); _
// Aqui mostrara las xxxxx
//Falta recibir el paquete de vuelta

midatagramSocket.receive(paquete); //al llegar aqui _
es programa espera a que le llegue la informacion desde el servidor
System.out.println( new String(paquete.getData()));
midatagramSocket.close();
}catch(SocketException e){
}
}
}
//Este programa envia una cadena y recibe el eco, recibe lo mismo que envie
//Clase Servidor
import java.net.*;
import java.io.*;
public class ejemploDatagramasServidor{
www.learning.es
try{
DatagramSocket socketDatagrama = new DatagramSocket (5000);
System.out.println("Escuchando en el puerto 5000");
//Lo meto en un bucle infinito para que este escuchando
while(true){
DatagramPacket paquete = new DatagramPacket (new byte[20],20);
//Esperamos a recibir la informacin
socketDatagrama.receive(paquete);
System.out.println("Recibida llamada en el puerto 5000"); _
//Solo salta si recibo algo
//Reenvio la _
informacin recibida, construyo un paquete con la informacin recibida
DatagramPacket paqueteenvio = new DatagramPacket(paquete.getData(),_
paquete.getLength(),paquete.getAddress(), paquete.getPort());
socketDatagrama.send(paqueteenvio);
}
}catch(IOException ioe){
System.out.println(ioe.toString());
}
}
}
RMI
El sistema de Invocacin Remota de Mtodos (RMI) de Java permite a un objeto que se est
ejecutando en una Mquina Virtual Java realizar llamadas a mtodos de otro objeto que est en otra
Mquina Virtual Java diferente.
Relacin cliente-servidor
En la parte del servidor tenemos:
Aplicacin a la escucha.
Objetos a la espera de que sean utilizados.
Listado de objetos, esto es lo que llamamos Servicio de nombres en JAVA se llama RMI
registry que es una aplicacin que tenemos que levantar para trabajar con ella.
Implementar una clase servidor que:

Crea objetos de la clase que nos interesa (clase sirviente). Cuando creamos estos objetos
creamos como 3 objetos, en realidad:
El objeto remoto(Sirviente). Luego es como si lo clonramos y lo dividiramos en dos Stub
y Skeleton.
La representacin del objeto (Stub). Esto es lo que se coloca en el servicio de nombres.
Registra el stub en el servicio de nombres.
Otra representacin del objeto (Skeleton).
Los registramos en el servicio de nombres.
Clase/s sirviente/s: clase que genera unos objetos que utilizar el cliente. Tendr mtodos
que podr usar el cliente y otros que no. Para ello:
Declaramos una interfaz que nos diga los mtodos de los objetos de la clase sirviente a los
que podemos acceder. La clase sirviente debe implementar este interfaz.
En la parte del cliente:
Aplicacin cliente: Queremos trabajar con mtodos de objetos que estn en el servidor. La
aplicacin cliente preguntar por el objeto que queremos, en el servidor de nombres (listado
www.learning.es
de objetos). El cliente busca en el listado de objetos y se trae un ente de lo que est en el
listado de objetos, se trae una representacin del listado de objetos.
Nos traemos representacin del objeto que encuentra en el servicio de nombres stub.
Como funcionamos: ponemos a funcionar el servidor, se crearan los objetos, al crearse el
stub se registrar en el servicio de nombres. Crear el skeleton. Cuando el cliente llama al
servicio de nombres recibe el stub, vamos a tener el stub en los dos sitios.
El stub del cliente se va a comunicar con el Skeleton del servidor. El skeleton se comunica
con el objeto sirviente.
Tendremos cuatro archivos java: Cliente,Clase Servidor,Clase Sirviente e Interfaz
Ejemplo
Hacer una aplicacin que devuelve el cuadrado de el factorial de un numero. Un cliente llama a un
mtodo del servidor y devuelve el cuadrado del factorial de un nmero. El cuadrado y el factorial lo
hacemos en dos mtodos. En el interface solo ponemos el cuadrado. Desde el cliente solo podremos
llamar al mtodo cuadrado. Cuadrado llamara al factorial. De momento desde el cliente no pasamos
parmetro.
ElCliente.java
import java.rmi.*;
import java.rmi.server.*;
public class ElCliente{

String url= "rmi://localhost/";
try{
LaInterface inter = (LaInterface) Naming.lookup(url+"Numero");
System.out.println(inter.cuadrado());
}catch(Exception e){
}
}
}
ElServidor.java
import java.rmi.*;
public class ElServidor{

try{
System.out.println("Implementando la clase servidor");
//La clase ProductImpl es la que implementara los objetos

ElSirvienteImplementaLaInterface n = new ElSirvienteImplementaLaInterface (5);
System.out.println("Escribiendo en el servicio de nombres");

//Le digo que escriba en el servicio de nombres, para hacer referencia a ello pongo Naming
Naming.rebind("Numero",n); //Nmero es una manera de identificar a 5.Desde el _
cliente llamaremos a Numero ,que es como se reconoce al objeto 5
www.learning.es
System.out.println("Esperando las llamadas del cliente");
}catch(Exception e){
}
}
}
LaInterface.java
import java.rmi.*;
public interface LaInterface extends Remote{
String cuadrado()throws RemoteException;

}
ElSirvienteImplementaLaInterface.java
import java.rmi.*;
//Tiene que heredar de eso e implementar nuestro interface

public class ElSirvienteImplementaLaInterface extends _
UnicastRemoteObject implements LaInterface{
int valor; //Nmero de el que calculo el !^2

public ElSirvienteImplementaLaInterface (int n) _
throws RemoteException{
valor=n;
System.out.println("Estoy en _
ElSirvienteImplementaLaInterface");
}
//-----------------------------------------
public String cuadrado() throws RemoteException{
int x= factorial(valor);
x=x*x;
return "EL FACTORIAL AL CUADRADO DE _
"+ valor+ " ES "+ x;
}
//------------------------------------------
public int factorial(int n){
//Si no lo calculo
int resultado=1;
for(int i=1; i<=n;i++){

resultado*=i;
}
return resultado;
}
}
Actividades
www.learning.es

Módulo Java Programación Lenguaje

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Módulo Java Programación Lenguaje

Uploaded by

Copyright:

Available Formats

Mdulo 2

* Diferentes mquinas desde el punto de vista del hardware

- Diferentes mquinas desde el punto de vista del hardware.

Estos problemas se han agravado an ms con la expansin de Internet en la cual deben

La mquina virtual Java (JVM)

La especificacin de la JVM proporciona definiciones muy concretas para la implementacin de:

- Conjunto de instrucciones (equivalente al de la CPU).

En C, C++, y otros lenguajes, el programador es responsable de la gestin de la liberacin de

Java libera al programador de la responsabilidad de liberar la memoria. El lenguaje java proporciona

El proceso de "Garbage collection" se realiza automticamente durante el ciclo de vida de un

Seguridad del cdigo

En el momento de la ejecucin, los diferentes archivos bytecodes que componen el programa a

En el proceso de verificacin se resuelve si el cdigo cumple las especificaciones de la JVM y no viola

Arquitectura neutral (multiplataforma)

Los enteros son de 32 bits en complemento a 2.

Desarrollo con Java

Elementos y reglas sintcticas de los lenguajes de programacin

Comentarios en los programas

Tipos de datos bsicos

Al asignar un valor a la variable lo que estamos haciendo es almacenar el dato en la posicin de

Estas operaciones no slo se limitan a operaciones aritmticas. Disponemos tambin de operaciones

Tomar decisiones sobre la ejecucin o no de determinadas tareas en base al cumplimiento o no de

Almacenamiento de datos mediante Arrays.

Desarrollador del lenguaje de programacin. Su conocimiento de la mquina es profundo debido a

Posteriormente, estos lenguajes se han podido utilizar para el desarrollo de tecnologas de

Programador de aplicaciones. Su conocimiento suele centrarse en el lenguaje de programacin que

Programador. Aprovechando que el desarrollador del lenguaje de programacin ha implementado el

- API orientado a funciones.

En los lenguajes procedimentales, orientados a funciones, la estructura se realiza tomando como

En Java una clase se suele representar con la siguiente estructura:

public class NombreClase{

Analizaremos algunos conceptos bsicos para poder comprender el concepto de propiedad

La lgica de funcionamiento se implementa en el cdigo de cada mtodo

public static void salirCoche(){

System.out.println ("No te has subido y ya te bajas");

System.out.println("Primero frena y luego baja");

System.out.println("Acabas de bajar del coche.");

BufferedReader i=new BufferedReader(new InputStreamReader(System.in));

case 4: salirCoche ();

default:System.out.println("No existe la opcin");

System.out.println("La opcin debe ser un nmero");

Se pueden acceder a las variables de instancia de un objeto de la siguiente manera:

public class Coche{

public class Conductor {

Si intentamos modificar el valor de la variable nos dar error.

public class Coche{

public class Conductor {

public static void main(String args[]){

La implementacin siempre ser de dos partes: la declaracin y el cuerpo:

[ModificadoresAcceso] TipoRetorno nombreMtodo ([lista_de_argumentos]) [excepciones]{

Para devolver un valor se utiliza la palabra clave return.

Si se declara un mtodo anteponiendo la palabra static, ste se convierte en un mtodo esttico o

Sobrecarga de mtodos o polimorfismo

La Sobrecarga es uno de los procedimientos mediante el cual Java implementa el polimorfismo(en

En este ejemplo definimos una clase con 3 mtodos sobrecargados:

public void Metodo1(int edad) // Sobrecarga con un parmetro

public static void main (String [] var)

Utilizar comentarios en el cdigo fuente

En java hay tres tipos de comentarios:

Siguientes caracteres Pueden ser letras, nmeros o smbolos.

Longitud No hay una longitud mxima establecida.

Maysculas / Minsculas Se distinguen las maysculas de las minsculas.

No se pueden usar Palabras clave.