PDF M2 Java PDF

Módulo 2
Lenguaje de
Programación JAVA
Profesional en
Plataforma
JAVA
www.learning.es
Para uso exclusivo de los alumnos de LEARNING & TRAINING CLOUD, S.L.
Contenido
Introducción y Objetivos ........................................................................................................ 1
Introducción ........................................................................................................................................................... 1
Objetivo .................................................................................................................................................................. 1
Unidad 1. Introducción .......................................................................................................... 2
Arquitectura de Java ............................................................................................................................................... 2
Introducción ........................................................................................................................................................... 2
La máquina virtual Java (JVM) ................................................................................................................................ 2
El Garbage collection .............................................................................................................................................. 3
Seguridad del código .............................................................................................................................................. 3
Características de Java............................................................................................................................................ 4
Desarrollo con Java................................................................................................................................................. 5
Unidad 2. Programación Orientada a Objetos ........................................................................... 8
Introducción ........................................................................................................................................................... 8
Clases ..................................................................................................................................................................... 9
Tipos de clases ...................................................................................................................................................... 11
Variables de instancia ........................................................................................................................................... 12
Variables estáticas ................................................................................................................................................ 12
Variables finales ................................................................................................................................................... 13
Métodos de clase ................................................................................................................................................. 13
Sobrecarga de métodos o polimorfismo .............................................................................................................. 14
Unidad 3 . Identificadores, palabras clave y tipos .................................................................... 15
Introducción ......................................................................................................................................................... 15
Utilizar comentarios en el código 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
Introducción ......................................................................................................................................................... 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
Introducción ......................................................................................................................................................... 31
Creación de un array ............................................................................................................................................ 31
Unidad 6. Diseño de clases ................................................................................................... 34
Introducción ......................................................................................................................................................... 34
Variables y métodos en las subclases ................................................................................................................... 36
Clases y Métodos finales ...................................................................................................................................... 36
Clases abstractas .................................................................................................................................................. 36
Paquetes............................................................................................................................................................... 37
Interfaces ............................................................................................................................................................. 38
Unidad 7. Características Avanzadas de Clases ........................................................................ 39
Introducción ......................................................................................................................................................... 39
this y super ........................................................................................................................................................... 39
Destrucción de objetos ......................................................................................................................................... 40
Crear y usar tipos enumerados ........................................................................................................................... 41
Importaciones estáticas ....................................................................................................................................... 41
Laboratorio: Clase Objeto cadena ........................................................................................................................ 42
Unidad 8. Excepciones y aserciones ....................................................................................... 45
Introducción ......................................................................................................................................................... 45
try-catch-finally .................................................................................................................................................... 45
ASERCIONES ......................................................................................................................................................... 47
Unidad 9. API Colecciones y genéricos ................................................................................... 49
Introducción ......................................................................................................................................................... 49
Colecciones........................................................................................................................................................... 49
Genéricos ............................................................................................................................................................. 55
Unidad 10. Principios básicos de E/S ...................................................................................... 58
Introducción ......................................................................................................................................................... 58
Argumentos de la línea 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
Introducción ......................................................................................................................................................... 83
System.in .............................................................................................................................................................. 84
System.out ........................................................................................................................................................... 85
System.err ............................................................................................................................................................ 85
Unidad 12. Creación de interfaces gráficas con el API Swing ..................................................... 87
Introducción ......................................................................................................................................................... 87
Programación gráfica con Swing .......................................................................................................................... 88
Ejemplos con algunas de las clases de Swing ....................................................................................................... 90
Laboratorio: Manejo de los cuadros de diálogo ................................................................................................... 96
Unidad 13. Control de eventos generados por la interfaz gráfica ............................................... 102
Introducción ....................................................................................................................................................... 102
Modelo nuevo de delegación. (Source, Listener, Adapter). ............................................................................... 102
Ejemplos con eventos ......................................................................................................................................... 104
Clase SwingWorker ............................................................................................................................................. 105
Laboratorio 1: Movimiento entre frames ........................................................................................................... 106
Laboratorio 2: Cargador de imágenes ................................................................................................................ 109
Unidad 14. Aplicaciones basadas en la interfaz gráfica ........................................................... 112
Introducción ....................................................................................................................................................... 112
Creación de un menú ......................................................................................................................................... 112
Creación de un Toolbar ...................................................................................................................................... 114
JPopupMenu ...................................................................................................................................................... 115
Unidad 15 . Hilos ................................................................................................................ 118
Introducción ....................................................................................................................................................... 118
Ciclo de vida de un thread .................................................................................................................................. 118
Primer ejemplo de hilos ..................................................................................................................................... 119
Métodos 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
Sincronización .................................................................................................................................................... 126
Unidad 16. Programación en red ......................................................................................... 128
Introducción ....................................................................................................................................................... 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
Introducción y Objetivos
Introducción
Sun Microsystems es la empresa que ha inventado el lenguaje Java, en un intento de resolver
simultáneamente todos los problemas que se planteaban a los desarrolladores de software por la
proliferación de arquitecturas incompatibles en los siguientes aspectos:
* Diferentes máquinas desde el punto de vista del hardware

* Diferentes sistemas operativos
* Diferentes sistemas de ventanas que funcionan sobre una misma máquina.
Estos problemas se han agravado aún más con la expansión de Internet en la cual debe
comunicarse plataformas heterogéneas, y dónde las aplicaciones distribuidas son el corazón del
sistema.
Objetivo
El éxito de Java reside en su arquitectura y las características que esta arquitectura le confiere, lo
cual veremos en el desarrollo del módulo.
www.learning.es
Unidad 1. Introducción
Sun Microsystems es la empresa que ha inventado el lenguaje Java, en un intento de resolver
simultáneamente todos los problemas que se planteaban a los desarrolladores de software por la
proliferación de arquitecturas incompatibles en los siguientes aspectos:
- Diferentes máquinas desde el punto de vista del hardware.

- Diferentes sistemas operativos.
- Diferentes sistemas de ventanas que funcionan sobre una misma máquina.
Estos problemas se han agravado aún más con la expansión de Internet en la cual deben
comunicarse plataformas heterogéneas, y dónde las aplicaciones distribuidas son el corazón del
sistema.
El éxito de Java reside en su arquitectura y las características que esta arquitectura le confiere.
Arquitectura de Java
Introducción
En la arquitectura de Java es dónde se encuentra la solución al problema planteado en la
introducción. 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 máquina virtual java (JVM). Por tanto,
java es compilable-interpretable.
La máquina virtual Java (JVM)

La Especificación de la Máquina Virtual Java la define como:
Una máquina imaginaria implementada mediante la emulación por software en una máquina real. El
código para la máquina virtual Java se almacena en archivos .class, cada uno de los cuales contiene,
al menos, el código para una clase pública.
La especificación de la máquina virtual java proporciona las especificaciones de hardware para las
que se compila toda la tecnología java. Esta especificación permite al software en java ser
independiente de la plataforma ya que la compilación se hace para una máquina genérica conocida
como la máquina virtual java (JVM). Esta puede ser emulada por software para poder ser ejecutada
en los diferentes sistemas informáticos existentes, o bien ser implementada en hardware.
www.learning.es
A partir del código fuente el compilador genera bytecodes. Estos bytecodes son instrucciones de
código máquina para la JVM. Cada intérprete de java tiene una implementación de la JVM.
La especificación de la JVM proporciona definiciones muy concretas para la implementación 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 programación permiten la reserva de memoria en tiempo de
ejecución. El proceso de reserva de memoria varía según 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 ejecución debería liberar esa memoria.
En C, C++, y otros lenguajes, el programador es responsable de la gestión de la liberación 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
ejecución 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 ejecución, 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 operación.
El proceso de "Garbage collection" se realiza automáticamente durante el ciclo de vida de un

programa java, eliminando la necesidad de liberar memoria y evitando las pérdidas de memoria. Sin
embargo, la implementación del gestor de "garbage collection" puede variar sustancialmente en las
diferentes implementaciones de la JVM.
Seguridad del código

Ya hemos visto que el código fuente de Java se compila en el sentido de que se convierten a un
conjunto de bytecodes.
En el momento de la ejecución, los diferentes archivos bytecodes que componen el programa a

ejecutar se cargan, se verifican y se ejecutan en el intérprete. La función del intérprete es doble:
- Por un lado ejecuta los bytecodes y por otro gestiona las llamadas al hardware del sistema.
- El entorno de ejecución que ejecuta el código compilado para una JVM realiza tres tareas
principales:
- Carga el código: Lo realiza el cargador de clases.
- Verificación del código: Lo realiza el verificador de bytecode.
- Ejecución del código: Lo realiza el intérprete de bytecode.
El cargador de clases
Su función es cargar todas las clases necesarias para la ejecución de un programa.
www.learning.es
Además, mantiene separadas aquellas clases cargadas a partir del sistema de archivos local y
aquellas otras cargadas a través de los recursos de la red. Esto permite limitar la acción de posibles
aplicaciones dañinas, 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 aplicación.
En este momento se asigna direcciones de memoria reales a las referencias simbólicas del código y
se rellena la tabla de asignación de memoria. Debido a que el proceso de asignación de memoria se
realiza en el momento de la ejecución, el intérprete de java añade protección contra acceso no
autorizado a las áreas de código.
Verificador de bytecode
El código de java se verifica mediante diferentes test antes de ejecutarse en la máquina. La JVM
verifica el formato de los diferentes fragmentos de bytecode en busca de código ilegal - código 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 verificación se resuelve si el código cumple las especificaciones de la JVM y no viola

la integridad del sistema. Si la verificación se completa con éxito, se puede asegurar lo siguiente:
- Las clases cumplen con el formato de archivo de clase de la especificación JVM.
- No hay violaciones de acceso restringido.
- El código no provoca desbordamientos de la pila.
- Los tipos de parámetros para todo el código es correcto y no se modificará durante la ejecución.
- No existen conversiones ilegales de datos, por ejemplo, convertir enteros a referencias a
objetos.
- Los accesos a los campos de los objetos están autorizados.
Características de Java
Introducción
La arquitectura presentada en el punto anterior proporciona unas características a Java que ningún
otro lenguaje de programación tiene:
Robusto
Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo
de ejecución. En tiempo de compilación no tiene ningún misterio porque todos los lenguajes realizan
esas verificaciones, sin embargo, en tiempo de ejecución, la JVM, que realiza la interpretación de los
bytecodes, detecta cuando existe algún problema en la ejecución del programa, y lanza excepciones
que pueden ser recogidas por el programador con el propósito de recuperarse de dichos errores.
Arquitectura neutral (multiplataforma)

Gracias a que la compilación se realiza a un código objeto independiente de la arquitectura de la
máquina (bytecodes), tan sólo necesitamos utilizar el intérprete 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 ejecución la realiza la JVM, los programas Java pueden ser sometidos a muchas
comprobaciones antes de ejecutarse en la máquina. En concreto:
- El código se pasa a través de un verificador de ByteCodes que comprueba el formato de los
fragmentos de código y detecta fragmentos de código ilegal (código 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 aplicación 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 código fuente, el propio JDK proporciona un desensamblador de
ByteCodes, que hace que cualquier programa pueda ser convertido a código fuente a partir de
sus bytecodes. Utilizando javap no se obtiene el código fuente original, aunque si desmonta el
programa mostrando su estructura. Este problema de seguridad del código fuente es algo
todavía pendiente de subsanar.
Portable
Más allá de la portabilidad básica por ser de arquitectura independiente, Java implementa otros
estándares de portabilidad para facilitar el desarrollo.
Los enteros son de 32 bits en complemento a 2.
Java construye sus interfaces de usuario a través 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 través 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 programación 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 sintácticas (estructura) y semánticas (significado) permiten el entendimiento entre las
partes que forman la comunicación.
En los lenguajes de programación también encontramos unas reglas sintácticas que debemos
respetar a la hora de confeccionar los programas y una semántica encargada de resolver el
problema que queremos programar.
Elementos y reglas sintácticas de los lenguajes de programación

Aunque todos los conceptos que aprenderemos a continuación aparecen en todos los lenguajes de
programación existen diferencias en la implementación 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 más detalladamente
posible lo que significa cada una de las órdenes que forman parte del programa, con el propósito de
poder recordar en un futuro la función que realiza cada una de ellas, y facilitar su estudio a personas
ajenas al programa.
Identificadores
En todo lenguaje de programación surge la necesidad de utilizar una serie de elementos que
debemos designar con algún nombre, por ejemplo:
Elemento Descripción
Variables - Elementos utilizados para referenciar posiciones de memoria dónde podremos
almacenar datos necesarios para el programa.
Funciones - Elementos utilizados para referenciar posiciones de memoria dónde reside el
www.learning.es
código del programa.
Objetos - Elementos que encapsulan variables (propiedades) y funciones (métodos) de
manera que resulta más sencillo modelar los problemas que queremos resolver
simplificando el diseño de programas complejos.
etc. - Conforme avancemos iremos conociendo más elementos de los lenguajes de
programación.
A la hora de asignar nombre a todos estos elementos hay que seguir unas reglas.
Tipos de datos básicos

El modelo mental más sencillo que se puede tener de una aplicación informática 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 cuáles deben ser albergados en memoria y referenciados mediante
alguna variable, pueden ser de diferente naturaleza (numéricos, alfanuméricos, etc.).
Cada lenguaje de programación dispone de unos tipos de datos básicos a los cuáles nos tenemos
que amoldar a la hora de realizar el análisis de los datos que necesitamos en nuestra aplicación.
Variables
Este elemento juega un papel muy importante en el programa porque es el mecanismo que pone a
nuestra disposición el lenguaje de programación para gestionar de una manera sencilla los datos de
la aplicación.
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 posición 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 cálculo de matemático y, aunque ahora
ha pasado a un segundo plano, los lenguajes de programación ofrecen una serie de elementos que
permiten realizar operaciones con los datos.
Estas operaciones no sólo se limitan a operaciones aritméticas. Disponemos también de operaciones

lógicas, comparaciones, etc.
Sentencias de control
Sin embargo, la característica 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 básico,
limitándose a:
Tomar decisiones sobre la ejecución o no de determinadas tareas en base al cumplimiento o no de

una o varias condiciones (sentencias de decisión). En dichas condiciones siempre estarán implicados
datos (o si se quiere, sus representantes las variables).
www.learning.es
Alterar el flujo de ejecución normal del código del programa (sentencias de salto o bucles). También
estas alteraciones estarán controladas por variables.
La combinación 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 básico para almacenar y acceder a datos en
memoria. Sin embargo, en la mayoría de aplicaciones este tipo de almacenamiento de información
se queda corto por ser demasiado simple y necesitamos a sistemas de almacenamiento más
complejos pero también más potentes.
Uno de estos sistemas, que aparece en todos los lenguajes de programación, es el de los Arrays.
Excepciones
Todos los lenguajes de programación avisan de los errores que cometamos en tiempo de
compilación, pero pocos son los que han sido diseñados para seguir avisando de posibles errores en
tiempo de ejecución. Las aplicaciones Java, gracias a que se ejecutan bajo la supervisión de la
máquina virtual (JVM), están siendo controladas constantemente. En caso de que ocurra algún error
de ejecución, se lanza una excepción que puede ser recogida y tratada por el programador en su
aplicación. De esta manera, lo que antes solía terminar en una ejecución anormal del programa, con
java puede ser resuelto.
Objetos
Java es un lenguaje de programación orientado a objetos. La importancia de este tema es tal que le
dedicamos el siguiente capítulo 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. Programación Orientada a Objetos
Introducción
El programador debe conocer cuál es su situación respecto a la máquina que va a programar y qué
personajes, junto con él, son importantes a la hora de desarrollar una aplicación. Cada uno de estos
personajes tiene un punto de vista diferente que describimos a continuación:
Desarrollador del lenguaje de programación. Su conocimiento de la máquina es profundo debido a

que debe desarrollar la aplicación que ayudará al programador a realizar su trabajo. En un principio
se desarrollaban los lenguajes de programación 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 tecnologías de

programación más potentes como C++, y éste a su vez es el que se ha utilizado en el desarrollo de
Java. El lenguaje de programación 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 programación que

utiliza para el desarrollo de sus aplicaciones. No necesita conocer la máquina tan en profundidad
como el desarrollador de lenguajes de programación, sin embargo, ese conocimiento extra ayuda a
comprender lo que se está realizando y, por tanto, facilita el desarrollo de aplicaciones. Su función
principal es utilizar todas las herramientas que le ofrece un lenguaje de programación para
desarrollar aplicaciones fáciles de usar (usabilidad) destinadas al siguiente personaje: el usuario.
Usuario. Su conocimiento del ordenador suele ser escaso, por no decir nulo, y su función es la de
utilizar las aplicaciones que ha desarrollado el programador.
Un ejemplo puede aclarar todo lo expuesto anteriormente. Veamos cómo realiza el acceso a la hora
cada uno de estos personajes.
Desarrollador del lenguaje de programación. Este personaje conoce la manera que se ha diseñado
en la máquina para contabilizar el tiempo. El reloj de tiempo real (RTC) incorpora un contador dónde
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 aplicación de un algoritmo matemático el día, mes y año en el que nos
encontramos, y la hora con una precisión de milisegundos. Por tanto, el desarrollador de un lenguaje
de programación, para acceder hasta la hora del sistema, tendría que acceder al dato almacenado
en el RTC mediante la lectura del puerto dónde está situado e implementar el algoritmo de
conversión, lo que requiere un conocimiento del funcionamiento de la máquina determinado.
Programador. Aprovechando que el desarrollador del lenguaje de programación ha implementado el

código de más bajo nivel para acceder a la hora del sistema, puede ofrecer este código al
programador para simplificarle la forma de acceso. Una parte fundamental de un lenguaje de
programación es el API que ofrece al programador. En él se encuentra todo el código que ha
desarrollado el desarrollador del lenguaje de programación y que puede utilizar el programador en
sus aplicaciones. La evolución de las tecnologías de programación ha dado lugar a dos tipos de
lenguaje de programación (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
representación en la aplicación.
www.learning.es
En este tema aprenderemos los conceptos de la programación orientada a objetos.
- El desarrollador de lenguajes de programación debe pensar en facilitar al programador su
trabajo, el desarrollo de aplicaciones informáticas, ofreciéndole unas herramientas que le
ofrezcan:
Clases
Las diferentes tecnologías de programación se diferencian en la manera que ofrecen de estructurar
los datos y el código que forman una aplicación.
A la hora de plantear el análisis del problema que se quiere resolver por software, todas las
tecnologías han optado por dividir dicho problema en parte más pequeñas. 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 información de lo que hay que hacer de su
interacción con el usuario. En la actualidad esta interacción se realiza a través de un entorno gráfico
y las órdenes se generan mediante eventos.
En los lenguajes procedimentales, orientados a funciones, la estructura se realiza tomando como

referencia el código. Cada una de esas partes se denomina subrutina, procedimiento o función
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{

// Definición de propiedades --> Características del elemento que describimos con la clase.
// Definición de los métodos --> Comportamiento y funcionalidades del elemento.
}
Analizaremos algunos conceptos básicos para poder comprender el concepto de propiedad

(variables), métodos (funciones) y lógicas de funcionamiento.
En este primer ejemplo podemos observar que creamos una clase coche.
Las propiedades de la clase representan características del coche: estado, velocidad actual,
velocidad máxima,…
Los métodos representan acciones que podemos realizar sobre el coche: montar, bajar, salir,...
La lógica de funcionamiento se implementa en el código de cada método
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 opción");
www.learning.es
}
public static void montar(){
if (estado==false){
System.out.println("Ya estás 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 más");
}
else{
++velocidad;
System.out.println("Velocidad actual= "+velocidad);
}
menu();
}
public static void parar(){
if (velocidad==0){
System.out.println("Si estás 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 opción");
}
}
catch( NumberFormatException e){
System.out.println("La opción debe ser un número");

}
}while (true);
Tipos de clases
abstract
Una clase abstract tiene al menos un método 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 métodos 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 declaración de una variable dentro de la definición 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 métodos y dentro de la clase, y son del tipo global
por lo que las pueden utilizar cualquier método no estático de esa clase, pero para acceder desde
métodos estáticos es necesario instanciar la clase.
Variables estáticas
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
algún objeto modifica la variable, quedará modificada para todos los objetos.
Si queremos acceder a una variable de clase no es necesario instanciar ningún objeto de dicha clase,
basta con usar:
Nombredeclase.nombredevariableestática
En este ejemplo definimos una variable estática para la velocidad máxima 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 máxima 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 modificación una vez que sea declarada e inicializada.
Poniendo la palabra final con una variable o clase estática, se crean constantes de clase.
Si intentamos modificar el valor de la variable nos dará error.
En este ejemplo intentaremos modificar la velocidad máxima a la que puede ir un coche. Como la
variable que controla la velocidad máxima es final comprobaremos que nos saltará un error:
public class Coche{

…
…
…
static final int VMAXIMA=120;//Velocidad máxima a la que podemos circular.
…
…
…
}
public class Conductor {
Coche.VMAXIMA=180;
System.out.prinln(Coche.VMAXIMA);
}
Métodos de clase
Los métodos son funciones que pueden ser llamados dentro de la clase o por otras clases.
La implementación siempre será de dos partes: la declaración y el cuerpo:
[ModificadoresAcceso] TipoRetorno nombreMétodo ([lista_de_argumentos]) [excepciones]{

CuerpodelMétodo
}
La lista de argumentos es opcional. Los parámetros o argumentos se usan para pasar información al
cuerpo del método. Los parámetros se pararán 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 aplicación que realizó la llamada.
Para devolver un valor se utiliza la palabra clave return.
Si se declara un método anteponiendo la palabra static, éste se convierte en un método estático o

de clase. Las características de estos métodos son:
www.learning.es
Pueden ser invocados sin necesidad de que haya que instanciar ningún objeto de la clase.
NombreClase.nombreMétodo(...)
Los métodos estáticos sólo tienen acceso a variables de clase o estáticas; 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
través de ese objeto.
Sobrecarga de métodos o polimorfismo

En Java es posible definir dos o más métodos dentro de la misma clase que compartan el mismo
nombre pero las declaraciones de sus parámetros deben ser diferentes. A esto es a lo que se conoce
como Sobrecarga de Métodos.
La Sobrecarga es uno de los procedimientos mediante el cual Java implementa el polimorfismo(en

programación orientada a objetos es la capacidad que tienen los objetos de una clase de responder
al mismo mensaje o evento en función de los parámetros utilizados durante su invocación).
En este ejemplo definimos una clase con 3 métodos sobrecargados:

class Principal{
public void Metodo1()
{
System.out.println(“Metodo sin Argumentos”);
}
public void Metodo1(int edad) // Sobrecarga con un parámetro

{
System.out.print(“Metodo con un Argumento:”);
System.out.println(“ edad= “ +edad);
public void Metodo1(double edad, double año, double mes) //Sobrecarga con tres
parámetros
{
System.out.print(“Metodo con tres Argumentos:”);
System.out.println(“ edad= “ +edad+ “ año= “ + año + “ 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 Métodos
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
Introducción
Al igual que el lenguaje natural que utilizamos para comunicarnos, ya sea de forma oral o por
escrito, cualquier lenguaje de programación 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 sintácticas (estructura) y semánticas (significado) permiten el entendimiento entre
las partes que forman la comunicación.
En los lenguajes de programación también encontramos unas reglas sintácticas que debemos
respetar a la hora de confeccionar los programas y una semántica encargada de resolver el
problema que queremos programar.
Utilizar comentarios en el código fuente

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

Comentario Descripción
//.......... Comentario para una sola línea.
/* ........ */ Comentario de una o más líneas
/** ........*/ Comentario de documentación de una o más líneas.
Los comentarios de documentación, colocados inmediatamente antes de una declaración de variable
o función, indican que ese comentario ha de ser colocado en la documentación que se genera
automáticamente cuando se usa la herramienta javadoc.
Identificadores
En todo lenguaje de programación surge la necesidad de utilizar una serie de elementos que
debemos designar con algún nombre, por ejemplo:
Variables - Elementos utilizados para referenciar posiciones de memoria dónde podremos
almacenar datos necesarios para el programa.
Funciones - Elementos utilizados para referenciar posiciones de memoria dónde reside el
código del programa.
Objetos - Elementos que encapsulan variables (propiedades) y funciones (métodos) de
manera que resulta más sencillo modelar los problemas que queremos resolver
simplificando el diseño de programas complejos.
etc. - Conforme avancemos iremos conociendo más elementos de los lenguajes de
programación.
www.learning.es
Los identificadores sirven para asignar nombre a los diferentes elementos que forman un programa:
variables, métodos, clases, objetos, etc.; cualquier cosa que el programador necesite identificar y
que esté contemplado por el lenguaje de programación.
En la siguiente tabla se muestran las reglas sintácticas que debemos cumplir a la hora de elegir un
identificador:
Primer carácter Una letra, subrayado ( _ ) o el símbolo de dólar ($).
Siguientes caracteres Pueden ser letras, números o símbolos.
Longitud No hay una longitud máxima establecida.
Mayúsculas / Minúsculas Se distinguen las mayúsculas de las minúsculas.
No se pueden usar Palabras clave.

Palabras reservadas.
Palabras reservadas
En la siguiente tabla tenemos las palabras claves proporcionadas por la documentación 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 métodos.

Existe un convenio, no obligatorio, a la hora de nombrar las clases, las variables y métodos. Es
recomendable seguirlo debido a que ayuda a dar claridad a los programas.
Clases e interfaces - Deberían ser un nombre o una concatenación de ellos. (FacturaEnero)

- Poner en mayúscula la primera letra de cada nombre utilizado.
Métodos - Deberían ser verbos con nombres. (calcularImporte)

- Mismo regla que en clases pero poniendo con minúscula la primera letra de
verbo. Se aconseja no usar el símbolo de subrayado.
www.learning.es
Constantes - En mayúsculas.
- Si se usan varias palabras se aconseja separarlas mediante el símbolo de
subrayado.
Variables - Deberían ser un nombre o una concatenación de ellos. (cantidadVariable)

- El primero de ellos comenzaría en minúscula y el resto en mayúsculas.
Tipos de datos
Tipos primitivos
Java utiliza cuatro tipos de elementos para abarcar todos los posibles datos básicos que podemos
necesitar en el desarrollo de una aplicación.
Enteros, reales en coma flotante, booleanos y caracteres.
La siguiente tabla lista los tipos de datos primitivos soportados por Java, sus tamaños y su formato.
Tipo Tamaño/Formato Descripción
(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 precisión.
double 64-bit IEEE 754 Coma flotante de doble precisión.
(Texto)
Un único carácter o carácter aislado.

Carácter 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"
(Lógicos)
boolean true o false Un valor booleano (true or false).
www.learning.es
Variables
En programación, las variables son estructuras de datos que, como su nombre indica, pueden
cambiar de contenido a lo largo de la ejecución 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 declaración consiste en una
sentencia en la que figura el tipo de dato y el nombre que asignamos a la variable. Después 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 excepción 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 métodos. En el siguiente ejemplo Vactual es una variable
local al método mostrarVelocidad en la que guardamos la velocidad actual a la que circula un coche.
Una variable local existe desde el momento de su definición 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
Aritméticos (Suma, resta, multiplicación, división, resto, incremento y decremento).
En la siguiente tabla tenemos las operaciones aritméticas que podemos realizar entre dos
operadores.
Actúan sobre enteros y números en coma flotante.
www.learning.es
El operador + también se utiliza para concatenar cadenas (strings).
En la siguiente tabla tenemos las operaciones aritméticas 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 pérdida
int resto1=s%b; //de precisión, por tanto, obtenemos errores de
compilación.
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 próposito de no obtener resultados erróneos
}
}
Operadores relacionales
Operadores condicionales
www.learning.es
Operadores a nivel de bit
Es interesante observar que la función 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 función AND se usa con datos numéricos.
El operador condicional se usa sobre booleanos.
Veamos algunos ejemplos que aclaren estos conceptos:
Definimos dos datos tipos short y realizamos operaciones lógicas a nivel de bit con ellos. También 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 código binario de un dato tipo int. Observar que el código sale al revés.
Modificar el código 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 asignación
Una forma de ahorrar tiempo a la hora de escribir expresiones pero que muchas veces lían las cosas
innecesariamente.
Operador ternario if-then-else

Sintaxis:
Expresión ? sentencia 1 : sentencia 2
Si la expresión 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 según SUN se refleja en la siguiente tabla (de más prioritario a menos).
www.learning.es
Ver Video: Casting o Conversión entre tipos de datos, en la
Unidad 3,en el Módulo 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.
Solución
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.
Solución

{
{
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.
Solución

{
{
boolean b1=true;
boolean b2=false;
if(b1){
System.out.println("b1 es "+b1);
if(!b2){
System.out.println("b2 es "+b2);
Actividades
actividades que encontrará en la unidad correspondiente de la plataforma eLearning.
www.learning.es
Unidad 4. Expresiones y control de flujo
Introducción
En la siguiente tabla se resumen las sentencias que proporciona Java para controlar el flujo de un
programa:
Tipos Sentencias
De decisión. if-else, switch-case
Bucles for, while, do-while
Excepciones try-catch-finally, throw
Varios break, continue, label: , return
if-else
Permite seleccionar la ejecución de distintos fragmentos de código dependiendo del resultado de la

valoración de una expresión booleana.
Su sintaxis es la siguiente:
if (expresion_booleana) { // La expresión booleana expresa condiciones

...
// código que se ejecuta si la expresión devuelve true
...
} else {
...
// código que se ejecuta si la expresión devuelve false
...
}
El uso de else es opcional.

La expresión 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 expresión.
Su sintaxis es la siguiente:
switch (expresión) {
case valor1: sentencias1;

break;
break;
break;
break;
break;
default: sentencias_por_defecto
break;
}
La expresión puede devolver cualquier tipo básico, 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
expresión 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 inicialización de la variable que controla el bucle, su variación y la
condición de permanencia, en la propia definición del for.
Su sintaxis:
for (inicialización; condición de permanencia; variación){
...
sentencias
...
}
La inicialización hace referencia a la variable de control del bucle.
La condición de permanencia es una expresión booleana donde debe encontrarse la variable de

control.
La actualización hace referencia a la variable de control.
Ejemplo: Imprimir en un bucle for los 10 primeros números 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 expresión booleana sea verdadera.
Su sintaxis es:
while (Expresión_booleana) { //Condición de permanencia
...
sentencias;
...
}
Dentro del bucle se deberá alterar la variable que controla el bucle de lo contrario nunca se dejará
de cumplir la condición.
Se puede realizar un bucle infinito pero se debe incluir la salida dentro del bucle.
www.learning.es
Ejercicio: Recoger un número 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 número 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 expresión.
Su sintaxis:
do {
...
sentencias;
www.learning.es
...
} while (Expresión_booleana);
EJEMPLO: Recoger un número 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 número:");
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 iteración sin que la iteración 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 condición de permanencia todavía 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 código desde el que se llamó a la función.
En el retorno, se puede devolver algún valor.
www.learning.es
Cuando un método se declara como void se debe usar la forma de return sin indicarle ningún valor
Esto se hace para no ejecutar todo el código 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 aplicación de Java.
 Crear un algoritmo que imprima los primos entre 1 y 50.
Solución
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 Módulo 2, en la plataforma elearning
Ver Video: Sentencias Break, en la Unidad 4,

Actividades
www.learning.es
Unidad 5. Arrays
Introducción
Un array es una colección de elementos del mismo tipo.
Los elementos que puede contener un array pueden ser datos de tipos primitivos u objetos.
Creación de un array
Un array es una colección 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 declaración 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 métodos básicos:

int numeros[] = new int[20]; // Define un array de 20 enteros pero sin valores (vacío).
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 tamaño 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 números básicos 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
tamaño 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 dinámica.

En este ejemplo comprobamos como el compilador nos avisaría del error.
Java dispone de las colecciones para redimensionar de forma dinámica.

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

String saludos[]={"hola","adios"};
enteros[10]=10;
enteros[i]=i;
www.learning.es
}
}
}
}
También 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 límites de un array.
Si declaramos un array de dos dimensiones, no es necesario indicar el tamaño de la dimensión

secundaria a la hora de la declaración del array, sino que puede declararse posteriormente el
tamaño de cada uno de los subarrays.
Todos los arrays en Java tienen una función 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. Diseño de clases
Introducción
Para poder diseñar bien un conjunto de clase debemos tener en cuenta los siguientes conceptos:
Un API donde el programador encuentre ya desarrolladas unas funcionalidades básicas que podrá
utilizar en sus aplicaciones.
Un kit de desarrollo donde se encuentren el compilador, el depurador, el intérprete si es necesario y

demás herramientas que permitan la ejecución de las aplicaciones desarrolladas. Todo este kit
puede estar integrado en un entorno de desarrollo.
Una tecnología que permita al programador estructurar su aplicación de la manera más sencilla
posible de tal forma que su análisis e implementación alcancen un nivel de abstracción tal que su
desarrollo sea lo más ordenado y claro posible.
Constructores
Es un tipo específico de método que siempre tiene el mismo nombre de la clase y se utiliza para
construir objetos de esa clase.
No tiene tipo de dato específico 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 después de la palabra reservada new y
asignarlo a una referencia declarada previamente. Un constructor es un método que se ejecuta cada
vez que se crea un objeto, el propósito de este procedimiento es el de inicializar los datos del
objeto. El nombre del constructor siempre es igual al nombre de la clase.
Declaración
class facturar {
int total, importe;
facturar () { total=0; importe=0; } // el constructor
}
Constructor con parámetros

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, característica muy potente que permite definir una clase
tomando como base a otra clase ya existente. Esto es una de las bases de la reutilización de código
y especialización.
Dentro de un mismo tipo de objetos (por ejemplo, los empleados), existe una variedad de modelos
(administrativos, programador, gerente, etc) que dificulta la definición de la clase genérica. Por
ejemplo, si defino los métodos incentivos() y vacacionesNavidad(), estos métodos sólo se podrán
aplicar a aquellos empleados que tengan incentivos y vacaciones en navidad.
Para resolver este tipo de problemas, la programación 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 genérico y mediante herencia crear otras clases más especializadas que
respondan a las necesidades de cada tipo de empleado. La profundidad en la jerarquía de clases no
tiene límite.
La herencia se consigue mediante el uso de extends.

Una clase sólo puede heredar de una única superclase directamente (no existe la herencia múltiple).
Los interfaces (estudiados más adelante) permitirán simular la herencia múltiple.
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("Gómez");
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 métodos en las subclases

Las subclases heredan el estado (propiedades) y el comportamiento (métodos) de la superclase.
Sin embargo, las subclases no están limitadas al estado y comportamiento de la superclases. Las
subclases pueden añadir variables y métodos que las diferenciaran de las otras subclases.
Además, las subclases pueden sobrescribir los métodos que heredan de la superclases, si lo
necesitan, para especializar más su funcionalidad. Para sobrescribir un método basta con definir en
la subclase uno que se llame igual, tenga el mismo tipo de retorno y la misma lista de parámetros.
Clases y Métodos finales

Las clases que son declaradas como finales no pueden ser derivadas.
Los métodos 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 métodos definido pero no lo ha
implementado. La definición de un método consiste en especificar su nombre, el tipo de retorno y
los argumentos de entrada.
public abstract class Empleado{

// variables que heredarán las subclases.
//Métodos comunes que sí se implementan en la clase abstracta.
//Métodos abstractos que deberán implementar las subclases.
// Estamos obligando a que todos los empleados
// tengan vacaciones y pagas
public abstract void Vacaciones();
public abstract void pagas();
}
Otros métodos si pueden estar implementados.

Si una clase tiene un método abstracto, ella también tiene que ser declarada abstracta.
De una clase abstracta no se pueden crear objetos porque el compilador no sabría qué hacer con los
métodos que no están implementados. Por eso no tiene sentido el constructor.
Las clases abstractas no pueden tener métodos estáticos 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 podrán usar nunca.
www.learning.es
Paquetes
Cuando se necesita establecer seguridad, o simplemente cuando el número 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 protección en el acceso y gestión de nombres.
Las clases se agrupan en paquetes por varios motivos:
 Los programadores pueden determinar fácilmente que clases e interfaces están relacionados.
 Se facilita la búsqueda 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
Método Propiedad Clase
- Para poder invocar al - Cada objeto creado de
de instancia (no
método 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 método a través del nombre clase comparten las - No se puede usar.
de la clase. propiedades declaradas
así.
- El método 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 método no puede ser - La variable es una - La clase no se puede
final sobrescrito en el proceso de constante y su valor no extender más por
herencia. puede ser modificado. herencia.
- El acceso al método sólo - El acceso a la variable
private se puede realizar desde la sólo se puede realizar - No se puede usar.
propia clase. desde la propia clase.
- El acceso al método sólo - El acceso a la propiedad
se puede realizar desde las sólo 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 método 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 método 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 métodos de una clase sin implementarlos (nombres de métodos, listas de
argumentos, tipos de retorno) los cuales serán implementados por otra clase.
La diferencia entre una interface y una clase abstracta es que la interface es simplemente una lista
de métodos no implementados, además puede incluir la declaración de constantes. Una clase
abstracta puede incluir métodos 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 después de la palabra
reservada implements.
Creación interface
En este ejemplo creamos una interface con los métodos 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();
}
Implementación 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 continuación 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. Características Avanzadas de
Clases
Introducción
En java podemos realizar operaciones muy complejas con clases. Podremos realizar acciones más
allá de los conceptos básicos en el diseño de las clases.
this y super
Java incluye un valor de referencia especial llamado this, que se utiliza dentro de cualquier método
para referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el
método 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 código, seleccionados a través 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 método es de la superclase. Es
decir, que si queremos hacer referencia a una variable o método 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 también 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());
}
}
Destrucción de objetos
La destrucción de los objetos
La destrucción de un objeto se le denomina a la acción 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 automática o bien personalizada.
Destrucción automática
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
más quebraderos de cabeza le producen, olvidarse de liberar la memoria reservada.
El recolector de basura se encargará de liberar una zona de memoria dinámica que había sido
reservada mediante el operador new, cuando el objeto ya no va a ser utilizado más durante el
programa.
El sistema de recogida de basura se ejecuta periódicamente, buscando objetos que ya no estén

referenciados.
Podríamos forzar la ejecución del recolector de basura para decidir nosotros que lo haga en un
determinado momento mediante el método gc de la clase System.
System.gc();
Destrucción personalizada
El método 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() {
// Liberación del recurso no Java o recurso compartido
www.learning.es
}
}
El intérprete de Java llama al método finalize(), si existe cuando vaya a reclamar el espacio de ese
objeto, mediante la recogida de basura.
Debe observarse que el método 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 versión 1.5 de java y sirven para restringir la selección
de valores a algunos previamente definidos.
Un ejemplo sería una aplicación java donde queramos crear jugadores de fútbol. Si queremos que
las posiciones de los jugadores sean exclusivamente: PORTERO, DEFENSA, CENTROCAMPISTA y
DELANTERO podríamos 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 estáticas
Las importaciones estáticas nos permiten llamar a un método o propiedad estática 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
importación estática ha de usarse cuando sea necesario acceder frecuentemente a atributos de clase
(estáticos).
Sintaxis
Un solo método o propiedad
import static paquete. NombreClase.metodo_o_propiedad_static;
Todos los elementos estáticos de la clase
import static paquete.NombreClase.*;
Ejemplo
El siguiente ejemplo podemos apreciar como no es necesario acceder a las variables estáticas
prediciéndolas del nombre de la clase.
Supongamos que tenemos una clase llamada Jugador con tres propiedades: nombre, edad y
posición.
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 impresión que nos permita acceder a los miembros estáticos 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:
Diseño de clases eficiente.
Enunciado:
 Realizar una clase que contenga algunos métodos de la clase String, pero esta vez debemos
tratarla como un objeto desde otra clase externa.
 Los métodos que tendrá serán convertirMayusculas, convertirMinusculas, longitud, isNumeric.
Solución:
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
Introducción
Java implementa excepciones y aserciones con el propósito de conseguir código robusto.
En esta unidad veremos los pasos necesarios para poder controlar los posibles errores en nuestra
aplicación en tiempo de diseño y/o programación.
try-catch-finally
Cuando ocurre un error en un programa, el código que encuentra el error lanza una excepción que
se puede capturar desde la aplicación con el propósito de recuperarse de ella.
Existen dos modos de tratar las excepciones:
No tratarlas de forma detallada dejando a la máquina virtual de Java que realice la tarea que tenga
programada por defecto. Esto se realiza mediante la cláusula throws.
Tratamiento de la excepción
No tratando la excepción
public static void main(String args[]) throws IOException,... {

Código que puede lanzar las excepciones especificadas;
}
Tratando la excepción
public static void main(String args[]) {
try{
Código que puede lanzar las excepciones
}
catch( Excepción esperada) {
}
catch(Otra Excepcion esperada){
}
finally{
Código que se ejecuta siempre, aunque se lance la excepción
}
}
La sentencia finally es opcional.
Ejemplo de excepción 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 más 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 código 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, serán avisadas por el compilador
Creación de excepción propia:

En Java podemos crear una excepción 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 excepción 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 técnica de las aserciones consiste en sembrar el código 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 atrás las causas que han llevado a un fallo.
USO DE LAS ASERCIONES:

Distintas formas de utilizar una aserción:
assert dato > 15;
afirme dato==x+1;
assert Conectar();
Todas estas expresiones deben devolver un boolean. Si la condición que evaluamos es verdad, la
ejecución continúa normalmente, si no se lanza un AssertionError.
ACTIVAR/DESACTIVAR ASERCIONES:
Java no chequea las aserciones salvo que le indiquemos explícitamente 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 sólo 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 sólo 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 genéricos
Introducción
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 están
estructuradas en una jerarquía. A medida que se va descendiendo a niveles más específicos
aumentan los requerimientos y lo que se le pide a ese objeto que sepa hacer.
A partir de la versión 5 de Java se implementan los genéricos, gracias a los genéricos 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. Colección sin duplicados

Queue: Colección ordenada con extracción por el principio e inserción por el principio (LIFO) o por el
final (FIFO)
Map. Un grupo de pares objeto llave-valor. Un mapa es también 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 restricción 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 misión es la de recorrer a través 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 específico 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 métodos podríamos utilizarlos con List,
Queue o Set ya que extienden de collection pero que pueden incluir alguna restricción.
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 colección. 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 están 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 tamñao
strings = col1.toArray(new String[0]);
}
}
Resultado:
Los métodos más interesantes de una colección son:
Los elementos de una colección pueden pasarse a un array mediante
www.learning.es
List
El orden es la característica más importante de una lista, ya que mantiene elementos en una
secuencia particular. Podemos movernos en ambas direcciones de la lista a través de un ListIterator.
Son muy similares a un array, pero con tamaño 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 posición anterior, para cubrir el hueco que deja el elemento.
Esto hace que sacar elementos del medio o del principio sea costoso.
La segunda implementación 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 implementación 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 inserción 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
Colección 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 métodos 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 métodos 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 implementación 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 código hash es una manera de tomar parte de la información de un objeto y convertirla en un
entero único relativo con lo que las búsquedas se pueden hacer con mucha rapidez.
Un código hash debe estar basado en el contenido del objeto.
Queue:
Es una colección ordenada de elementos con métodos 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 inserción 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á vacía o llena, Queue proporciona métodos para
interrogar, que devuelven null. Por ello no se suele permitir inserción de null como valor
BlockingQueue: put()/take() se bloquean hasta que hay espacio/hay elementos.
Para añadir elementos

add() : en BoundedQueue eleva excepción si está llena
offer() : devuelve false si está llena, no eleva excepción
put() : Es de BlockinQueue y se bloquea si está llena
Para extraer elementos
remove() : extrae el elemento del principio. Excep. si vacío
poll() : como remove() pero si está vacía devuelve ull
take() : Es de BlockinQueue y se bloquea si está vacía
drainTo() : Es de BlockinQueue: vacía y devuelve colección
Para consultar sin extraer
element() : Devuelve, sin extraerlo, el primer elemento. Excep. si vacía
peek() : Como element() pero devuelve null si vacía
Implementaciones:
LinkedList: FIFO sin límite 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 método que espera
una colección.
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 métodos de ordenamiento. Esto se
logra implementando la interfaz java.util.Comparator.
Cuando nosotros creamos una clase de algún 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 método:
int compareTo(Object o)
El método compareTo () devuelve un entero con las siguientes características:
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 mayúsculas y minúsculas e imprimiendo
lo resultado por orden alfabético.
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("Gómez");
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;//método 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
}
}
Genéricos
Los tipos genéricos permiten forzar la seguridad de los tipos, en tiempo de compilación, en las
colecciones (u otras clases y métodos 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 genéricas tendríamos 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 también puede ser
una interface).
Cuando se utilizan colecciones genéricas, no es necesario castear los objetos cuando se obtienen de
la misma.
Se puede pasar una colección genérica como parámetro a un método que toma una colección no
genérica, pero los resultados pueden ser inesperados.
Compilar sin ningún error no es lo mismo que compilar sin ninguna advertencia. Una advertencia de
compilación no es considerado un error de compilación.
La información genérica de tipo no existe en tiempo de ejecución, es solo para la seguridad de tipos
en tiempo de compilación. Mezclando genéricos con código legal se puede compilar correctamente,
pero dicho código puede arrojar una excepción.
Las asignaciones polimórficas aplican solo al tipo base, no al parámetro de tipo genérico:
List<Deportes> l = new ArrayList< Deportes >(); // válido

List< Deportes > l = new ArrayList<Futbol>(); // invalido
La regla de asignación polimórfica aplica en cualquier lugar en donde se pueda realizar una
asignación:
void foo(List< Deportes > l) { } // no puede tomar un argumento List< Futbol >
List< Deportes > bar() { } // no puede devolver un List< Futbol >
La sintaxis comodín permite a un método genérico, aceptar subtipos (o supertipos) de un tipo
declarado_
como argumento de método: List<? extends Deportes >
Cuando se utiliza un comodin <? extends Futbol>, la colección puede ser accedida pero no
modificada.
Cuando se utiliza el comodin List<?>, cualquier tipo genérico puede ser asignado a la referencia,
pero solo_
para acceso, no para modificaciones.
List<?> es igual a List<? extends Object>.
Las convenciones de declaración utilizan la letra T para tipos y E para elementos de una colección.
Se puede utilizar más de un tipo parametrizado en una declaración.

Se puede declarar un tipo genérico utilizando un tipo que no esté definido en la clase:
public <T> void makeList(T t) { }
Por convención los tipos parametrizados son letras solitarias mayúsculas, sin esta convención sería
difícil leer el código 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 básicos de E/S
Introducción
En java todas las operaciones que constituyen un flujo de información 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 través 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 información.
Argumentos de la línea 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 parámetros que enviamos al ejecutar el programa.
Java impresiones Madrid Valencia Sevilla
El código 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 características del sistema donde ejecutamos nuestros
programas para evaluar el rendimiento que éste pueda tener o simplemente para propósitos
informativos. La clase System del paquete java.lang nos permite hacer uso del método getProperty
paraobtener la siguiente información:
java.version : Versión del entorno de desarrollo de Java (JRE).

java.vendor : Nombre de la distribución del JRE.
java.home: Directorio de instalación de la máquina virtual.
os.name: Nombre del sistema operativo.
www.learning.es
os.arch: Arquitectura del sistema operativo.
os.version: Versión 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 máquina virtual instalada.
java.vm.version: Versión de la máquina virtual instalada.
El siguiente ejemplo mostrará información de nuestra máquina 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 características:
– La clave y el valor de la tabla son strings

– La tabla puede ser grabada y recuperada de un stream con sólo una operación
– Valores por defecto pueden ser definidos en una tabla secundaria
– Debido a que Properties hereda de Hashtable , los métodos put y putAll se pueden
aplicar a un objeto Properties .
Métodos 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 enumeración de todas las claves del archivo de propiedades.
Creación de archivo de propiedades

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

# Nombre del servidor
servidor.nombre=PC9915
# Usuario para la conexión
servidor.usuario=Pepe
# Password para la conexión
servidor.password=poijasfr
Recuperación de la información 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 magnético que se utilizan para guardar información de forma persistente de
los programas java.
La información 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 básicas para trabajar con ficheros:
– Apertura del fichero

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

– Byte
– Caracteres
CLASES DEL PAQUETE IO

CLASE READER
Clase base que permite la lectura de la información de cualquier soporte de caracteres.
CLASE WRITER
Clase base que permite la escritura de la información en cualquier soporte de caracteres.
CLASE INPUTSTREAM
Clase base que permite leer la información de cualquier objeto en bytes
CLASE OUTPUTSTREAM
Clase base que permite escribir la información de cualquier objeto en bytes
TIPOS DE FICHEROS
Ficheros secuenciales: Se caracterizan por manejar información de distinta longitud. En un operación
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 información 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 métodos:
Utilizando la función createNewFile().

Escribir al menos un byte de información.
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 aplicación.
- File archivo3= new File(“Ejemplo3.txt”)
Al no poner ruta crea el fichero donde se está ejecutando la aplicación.
Métodos:
– canRead(): Boolean. True si se puede hacer una operación de lectura en un fichero o carpeta.
– canWrite(): Boolean. True si se puede hacer una operación 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 aplicación.
– 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 crearía 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 carácter 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 carácter.
– separator: Devuelve un string indicando el carácter que se utiliza dentro del sistema para
establecer la ruta a los recursos. En Windows es “\”.
– separatorChar: Idem del anterior pero lo devuelve como carácter.
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 número 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 métodos más interesantes de la clase File.
Enunciado
Crear en la unidad “c” de vuestra máquina una carpeta con el nombre TrabajosCurso.
Desarrollar una clase que nos permita recorrer y mostrar el número de ficheros que tenemos en esta
carpeta.
Solución
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 información 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 automáticamente 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
automáticamente 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
automáticamente y en el caso de que exista si el segundo argumento es true añade, y si es
falso sobrescribe.
Los tres constructores propagan una excepción IOException.
Métodos:
– void write(byte[],int,int): El primer argumento es una matriz de tipo byte con la información
que se va a escribir en el fichero, el segundo argumento es la posición dentro de la matriz a
partir de la cual voy a escribir en el fichero y el tercero y último es el número 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

información 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 excepción 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.
Métodos:
int read(byte[],int,int): El primer argumento es una matriz de tipo byte con la información leida del
fichero, el segundo argumento es la posición dentro de la matriz a partir de la cual voy a leer y el
tercero y último es el número de byte de la matriz que se van a leer.
Devuelve el número de byte leidos por del fichero.
Propaga excepción 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
Solución:
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 añadir 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
información 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 información 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 automáticamente 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 automáticamente 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
automáticamente y en el caso de que exista lo sobrescribe.
Métodos:
– void write(char[],int,int): El primer argumento es una matriz de tipo char con la información
que se va a escribir en el fichero, el segundo argumento es la posición dentro de la matriz a
partir de la cual voy a escribir en el fichero y el tercero y último es el número de byte de la
– void write(String): Útil para escribir la cadena que se pasa como argumento en el fichero.

información del fichero no
– se escribe y puede perder su contenido.
Los tres métodos propagan una excepción IOException.
CLASE FILEREADER
Clase que se utiliza para crear un flujo que te permite leer información que va en caracteres en un
fichero.
Constructores:
– FileReader(File): Abre un flujo para leer información 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 excepción de la clase
FileNotFoundException.
Métodos:
– int read(char[],int,int): El primer argumento es una matriz de tipo char en donde se gurda la
información leída del fichero, el segundo argumento es la posición dentro de la matriz a partir
de la cual voy a escribir en el fichero y el tercero y último es el número 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 métodos propagan una excepción 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.
Métodos:
– void writeUTF(String): Para escribir la cadena que se pasa como argumento. Este formato
incluye información 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 carácter el tipo entero que se pasa como
argumento(el código 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 información 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 información de los tipos primitivos de java, incluyendo la clase String.
Métodos:
Tiene los mismos métodos que la clase anterior:
writeUTFreadUTF
write...read....
...................
Los métodos propagan una excepción IOException.

Hay una excepción EOFExeption cuando intentas leer de un fichero que ya no tiene información.
Para leer la información a través de la clase DataInputStream, obligatoriamente esa información

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 métodos que DataOutputStream mas:

void writeObject(Object): Para escribir a través del flujo que está asociado al objeto que se pasa
como argumento.
Propagan la excepción IOException.
Para poder utilizar este flujo los objetos han de ser PERSISTENTES: Aquel que al ser escrito a través
de un flujo se encarga de almacenar los valores de sus variables miembro.
La serialización es el proceso por el cual un objeto o una colección 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 métodos, únicamente avisa
al compilador que los objetos que pertenecen a esa clase se encargan ellos mismos de guardar la
información 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 número de objetos a través del flujo.
En el caso particular de que el objeto destino sea un fichero, solo va a permitir una operación 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 aplicación.
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.
Métodos:
Mismos métodos 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 métodos propagan una excepción de la clase IOException.
www.learning.es
El método readObject propaga la excepción ClassNotFoundException(Cuando se intenta hacer un
cast al objeto que se ha leído de una case que no es), y la excepción
StreamCorruptedException(cuando se intenta hacer más de una operación de lectura a través 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 información 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 información de los clientes en
un fichero de texto. La escritura la realizaremos a través de la creación 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 Pérez",
"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 información

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 más fáciles 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 añadir información 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: sólo
lectura "r", o lectura/escritura "r/w".
RandomAccessFile Fichero = new RandomAccessFile ("datos.txt","rw");
En el siguiente ejemplo crearemos una aplicación 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 Módulo 2, en la plataforma elearning
Actividades
www.learning.es
Unidad 11. E/S de consola y E/S de archivos
Introducción
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, página web, applet,…
El acceso a la entrada y salida estándar de datos en Java es controlado por tres objetos que se
crean automáticamente al iniciar la aplicación: 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 código que lea de ellas sin saber qué estamos leyendo.
Por otro lado, es una pega. Como un InputStream es para leer bytes, sólo tiene métodos para leer
bytes. Nosotros queremos leer palabras o números del teclado, no bytes. Si escribimos en el teclado
una A mayúscula 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 más a lo que queremos.
Un Reader tiene métodos 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.
¿Cómo convertimos el System.in en Reader?. Hay una clase en java, la InputStreamReader, que nos
hace esta conversión. Para obtener un Reader, únicamente tenemos que instanciar un
InputStreamReader pasándole en el constructor un InputStream. El código 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 paréntesis 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 podríamos apañarnos. 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 cuántos
queremos (que no lo sabemos), o bien ir pidiendo de uno en uno hasta que no haya más.
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 pasándole en el construtor el Reader. El código es
BufferedReader br = new BufferedReader (isr);
El funcionamiento de esta clase es igual que el InputStreamReader. Cuando le pedmos una línea
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 método readLine(). Este método lee todos los caracteres tecleados
(recibidos si fuera otro dispositivo de entrada) hasta que encuentra la pulsación de la tecla
o como quieras llamarla.
String texto = br.readLine();
Objetivos
 Conocer los objetos que implementan la salida estándar 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
realizarán 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));
Métodos más impotantes:
skip(n): Ignora los n caracteres siguientes de la entrada.
read():Si no se ha introducido ningún carácter por el teclado devuelve el valor –
1. Devuelve el carácter que se ha introducido por el teclado leyéndolo del buffer de entrada y lo
elimina del buffer para que en la siguiente lectura sea leído el siguiente carácter.
En el siguiente ejemplo recogemos un número por teclado y mostramos en pantalla si el número es

par o impar.
import java.io.*;

String numero;
int dato=Integer.parseInt(numero);
if (dato%2==0){
else{
www.learning.es
}
}
Introduzca número:
5
El dato 5 es impar
System.out
Este objeto implementa la salida estándar. Se pueden utilizar los métodos print() y println() con
cualquier tipo básico Java como argumento.
Una de las novedades desde la versión 1.5 de java es el famoso printf tan usado en C. Este método
nos permite definir como representar multitud de tipos de datos sin mucho trabajo.
En este ejemplo obligamos la salida a 14 posiciones, con el símbolo 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 idénticas 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 número por teclado y mostramos en pantalla si el número es
par o impar. Si el número 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 operación" );
}
}
}
Introduzca número:
3
Dato impar no se puede realizar la operación
El dato 3 es impar
Actividades
www.learning.es
Unidad 12. Creación de interfaces gráficas
con el API Swing
Introducción
La base de la programación gráfica se encuentra en estos dos elementos físicos del ordenador, los
cuales se diseñaron de forma conjunta con el propósito de presentar información al usuario. El
comprender su funcionamiento ayuda a conocer lo que estamos haciendo cuando diseñamos un
entorno gráfico.
Monitor y tarjeta gráfica

El CRT (Tubo de Rayos Catódicos) está formado por los siguientes elementos:
- Cátodos: Aquí se generan tres haces de electrones cuya energía corresponden con los tres
colores básicos, a partir de los cuales podemos obtener el resto de colores.
- Sistema de enfoque: Mediante un sistema de electroimanes (campos magnéticos generados
a partir de señales eléctricas) enfocamos los tres haces de electrones sobre un punto de la
pantalla. Este sistema es el encargado también de realizar el desplazamiento de dichos haces
con el propósito 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. Además mantiene la impresión de los
haces durante un tiempo que junto con la persistencia de nuestra retina nos da la sensación
de permanencia.
A partir de este funcionamiento podemos definir una serie de parámetros:

- Pixel: la unidad básica de información de la imagen. Se corresponde con uno de los puntos
donde convergen los tres haces de electrones. El tamaño actual es de 0.28mm. Cuanto más
pequeño sea el pixel, mayores resoluciones podríamos obtener con el mismo tamaño de la
pantalla.
- Resolución vertical y horizontal (resolución): Es el número de píxeles que se están
representando de forma vertical (líneas) y de forma horizontal (número de puntos en una
línea). Resoluciones típicas son: 640x480, 800x600, 1024x768.
- Frecuencia de cuadro: Es el número de imágenes que se presentan por segundo. Esta
frecuencia se coge directamente de la frecuencia de la señal de red (50Hz) y debe ser valores
que eviten el parpadeo.
- Entrelazado: Tecnología que permite representar primero las líneas impares y posteriormente
las líneas 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 variación es analógica dentro del monitor, por tanto, podríamos conseguir
infinidad de colores, sin embargo, los circuitos que controlan estas intensidades (situados en
la tarjeta gráfica) manejan datos digitales que posteriormente se convierte a analógico con la
correspondiente pérdida de niveles.
La evolución de los monitores:

- CGA
- EGA
- VGA
- SVGA
Tarjeta gráfica. Este es el elemento que controla todas las señales que necesita el monitor para
presentar información en pantalla. En concreto:
- Señales de temporización para el movimiento de los haces.
- Señales RGB para el control de la intensidad de los haces (colores).
www.learning.es
La información de los colores son datos binarios situados en la memoria que tiene la propia tarjeta
gráfica. Un conjunto de posiciones de memoria alberga la información para cada pixel. Por tanto, la
resolución y número de colores que podemos obtener depende de la memoria que disponga la
tarjeta.
Conclusión: Por tanto cuando aparece un elemento gráfico en pantalla, tan sólo se han situado en la
zona de memoria correspondiente un conjunto de datos binarios que codifican los colores del
conjunto de píxeles de la zona de pantalla en concreto.
El sistema de coordenadas.
A la hora de diseñar los programa de bajo nivel que faciliten a los programadores su trabajo con el
entorno gráfico, es necesario establecer algún sistema de referencia que ponga orden en el mar de
píxeles de la pantalla. Se acordó que el origen de coordenadas (0,0) sería la esquina superior
izquierda, la coordenada x serían las líneas, y la coordenada y serían las columnas.
Ahora bien, los lenguajes de programación pueden manejar coordenadas relativas o absolutas.
- Coordenadas absolutas: Cualquier elemento que se sitúe sobre la pantalla (por ejemplo,
un botón) tendrá su origen de coordenadas en la esquina superior izquierda y tendrán 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 transformación 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
posición determinada por su anchura y altura totales, menos una unidad.
La unidad de medida son los píxeles.
A la hora de un pintar un Componente, se debe tener en cuenta, además del tamaño ya comentado,
el tamaño del borde del Componente, si lo tuviera. Por ejemplo, un borde que ocupará un pixel
alrededor del componente, haría que la coordenada de la esquina superior izquierda pasase de ser
(0,0) a (1,1) y reduciría además la anchura y altura totales del Componente es dos píxeles, uno por
cada lado.
Clases de Java para la programación gráfica y su evolución.

Al enfrentarse con el desarrollo de una aplicación gráfica, el programador debe conocer las
herramientas que le ofrece el lenguaje de programación que va a utilizar. Java dispone de una serie
de clases para este menéster. Estas clases se encuentran en los siguientes paquetes:
Java.awt: El AWT (Abstract Window Toolkit) es el primer paquete que diseño Sun para el desarrollo
de entornos gráficos.
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.
Programación gráfica con Swing

Swing hay que verlo como una extensión de AWT, por tanto, no hay que olvidar lo aprendido en
AWT. Es más, en la mayoría de los casos es suficiente con añadir una "J" al componente AWT para
que se convierta en un componente Swing.
En Swing, los componentes de la interfaz gráfica son Beans. Todos los componentes son "ligeros"
(lightweight), es decir, ya no se usan componentes dependientes del sistema operativo.
Se utiliza sólo el nuevo modelo de Delegación de eventos.
Son muchas las ventajas que ofrece el uso de Swing:
www.learning.es
- La navegación con el teclado es automática, es decir, cualquier aplicación Swing se puede
usar sin el ratón sin tener que añadir líneas de código adicionales.
- Las etiquetas de información ("tool tips") se pueden crear con una sola línea de código. Estas
etiquetas de información son las que aparecen cuando nos situamos con el ratón sobre un
componente del interfaz gráfico.
Con respecto al AWT, Swing incorpora muchos aspectos que permiten mejorar el entorno gráfico.
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 continuación pasamos a describir las nuevas clases agrupadas según lo que sean:
Sumario de clases del paquete javax.swing
BoxLayout Un gestor de trazado nuevo que permite a múltiples componentes ser
colocados según un eje horizontal o vertical.
JRootPane El componente fundamental en la jerarquía de contenedores.
JWindow Una representación de una ventana.
JApplet Una versión extendida de java.applet.Applet que añade nuevas
funcionalidades, por ejemplo, pueden añadirse barras de menú de
Swing.
JDialog La clase principal para crear una ventana de diálogo.
JFrame Una versión extendida de java.awt.Frame que añade funcionalidades
extras.
JPanel JPanel es un contenedor ligero genérico.
JInternalFrame Un objeto ligero que proporciona muchas de las características de
una ventana nativa, incluyendo "pinchar y arrastrar", cerrado,
iconizado, redimensionado, título y barra de menú.
JComponent La clase base para los componentes Swing.
AbstractButton Define el comportamiento común de las clases JButton,
JToggleButton, JCheckbox y JRadioButton. Es una clase abstracta y,
por tanto, no pueden crearse objetos.
AbstractListModel La definición abstracta para el modelo de datos que proporciona una
lista con sus contenidos.
JButton Un botón Swing.
JCheckBox Un CheckBox Swing.
JRadioButton Una implementación de un botón tipo radio
JToggleButton Una implementación de un botón de dos estados.
ButtonGroup Esta clase permite crear un grupo de botones con exclusión múltiple.
JLabel Un área para visualizar un texto corto, una imagen o ambos.
JComboBox Implementación de Swing de un ComboBox -- Un ComboBox es una
combinación 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 más objetos
de una lista.
ImageIcon Una implementación del interface Icon que permite pintar iconos a
partir de imágenes.
JTextField Una implementación de una caja de texto..
JPasswordField JPasswordField es un campo de texto tipo password.
JTextArea Una implementación de un textarea.
JScrollPane Un contenedor que permite añadir 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 gráficamente un
www.learning.es
Sumario de clases del paquete javax.swing
valor desplazando una barra dentro de un intervalo.
JMenuBar Una implementación de una barra de menú.
JMenu Una implementación de un menú.
JMenuItem Una implementación de un MenuItem.
JPopupMenu Una implementación de un menú emergente
JRadioButtonMenuItem Una implementación de un item de menú tipo radio.
JCheckBoxMenuItem Un item de un menú Swing que puede ser seleccionado o no.
JSeparator Una implementación de un separador de opciones de menú.
JToolBar Una implementación de una barra de herramientas.
JColorChooser Esta clase proporciona un panel de controles diseñado 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 diálogo estándar
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 representación gráfica.
JScrollBar Una implementación de una barra de desplazamiento.
JTabbedPane Un componente que permite al usuario desplazarse entre un grupo
de componentes pulsando el tabulador con un título y/o icono dado.
JSplitPane JSplitPane se usa para dividir dos (y sólo 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 ejecución.

Realizar un programa que permita modificar dinámicamente el número de controles que contiene un
contenedor en un JFrame.
Al pulsar sobre agregar, iremos agregando botones hasta el máximo de diez botones.
Al pulsar sobre Eliminar, iremos eliminando botones del contenedor de uno en uno.
Con el botón 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 aplicación 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 diálogo

Objetivo
Utilizar los cuadros de diálogo de Swing.
Enunciado
www.learning.es
- Realizar una aplicación en la que cargaremos los distintos cuadros de dialogo que nos
proporciona Swing.
- En el botón de maximizar, haremos la ventana tan grande como la pantalla.
- En el botón de dialogo, mostraremos una ventana que nos indique la versión de la aplicación
y así con cada uno de los diálogos 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("Acción 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("Acción 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 Gráfica,

en la Unidad 12, en el Módulo 2, en la plataforma elearning
Actividades
www.learning.es
Unidad 13. Control de eventos generados por
la interfaz gráfica
Introducción
El modelo antiguo de eventos está basado en la herencia.

Para que un programa capture eventos de una interfaz gráfica, los componentes deben ser
subclases de la interfaz y sobreescribir los métodos action() y handleEvent().
Cuando uno de los métodos devuelve true, el evento ya no es procesado más allá, en caso contrario,
el evento se propaga a través de la jerarquía de componentes de la interfaz hasta que sea tratado o
alcance al jerarquía de componentes.
Hay dos elecciones para estructurar el código de gestión de eventos:
Cada componente individual puede hacerse subclase para manejar específicamente 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 delegación. (Source, Listener,

Adapter).
Los eventos ahora están organizados en jerarquías 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 Descripción

Es la clase raíz de la cual derivarán todos los eventos.
Tiene dos métodos de interés que son:
EventObject Object getSource() --> Devuelve el objeto sobre el que se ha
producido el evento.
String toString() -->Da una representación en forma de String.
Es la clase raíz de la cual derivan todos los eventos del AWT.
Es una clase abstracta.
De interés son:
AWTEvent - Sus campos estáticos que almacenan los valores para diferentes tipos
de eventos.
- El método int getID() que devuelve un número 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 tamaño, ...
Deriva de AWTEvent.
ComponentEvent
Estos eventos se producen sólo con propósitos de notificación. 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 método addComponentListener sobre el
objeto sobre el cual queremos recibir los eventos.
Son de interés:
- 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 método 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 añade o se quita un
objeto de él.
El evento es pasado a cada ContainerListener o AdapterListener que se
haya dado de alta mediante el método 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 añadido, se ha quitado, ...
- Sus métodos: 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 añadido, 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 método addWindowListener() para ser
notificados.
El método getWindow() devuelve la ventana que generó el evento.
Es el evento raíz 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 ratón).
A continuación vemos MouseEvent.
Indica que una acción de ratón ha sucedido sobre un componente.
Eventos de ratón
- Un botón del ratón es presionado.
- Un botón del ratón es liberado
- Un botón del ratón es clickeado (presionado y liberado)
- El cursor del ratón entra en un componente.
- El cursor del ratón sale del componente.
MouseEvent
Mouse Motion Events
- El ratón es movido.
- El ratón es arrastrado con botón pulsado (dragged)
Estos eventos se envían a los MouseListener y MouseAdapter que se
hayan registrado mediante el método addMouseListener().
Dispone de una serie de métodos tipo get (getX, getY, getPosition,
getClickCount para recoger información 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 método 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 método 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
acción.
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 duración.
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í podríamos ir actualizando el código 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 más de un Frame en un proyecto.
Enunciado
- Realizar una aplicación en la que podremos movernos entre diferentes Frames que hayamos
creado previamente en nuestra aplicación.
- Tendremos 3 ventanas JFrame, en cada una de las ventanas podremos pasar a la siguiente o
la anterior, dependiendo de la posición del conjunto.
- En la ventana final podremos cerrar la aplicación, o movernos entre las diferentes ventanas
que tengamos.
- Crearemos una clase principal que se encargará de iniciar la aplicación, del movimiento y de
terminar la aplicación.
www.learning.es
- Pondremos un control JProgressBar para saber dónde estamos posicionados en el conjunto
de ventanas.
CLASE PRINCIPAL PARA ADMINISTRAR LOS MOVIMIENTOS
En ésta clase, los objetos serán 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 imágenes

Objetivo
Trabajar con componentes gráficos.
Enunciado
- Realizar una aplicación para cargar imágenes dinámicamente desde una ruta dada.
- Tendremos la posibilidad de cambiar el tamaño de la imagen a nuestra conveniencia,
dependiendo si queremos darle un tamaño 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 método
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 después la práctica con un JLABEL y utilizando el método 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 gráfica
Introducción
En Swing disponemos de cuatro calse importantes para la creación de interfaces basadas en la
creación de menúes que son: JMenu, JMenuBar, JMenuItem y JPopupMenu. Un menú en una
aplicación no es más que un JMenuBar en el que hay varios menús como veremos en esta unidad.
En esta imagen podemos apreciar las diferentes secciones a las que hacen referencia las clases
relacionadas con menús de Java:
Objetivos
 Conocer las principales clases en la elaboración de menús con java
 Aprender a realizar un toolbar con java
Creación de un menú
Las tres clases más 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 JMenúBar, 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.
Jerarquía de clases para realizar un menú:
www.learning.es
Ejemplo de creación de un Menú:
En el siguiente ejemplo crearemos un Menú con las opciones archivo y editar como se muestra en la
imagen.
public EjSwing(){
//Creación 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
Creación de un Toolbar
Un objeto JToolBar crea una barra de herramientas para la inserción de componentes dentro de una
fila o una columna. Normalmente las barras de herramientas proporcionan acceso a funcionalidades
que también se encuentran en ítems de menús.
En esta figura se aprecia un toolbar creado en una aplicación distribuida
Ejemplo de creación 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);
}
}
También podemos insertar iconos en la barra de herramientas:
www.learning.es
ImageIcon ImagenGuardar=new ImageIcon("guardar.gif");
bot1.setIcon(ImagenGuardar);
Sus propiedades más comunes son:

Autoscrolls(), Background(), Border(), Bounds(), Cursor(), Enabled(), Font(),
Foreground(),Floatable(), Insets(), Layout(), Margin(), Name(), Opaque(), Orientation(),
ToolTipText(), Visible(), VisibleRect().
Sus eventos más 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.
Creación de un JPopupMenu
// Demostración 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; además

// 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 anónima
// manejar evento de oprimir botón del ratón

public void mousePressed( MouseEvent evento )
{
checkForTriggerEvent( evento );
}
// manejar evento de soltar el botón del ratón

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 anónima
); // 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 cuál 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: Creación de un Toolbar, en la Unidad 14,

Actividades
www.learning.es
Unidad 15 . Hilos
Introducción
Todos los ejemplos que hemos realizado hasta este punto han sido desarrollados con un solo hilo de
ejecución, es decir, únicamente realizamos una tarea.
La programación multihilo o multitarea permitirá lanzar varias acciones dentro de un mismo
programa, de esta manera podremos realizar distintas tareas simultáneamente. El sistema con el
que estemos trabajando se encargará de la ejecución 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 información entre ellos, es
necesario usar algún sistema de sincronización 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 DEFINICIÓN
Un objeto Thread representa a una tarea en ejecución. Aquí se implementan
Thread
métodos que van a permitir gestionar tareas individualmente.
Un objeto de este tipo representa a un conjunto de Threads y proporciona métodos
ThreadGroup
para gestionar dicho grupo.
Ciclo de vida de un thread
Inicio tarea
Cuando se crea una nueva tarea, ésta no se arranca automáticamente sino que hay que usar el
método 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 métodos:
 start() : Método que crea los recursos necesarios para que la tarea se pueda ejecutar. No
conviene sobreescribir este método, el cual se implementa en la clase Thread.
 run(): Método equivalente al main de las aplicaciones que hemos realizado hasta ahora. En
este método es dónde el programador deberá poner el código que desea que se ejecute en la
tarea.
Detener la tarea
Una tarea se puede detener por los siguientes motivos:

 Llamando al método sleep().
 Cuando la tarea usa su método wait() para esperar a que se cumpla una condición.
 Cuando la tarea queda bloqueada en algún 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 operación de E/S, cuando dicha operación se realice.
 Si se paró por wait(), llamando al método notify() o notifyAll() y que la condición por la que
se espera se cumpla. Se llamará por tanto a alguno de esos métodos cuando la variable que
controla condición varíe.
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), además lanzará la tercera clase que es un
programa que solicita información 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("Método 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("Método Run de Teclado");
try{
for (int i=0;i<15;++i){
System.out.println("Introduzca línea de texto:");

linea=bin.readLine();
System.out.println("Usted escribió: "+linea);
}
}
catch(IOException e){
}
}
}
SALIDA DEL PROGRAMA:
www.learning.es
Métodos de la clase Thread
start()
Este método indica al intérprete de Java que cree un contexto del hilo del sistema y comience a
ejecutarlo. A continuación, el método run() de este hilo será invocado en el nuevo contexto del hilo.
Hay que tener precaución de no llamar al método start() más de una vez sobre un hilo determinado.
run()
El método run() constituye el cuerpo de un hilo en ejecución. Este es el único método del interfaz
Runnable. Es llamado por el método start() después de que el hilo apropiado del sistema se haya
inicializado. Siempre que el método run() devuelva el control, el hilo actual se detendrá.
stop()
Este método provoca que el hilo se detenga de manera inmediata. A menudo constituye una manera
brusca de detener un hilo, especialmente si este método se ejecuta sobre el hilo en curso. En tal
caso, la línea inmediatamente posterior a la llamada al método stop() no llega a ejecutarse jamás,
pues el contexto del hilo muere antes de que stop() devuelva el control. Una forma más elegante de
detener un hilo es utilizar alguna variable que ocasione que el método run() termine de manera
ordenada
currentThread()
Este método devuelve el objeto thread que representa al hilo de ejecución que se está ejecutando
actualmente.
sleep( long )
El método sleep() provoca que el intérprete ponga al hilo en curso a dormir durante el número de
milisegundos que se indiquen en el parámetro de invocación. Una vez transcurridos esos
milisegundos, dicho hilo volverá a estar disponible para su ejecución. Los relojes asociados a la
mayor parte de los intérpretes de Java no serán capaces de obtener precisiones mayores de 10
milisegundos, por mucho que se permita indicar hasta nanosegundos en la llamada alternativa a
este método.
yield()
Este método hace que el intérprete 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
inanición.
suspend()
El método suspend() es distinto de stop(). suspend() toma el hilo y provoca que se detenga su
ejecución sin destruir el hilo de sistema subyacente, ni el estado del hilo anteriormente en ejecución.
Si la ejecución de un hilo se suspende, puede llamarse a resume() sobre el mismo hilo para lograr
que vuelva a ejecutarse de nuevo.
resume()
El método resume() se utiliza para revivir un hilo suspendido. No hay garantías de que el hilo
comience a ejecutarse inmediatamente, ya que puede haber un hilo de mayor prioridad en ejecución
actualmente, pero resume() ocasiona que el hilo vuelva a ser un candidato a ser ejecutado.
www.learning.es
getPriority()
Este método devuelve la prioridad del hilo de ejecución en curso, que es un valor comprendido entre
uno y diez.
setPriority( int )
El método setPriority() asigna al hilo la prioridad indicada por el valor pasado como parámetro. 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 guía aproximada de utilización, se puede establecer que la mayor parte de
los procesos a nivel de usuario deberían 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, deberían tener
una prioridad cercana a MIN_PRIORITY. Con las tareas a las que se fije la máxima 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 intérprete Java quede totalmente fuera de control.
getName()
Este método devuelve el valor actual, de tipo cadena, asignado como nombre al hilo en ejecución
mediante setName().
setName( String )
Este método permite identificar al hilo con un nombre menmónico. De esta manera se facilita la
depuración de programas multihilo. El nombre mnemónico aparecerá en todas las líneas de trazado
que se muestran cada vez que el intérprete Java imprime excepciones no capturadas.
Uso de Wait y Notify

Los métodos wait(), notify() y notifyAll() deben ser llamados desde un contexto sincronizado.
El método wait() permite a un hilo pausar su ejecución hasta que se le notifique que ocurrió algo de
lo que se tiene que encargar.
El método notify() se utiliza para enviar una señal a un y solo un hilo que se encuentra esperando.
El método notify() no permite especificar que hilo en espera se va a notificar.
El método notifyAll() funciona del mismo modo que notify, a diferencia que envía señales a todos los
hilos esperando por un objeto.
Ejemplo del uso de estos métodos
En el siguiente ejemplo usamos los métodos 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("Método 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("Método Run de Actualiza");
www.learning.es
actualiza();
// El método wait() y notify() deben estar dentro de un método

// 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 actualización");
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
Sincronización
Uso
La cuestión cuando se trabaja con threads es que la ejecución avanza en varias partes del programa
a la vez. Cada una de esas ejecuciones simultáneas pueden tocar los mismos objetos.
Los métodos synchronized previenen que más de un hilo acceda al código de un método crítico
simultáneamente.
Para sincronizar un bloque de código, se debe especificar un argumento que es el objeto que se
utilizara como cerradura para la sincronización.
Se puede utilizar la palabra clave synchronized como un modificador de un método, o como un
iniciador de un bloque de código sincronizado.
Mientras que solo un hilo puede acceder al código sincronizado de una instancia en particular,
múltiples hilos pueden acceder al código no sincronizado de una misma instancia.
Cuando un hilo se duerme, su cerradura no se encuentra disponibles para otros hilos.
Ejemplo de sincronización
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 método operar");

}
Actividades
www.learning.es
Unidad 16. Programación en red
Introducción
Java tiene como ventaja frente a otros lenguajes de programación 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 DIRECCIÓN IP.
La comunicacón entre los equipos se realiza mediante dos protocolos de transmisión:

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

Dependiendo de lo que vaya a hacer usare un protocolo u otro.
TCP/IP: Mas seguro. Envía información de una maquina a otra. Esta información se envía en tramas
que son bloques de información que van codificadas en bytes(0 y 1).
Este protocolo envía las tramas, en el caso de producirse perdidas reenviarlas y una vez llegadas al
destino ordenarlas.
Además de protocolo se necesita un puerto. Son numéricos. Es el mecanismo por el que entra
información en la maquina o por el que la maquina envía información.
UDP: Es el protocolo universal de datos. Es el mas rápido y menos seguro. A una dirección manda
información y no se preocupa de que la dirección 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
máquinas.
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
}
}
}
Métodos de la clase
getLocalHost(): Devuelve el nombre de la maquina y la dirección IP. Para llamarlo

InetAddress.getLocalHost().
www.learning.es
getHostAddress(): Devuelve una cadena con la dirección IP. Para llamarlo
nombre_objeto.getHostAddress().
getHostName(): Devuelve una cadena con el nombre de la máquina. Para llamarlo

nombre_objeto.getHostName().
getByName( String): Determina la dirección IP del host a partir del nombre del host. Para llamarlo
InetAddress getByName(nombre).
getAddress(): Mete la dirección 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 métodos más importantes de la clase InetAddress.
Enunciado
Crear un clase que utilice los métodos más importantes de la clase InetAddress y muestre la
información 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

Solución:
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 método para la comunicación entre un programa del cliente y un programa del
servidor en una red. Un socket se define como el punto final en una conexión El Socket es donde el
cliente o el servidor escriben la información que transferimos.
Las clases Socket y ServerSocket del paquete java.net proporcionan un canal de comunicación
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 información que nos está entrando.
import java.net.*;
import java.io.*;
public class ejSocket{
try{
Socket misocket = new Socket("Servidor ",13);
//Creación 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");
}
}
}
Métodos de la clase Socket
getInputStream() : Abrir el canal de entrada de información
getOutputStream(): Abrimos el canal salida
close() : Cerramos el Socket
InetAddress getInetAddress() : Devuelve un objeto InetAddress con el nombre y la dirección 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 dirección.

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

int puerto = n_socket.getLocalPort();
Ejemplo de utilización de algunos de los métodos
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 excepción 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 comunicación
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 código fuente de una página
html. Luego podemos hacer un programa que interprete ese código y los transforme en elementos
java.
www.learning.es
También nos va a permitir obtener información 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.
Información del servidor: fecha de creación....
Comunicación de varios ordenadores
¿Cómo 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 dirección de la página, 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 podríamos 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");
}
}
}
Métodos 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 métodos
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 conexión como la del Socket pero más completa.
Podremos pedir más información al servidor: fecha de creación, tipo de fichero al que vamos a
acceder...
Pasos para crear una conexión

Creamos un objeto de la clase URL
Creamos un objeto de la clase URLConnection con el método openConnection del objeto url
URL miurl = new URL (“http://www.yahoo.com”);
URLConnection conexion = miurl.openConnection();
Especificaciones de la conexión:
Registrarnos
Podemos indicar si queremos tener abiertos canales de entrada y salida.
Conectarnos a partir de una fecha (por si queremos que la página 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 método 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 información son el protocolo TCP/IP y si esta
información llegaba mal la volvíamos a enviar.
Con los datagramas podemos enviar información más rápida, pero como desventaja la información
se puede perder.
La clase DatagramPacket nos permite elaborar paquetes de información. La clase DatagramSocket

sirve para enviar y recibir la información.
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 dirección y el

puerto, no como en Socket que se hace directamente.
DatagramSocket dtSocket= new DatagramSocket();
3. Usamos el método 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 información.
DatagramSocket otroSocket = new DatagramSocket(puerto);
Recibimos el paquete con el método 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 mostraría 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 información
socketDatagrama.receive(paquete);
System.out.println("Recibida llamada en el puerto 5000"); _
//Solo salta si recibo algo
//Reenvio la _
información recibida, construyo un paquete con la información 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 Invocación Remota de Métodos (RMI) de Java permite a un objeto que se está
ejecutando en una Máquina Virtual Java realizar llamadas a métodos de otro objeto que está en otra
Máquina Virtual Java diferente.
Relación cliente-servidor
En la parte del servidor tenemos:
 Aplicación 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 aplicación 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 clonáramos y lo dividiéramos en dos Stub
y Skeleton.
 La representación del objeto (Stub). Esto es lo que se coloca en el servicio de nombres.
Registra el stub en el servicio de nombres.
 Otra representación del objeto (Skeleton).
 Los registramos en el servicio de nombres.
 Clase/s sirviente/s: clase que genera unos objetos que utilizará el cliente. Tendrá métodos
que podrá usar el cliente y otros que no. Para ello:
 Declaramos una interfaz que nos diga los métodos de los objetos de la clase sirviente a los
que podemos acceder. La clase sirviente debe implementar este interfaz.
En la parte del cliente:
 Aplicación cliente: Queremos trabajar con métodos de objetos que están en el servidor. La
aplicación 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 representación del listado de objetos.
 Nos traemos “representación” 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 aplicación que devuelve el cuadrado de el factorial de un numero. Un cliente llama a un
método del servidor y devuelve el cuadrado del factorial de un número. El cuadrado y el factorial lo
hacemos en dos métodos. En el interface solo ponemos el cuadrado. Desde el cliente solo podremos
llamar al método cuadrado. Cuadrado llamara al factorial. De momento desde el cliente no pasamos
parámetro.
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); //Número 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; //Número 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

PDF M2 Java PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

PDF M2 Java PDF

Cargado por

Copyright:

Formatos disponibles

Módulo 2

* Diferentes máquinas desde el punto de vista del hardware

- Diferentes máquinas desde el punto de vista del hardware.

La máquina virtual Java (JVM)

La especificación de la JVM proporciona definiciones muy concretas para la implementación de:

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

En C, C++, y otros lenguajes, el programador es responsable de la gestión de la liberación de

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

El proceso de "Garbage collection" se realiza automáticamente durante el ciclo de vida de un

Seguridad del código

En el momento de la ejecución, los diferentes archivos bytecodes que componen el programa a

En el proceso de verificación se resuelve si el código 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 sintácticas de los lenguajes de programación

Comentarios en los programas

Tipos de datos básicos

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

Estas operaciones no sólo se limitan a operaciones aritméticas. Disponemos también de operaciones

Tomar decisiones sobre la ejecución o no de determinadas tareas en base al cumplimiento o no de

Almacenamiento de datos mediante Arrays.

Desarrollador del lenguaje de programación. Su conocimiento de la máquina es profundo debido a

Posteriormente, estos lenguajes se han podido utilizar para el desarrollo de tecnologías de

Programador de aplicaciones. Su conocimiento suele centrarse en el lenguaje de programación que

Programador. Aprovechando que el desarrollador del lenguaje de programación 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 básicos para poder comprender el concepto de propiedad

La lógica de funcionamiento se implementa en el código de cada método

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 opción");

System.out.println("La opción debe ser un número");

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 implementación siempre será de dos partes: la declaración y el cuerpo:

[ModificadoresAcceso] TipoRetorno nombreMétodo ([lista_de_argumentos]) [excepciones]{

Para devolver un valor se utiliza la palabra clave return.

Si se declara un método anteponiendo la palabra static, éste se convierte en un método estático o

Sobrecarga de métodos 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 métodos sobrecargados:

public void Metodo1(int edad) // Sobrecarga con un parámetro

public static void main (String [] var)

Utilizar comentarios en el código fuente

En java hay tres tipos de comentarios:

Siguientes caracteres Pueden ser letras, números o símbolos.

Longitud No hay una longitud máxima establecida.

Mayúsculas / Minúsculas Se distinguen las mayúsculas de las minúsculas.

No se pueden usar Palabras clave.

abstract double Int static