feat(ch 5 & 6): examples added

src/tutorialJava/capitulo5/ej06_PatronSingleton/Player.java

@@ -0,0 +1,37 @@
+package tutorialJava.capitulo5.ej06_PatronSingleton;
+
+public class Player {
+
+	private String nombre;
+	
+	private static Player instance = null; // Singleton
+	
+	// Singleton
+	public static Player getInstance() {
+		if (instance == null) {
+			instance = new Player("Nave");
+		}
+		return instance;
+	}
+
+	public Player(String nombre) {
+		super();
+		this.nombre = nombre;
+	}
+
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	@Override
+	public String toString() {
+		return "Player [nombre=" + nombre + "]";
+	}
+	
+	
+	
+}

src/tutorialJava/capitulo5/ej06_PatronSingleton/Principal.java

@@ -0,0 +1,14 @@
+package tutorialJava.capitulo5.ej06_PatronSingleton;
+
+public class Principal {
+
+	public static void main(String[] args) {
+		
+		// Desde un localizador de colisiones
+		System.out.println("Llamada 1: " + Player.getInstance());
+		
+		System.out.println("Llamada 2: " + Player.getInstance());
+
+	}
+
+}

src/tutorialJava/capitulo5/ej07_InterfaceWindowListener/KKListener.java

@@ -0,0 +1,82 @@
+package tutorialJava.capitulo5.ej07_InterfaceWindowListener;
+
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+
+public class KKListener implements WindowListener, MouseListener {
+
+	@Override
+	public void mouseClicked(MouseEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void mousePressed(MouseEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void mouseReleased(MouseEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void mouseEntered(MouseEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void mouseExited(MouseEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void windowOpened(WindowEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void windowClosing(WindowEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void windowClosed(WindowEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void windowIconified(WindowEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void windowDeiconified(WindowEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void windowActivated(WindowEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+	@Override
+	public void windowDeactivated(WindowEvent e) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

src/tutorialJava/capitulo5/ej07_InterfaceWindowListener/Principal.java

@@ -0,0 +1,37 @@
+package tutorialJava.capitulo5.ej07_InterfaceWindowListener;
+
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.awt.event.WindowListener;
+
+import javax.swing.JFrame;
+
+public class Principal {
+
+	
+	
+	public static void main(String[] args) {
+		
+		JFrame ventana = new JFrame("Título de la ventana");
+		ventana.setBounds(0, 0, 800, 600);
+		ventana.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
+
+		ventana.addWindowListener(new WindowAdapter() {
+
+			@Override
+			public void windowClosing(WindowEvent e) {
+				super.windowClosing(e);
+			}});
+		
+		ventana.setVisible(true);
+
+	}
+
+}
+
+
+
+
+
+
+

src/tutorialJava/capitulo5/simulacroExamen01_poker/Baraja.java

@@ -0,0 +1,116 @@
+package tutorialJava.capitulo5.simulacroExamen01_poker;
+
+import tutorialJava.Utils;
+
+public class Baraja {
+
+	private Carta baraja[] = new Carta[52];
+	
+	public Baraja () {
+		for (int i = 0; i < 13; i++) {
+			baraja[i] = new Carta();
+			baraja[i].setValor(i + 1);
+			baraja[i].setPalo("Picas");
+		}
+		for (int i = 0; i < 13; i++) {
+			baraja[i + 13] = new Carta();
+			baraja[i + 13].setValor(i + 1);
+			baraja[i + 13].setPalo("Diamantes");
+		}
+		for (int i = 0; i < 13; i++) {
+			baraja[i + 26] = new Carta();
+			baraja[i + 26].setValor(i + 1);
+			baraja[i + 26].setPalo("Tréboles");
+		}
+		for (int i = 0; i < 13; i++) {
+			baraja[i + 39] = new Carta();
+			baraja[i + 39].setValor(i + 1);
+			baraja[i + 39].setPalo("Corazones");
+		}
+		
+		// Inicializo id de ordenación de cada carta
+		for (int i = 0; i < baraja.length; i++) {
+			baraja[i].setIdOrdenacion(i);
+		}
+	}
+
+	
+	public void pasaCartaDeAbajoHaciaArriba() {
+		Carta aux = baraja[baraja.length - 1];
+		for (int i = (baraja.length - 1); i > 0; i--) {
+			baraja[i] = baraja[i - 1];
+		}
+		baraja[0] = aux;
+	}
+	
+	public void pasaCartaDeArribaHaciaAbajo() {
+		Carta aux = baraja[0];
+		for (int i = 0; i < (baraja.length - 1); i++) {
+			baraja[i] = baraja[i + 1];
+		}
+		baraja[baraja.length - 1] = aux;
+	}
+	
+	public void mezclar() {
+		for (int i = 0; i < baraja.length; i++) {
+			int indice1 = Utils.obtenerNumeroAzar(0, baraja.length - 1);
+			int indice2 = Utils.obtenerNumeroAzar(0, baraja.length - 1);
+			
+			Carta aux = baraja[indice1];
+			baraja[indice1] = baraja[indice2];
+			baraja[indice2] = aux;
+		}
+	}
+	
+	public void ordenar() {
+		boolean hayIntercambios;
+		do {
+			hayIntercambios = false;
+			for (int i = 0; i < (baraja.length - 1); i++) {
+				if (baraja[i].getIdOrdenacion() > baraja[i + 1].getIdOrdenacion()) {
+					Carta aux = baraja[i];
+					baraja[i] = baraja[i + 1];
+					baraja[i + 1] = aux;
+					hayIntercambios = true;
+				}
+			}
+		} while (hayIntercambios == true);
+	}
+	
+	public void reparteManoAJugador(Jugador j) {
+		int cartasDadas = 0;
+		for (int i = baraja.length - 1; i > -1 && 
+				cartasDadas < j.getMano().length; i--) {
+			
+			if (baraja[i] != null) {
+				j.getMano()[cartasDadas] = baraja[i];
+				cartasDadas++;
+				baraja[i] = null;
+			}
+		}
+	}
+	
+	
+	public Carta[] getBaraja() {
+		return baraja;
+	}
+	public void setBaraja(Carta[] baraja) {
+		this.baraja = baraja;
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo5/simulacroExamen01_poker/Carta.java

@@ -0,0 +1,63 @@
+package tutorialJava.capitulo5.simulacroExamen01_poker;
+
+public class Carta {
+
+	private int valor;
+	private String palo;
+	private int idOrdenacion;
+	
+	public Carta () {
+	}
+
+	public String toString() {
+		StringBuffer sb = new StringBuffer();
+		
+		switch(valor) {
+		case 1:
+			sb.append("As"); break;
+		case 11:
+			sb.append("J"); break;
+		case 12:
+			sb.append("Q"); break;
+		case 13:
+			sb.append("K"); break;
+		default:
+			sb.append(valor);
+		}
+		
+		sb.append(":");
+		
+		if (palo.equalsIgnoreCase("Corazones")) sb.append("C");
+		else if (palo.equalsIgnoreCase("Tréboles")) sb.append("T");
+		else if (palo.equalsIgnoreCase("Diamantes")) sb.append("D");
+		else sb.append("P");
+		
+		return sb.toString();
+	}
+
+	public int getValor() {
+		return valor;
+	}
+
+	public void setValor(int valor) {
+		this.valor = valor;
+	}
+
+	public String getPalo() {
+		return palo;
+	}
+
+	public void setPalo(String palo) {
+		this.palo = palo;
+	}
+
+	public int getIdOrdenacion() {
+		return idOrdenacion;
+	}
+
+	public void setIdOrdenacion(int idOrdenacion) {
+		this.idOrdenacion = idOrdenacion;
+	}
+	
+	
+}

src/tutorialJava/capitulo5/simulacroExamen01_poker/Jugador.java

@@ -0,0 +1,38 @@
+package tutorialJava.capitulo5.simulacroExamen01_poker;
+
+import java.util.Arrays;
+
+public class Jugador {
+	private String nombre;
+	private Carta mano[];
+	
+	public Jugador () {
+		mano = new Carta[5];
+	}
+
+	public void obtenManoDeCartas(Baraja baraja) {
+		
+	}
+	
+	public String toString() {
+		return "Jugador [nombre=" + nombre + ", mano=" + Arrays.toString(mano) + "]";
+	}
+
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	public Carta[] getMano() {
+		return mano;
+	}
+
+	public void setMano(Carta[] mano) {
+		this.mano = mano;
+	}
+	
+	
+}

src/tutorialJava/capitulo5/simulacroExamen01_poker/Poker.java

@@ -0,0 +1,22 @@
+package tutorialJava.capitulo5.simulacroExamen01_poker;
+
+public class Poker {
+	// Creo los jugadores y asigno manos a los mismos
+	private Jugador jugadores[] = new Jugador[5];
+	private String nombres[] = new String[] {"Dario", "José Luis", "Carmen", "José", "Alba"};
+	private Baraja baraja = new Baraja();
+	
+	/**
+	 * 
+	 */
+	public Poker () {
+		baraja.mezclar();
+		for (int i = 0; i < jugadores.length; i++) {
+			jugadores[i] = new Jugador();
+			jugadores[i].setNombre(nombres[i]);
+			baraja.reparteManoAJugador(jugadores[i]);
+			jugadores[i].obtenManoDeCartas(baraja);
+		}
+		System.out.println();
+	}
+}

src/tutorialJava/capitulo5/simulacroExamen01_poker/Principal.java

@@ -0,0 +1,21 @@
+package tutorialJava.capitulo5.simulacroExamen01_poker;
+
+public class Principal {
+
+	public static void main (String args[]) {
+		Poker poker = new Poker();		
+		
+		System.out.println();
+	}
+}
+
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Juego.java

@@ -0,0 +1,99 @@
+package tutorialJava.capitulo5.simulacroExamen02_arkanoid;
+
+import java.util.Iterator;
+
+import tutorialJava.Utils;
+
+public class Juego {
+	private Ladrillo ladrillos[] = new Ladrillo[20];
+	private Pelota pelota = new Pelota();
+	private Ladrillo ladrillosDestruidos[] = new Ladrillo[20];
+	private int contadorLadrillosDestruidos = 0;
+	
+	public Juego() {
+		for (int i = 0; i < ladrillos.length; i++) {
+			ladrillos[i] = new Ladrillo();
+			ladrillos[i].setNombre("L" + i);
+		}
+	}
+
+	/**
+	 * 
+	 */
+	public void jugar() {
+		
+		do {
+			pelota.mueveAlAzar();
+			boolean colisionConLadrillos = false;
+			for (Ladrillo l : ladrillos) {
+				if (l.getPuntosVida() > 0) {
+					if (pelota.chocaConLadrillo(l)) {
+						l.quitoPuntoDeVida();
+						colisionConLadrillos = true;
+						agregaLadrilloADestruidosSiCorresponde(l);
+					}
+				}	
+			}	
+			if (colisionConLadrillos == true) {
+				muestraArrayLadrillos();
+			}
+		} while (quedanLadrillos());
+		// Estadísticas
+		System.out.println("Primero en ser destruido: " + ladrillosDestruidos[0].toString());
+		System.out.println("Último en ser destruido: " + 
+				ladrillosDestruidos[ladrillosDestruidos.length - 1].toString());		
+		
+		System.out.println("Orden de destrucción de los ladrillos");
+		muestraArrayLadrillosDestruidos();
+	}
+	
+	
+	private void agregaLadrilloADestruidosSiCorresponde(Ladrillo l) {
+		if (l.getPuntosVida() <= 0) {
+			ladrillosDestruidos[contadorLadrillosDestruidos] = l;
+			contadorLadrillosDestruidos++;
+		}
+	}
+	
+	
+	private void muestraArrayLadrillosDestruidos() {
+		for (Ladrillo l : ladrillosDestruidos) {
+			System.out.print(l.toString() + "-");
+		}
+		System.out.println();
+	}
+	
+	
+	private void muestraArrayLadrillos() {
+		for (Ladrillo l : ladrillos) {
+			if (l.getPuntosVida() > 0) {
+				System.out.print(l.toString() + "-");
+			}
+		}
+		System.out.println();
+	}
+	
+	
+	private boolean quedanLadrillos() {
+		for (Ladrillo l : ladrillos) {
+			if (l.getPuntosVida() > 0) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	
+	public Ladrillo[] getLadrillos() {
+		return ladrillos;
+	}
+	public void setLadrillos(Ladrillo[] ladrillos) {
+		this.ladrillos = ladrillos;
+	}
+	public Pelota getPelota() {
+		return pelota;
+	}
+	public void setPelota(Pelota pelota) {
+		this.pelota = pelota;
+	}
+}

src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Ladrillo.java

@@ -0,0 +1,114 @@
+package tutorialJava.capitulo5.simulacroExamen02_arkanoid;
+
+import tutorialJava.Utils;
+
+public class Ladrillo {
+
+	public static String COLORES[] = new String[] {"rojo", "verde", "azul"}; 
+	
+	private String nombre;
+	private String color;
+	private int x;
+	private int y, ancho, alto, puntosVida;
+	
+	public Ladrillo() {
+		super();
+		x = Utils.obtenerNumeroAzar(0, 800);
+		y = Utils.obtenerNumeroAzar(0, 500);
+		ancho = 100;
+		alto = 50;
+		puntosVida = Utils.obtenerNumeroAzar(1, 3);
+		asignaColor();
+	}
+
+	private void asignaColor() {
+		switch(puntosVida) {
+		case 1:
+			color = COLORES[Utils.obtenerNumeroAzar(0, COLORES.length - 1)];
+			break;
+		case 2: 
+			color = "Plateado";
+			break;
+		default:
+			color = "Dorado";
+		}
+	}
+	
+	public void quitoPuntoDeVida() {
+		puntosVida -= 1;
+	}
+	
+	public String getColor() {
+		return color;
+	}
+
+	public void setColor(String newColor) {
+		color = newColor;
+	}
+
+	public int getX() {
+		return x;
+	}
+
+	public void setX(int x) {
+		this.x = x;
+	}
+
+	public int getY() {
+		return y;
+	}
+
+	public void setY(int y) {
+		this.y = y;
+	}
+
+	public int getAncho() {
+		return ancho;
+	}
+
+	public void setAncho(int ancho) {
+		this.ancho = ancho;
+	}
+
+	public int getAlto() {
+		return alto;
+	}
+
+	public void setAlto(int alto) {
+		this.alto = alto;
+	}
+
+	public int getPuntosVida() {
+		return puntosVida;
+	}
+
+	public void setPuntosVida(int puntosVida) {
+		this.puntosVida = puntosVida;
+	}
+
+	
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	public String toString() {
+		return nombre + ":" + puntosVida;
+	}
+	
+	
+}
+
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Pelota.java

@@ -0,0 +1,55 @@
+package tutorialJava.capitulo5.simulacroExamen02_arkanoid;
+
+import tutorialJava.Utils;
+
+public class Pelota {
+	private int x;
+	private int y;
+	
+	public Pelota() {
+		super();
+	}
+	
+	/**
+	 * 
+	 * @param l
+	 * @return
+	 */
+	public boolean chocaConLadrillo(Ladrillo l) {
+		if (x >= l.getX() && x <= (l.getX() + l.getAncho()) &&
+				y >= l.getY() && y <= (l.getY() + l.getAlto())) {			
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * 
+	 */
+	public void mueveAlAzar() {
+		x= Utils.obtenerNumeroAzar(0, 800);
+		y = Utils.obtenerNumeroAzar(0, 500);
+	}
+	
+	/////// GETTERS Y SETTER
+	
+	public String toString() {
+		return "Pelota [x=" + x + ", y=" + y + "]";
+	}
+
+	public int getX() {
+		return x;
+	}
+	public void setX(int x) {
+		this.x = x;
+	}
+	public int getY() {
+		return y;
+	}
+	public void setY(int y) {
+		this.y = y;
+	}
+	
+	
+	
+}

src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Principal.java

@@ -0,0 +1,21 @@
+package tutorialJava.capitulo5.simulacroExamen02_arkanoid;
+
+import java.util.Scanner;
+
+public class Principal {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		String respuestaUsuario;
+		
+		do {
+			System.out.println("\n\n Juego del ARKANOID\n");
+			Juego juego = new Juego();
+			juego.jugar();
+
+			System.out.println("¿Quieres volver a jugar? (S -> Sí  N -> No): ");
+			respuestaUsuario = sc.nextLine();
+		} while (respuestaUsuario.equalsIgnoreCase("s"));
+	}
+
+}

src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/Ejemplo01_ListasConInteger.java

@@ -0,0 +1,51 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo01_ListYArrayList;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class Ejemplo01_ListasConInteger {
+
+	public static void main(String[] args) {
+		// Declarado la lista de Integers
+		List<Integer> numeros = new ArrayList<Integer>();
+
+		// Inicializar con 10 elementos de tipo Integer
+		for (int i = 0; i < 10; i++) {
+			numeros.add(new Integer(100 + i));
+			numeros.add(Integer.valueOf(100 + i));
+			numeros.add(100 + i);
+		}
+		
+		// Agrego un elemento
+		numeros.add(1000);
+		
+		// Elimino un elemento
+		numeros.remove(2);
+
+		// Inserto un elemento en una posición concreta
+		numeros.add(1, 5000);
+		
+		// Crear una nueva lista
+		List<Integer> numerosNegativos = new ArrayList<Integer>();
+		
+		// Inicializo la nueva lista
+		for (int i = 0; i < 3; i++) {
+			numerosNegativos.add(-1000 + i);
+		}
+		
+		// Agrego la nueva lista en cualquier posición de la antigua lista
+		numeros.addAll(4, numerosNegativos);
+		
+		// Primera forma de eliminar un elemento concreto sin conocer su posición
+		// Tengo que recorrer todos los elementos de la lista
+		for (int i = 0; i < numeros.size(); i++) {
+			if (numeros.get(i).intValue() == 5000) {
+				numeros.remove(i);
+			}
+		}
+		
+		System.out.println("");
+	}
+
+}

src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/cromosBaloncesto/CromoBaloncesto.java

@@ -0,0 +1,33 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo01_ListYArrayList.cromosBaloncesto;
+
+public class CromoBaloncesto {
+	private int id;
+	private String nombre;
+	/**
+	 * @param id
+	 * @param nombre
+	 */
+	public CromoBaloncesto(int id, String nombre) {
+		this.id = id;
+		this.nombre = nombre;
+	}
+	@Override
+	public String toString() {
+		return "CromoBaloncesto [id=" + id + ", nombre=" + nombre + "]";
+	}
+	public int getId() {
+		return id;
+	}
+	public void setId(int id) {
+		this.id = id;
+	}
+	public String getNombre() {
+		return nombre;
+	}
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+	
+	
+	
+}

src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/cromosBaloncesto/EjemploListasCromos.java

@@ -0,0 +1,44 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo01_ListYArrayList.cromosBaloncesto;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class EjemploListasCromos {
+
+	public static void main (String args[]) {
+		CromoBaloncesto c1 = new CromoBaloncesto(100, "Felipe Reyes");
+		CromoBaloncesto c2 = new CromoBaloncesto(200, "Lebron");
+		CromoBaloncesto c3 = new CromoBaloncesto(300, "Pau Gasol");
+
+		List<CromoBaloncesto> lista = new ArrayList<CromoBaloncesto>();
+		lista.add(c1);
+		lista.add(c2);
+		lista.add(10, c3);
+		
+		for (CromoBaloncesto c : lista) {
+			System.out.println(c.getNombre());
+		}
+		
+
+		
+//		CromoBaloncesto c4 = new CromoBaloncesto(4, "Cristina Castro");
+//		CromoBaloncesto c5 = new CromoBaloncesto(5, "María Jesús Joyanes");
+//		CromoBaloncesto c6 = new CromoBaloncesto(6, "Alazne Ruiz");
+//
+//		List<CromoBaloncesto> lista2 = new ArrayList<CromoBaloncesto>();
+//		lista2.add(c4);
+//		lista2.add(c5);
+//		lista2.add(c6);
+//		
+//		lista.addAll(1, lista2);
+//		
+//		lista.removeAll(lista);
+//		
+//		System.out.println("VAcía: " + lista.isEmpty());
+//		
+//		for (CromoBaloncesto c : lista) {
+//			System.out.println(c.toString());
+//		}		
+		
+	}
+}

src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashMap/EjemploHashMap.java

@@ -0,0 +1,75 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo02_HashMap;
+
+import java.util.HashMap;
+import java.util.Iterator;
+
+public class EjemploHashMap {
+
+	/**
+	 * 
+	 */
+	private static void ejemploHashMapGeneral () {
+		// Creaci<63>n de un HashMap general
+		HashMap hm = new HashMap();
+		
+		// Inserci<63>n de datos en un HashMap general
+		hm.put("1", new Persona ("11111111A", "P<EFBFBD>rez P<>rez", "Jos<EFBFBD>"));
+		hm.put("2", new Persona ("22222222A", "Mu<EFBFBD>oz Mu<4D>oz", "Rafael"));
+		hm.put("3", new Persona ("33333333A", "Cuenca Cuenca", "Juan"));
+		hm.put("4", new Persona ("44444444A", "Torralbo Torralbo", "Patricia"));
+		hm.put("5", new Persona ("55555555A", "L<EFBFBD>rida L<>rida", "Luc<EFBFBD>a"));
+		
+		
+		// Recuperaci<63>n de datos en un HashMap general
+		System.out.println("Objeto con id 1: " + hm.get("1"));  // Recuperaci<63>n de un solo objeto
+		
+		// Inserci<63>n de un objeto con un tipo de identificador diferente
+		hm.put(Integer.valueOf(6), new Persona ("66666666A", "Ram<EFBFBD>rez Ram<61>rez", "Ramiro"));
+		
+		
+		// Recuperaci<63>n de todas las claves de objetos en el HM
+		System.out.println("\nRecorrido del HashMap:");
+		Object claves[] = hm.keySet().toArray();
+		for (int i = 0; i < claves.length; i++) {
+			System.out.println("Identificador: " + claves[i] + 
+					" - Objeto obtenido: "  + hm.get(claves[i]));
+		}
+	}
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploHashMapEspecifico () {
+		// Creaci<63>n de un HashMap general
+		HashMap<String, Persona> hm = new HashMap<String, Persona>();
+		
+		// Inserci<63>n de datos en un HashMap general
+		hm.put("1", new Persona ("11111111A", "P<EFBFBD>rez P<>rez", "Jos<EFBFBD>"));
+		hm.put("2", new Persona ("22222222A", "Mu<EFBFBD>oz Mu<4D>oz", "Rafael"));
+		hm.put("3", new Persona ("33333333A", "Cuenca Cuenca", "Juan"));
+		hm.put("4", new Persona ("44444444A", "Torralbo Torralbo", "Patricia"));
+		hm.put("5", new Persona ("55555555A", "L<EFBFBD>rida L<>rida", "Luc<EFBFBD>a"));
+		
+		// Eliminaci<63>n de alg<6C>n elemento en el HM
+		hm.remove("5");
+		
+		// Recuperaci<63>n de todos los objetos en el HM
+		System.out.println("\nRecorrido de los objetos del HashMap:");
+		Iterator<Persona> personas = hm.values().iterator();
+		while (personas.hasNext()) {
+			System.out.println("Objeto obtenido: "  + personas.next());
+		}
+	}
+	
+	
+	
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main (String args[]) {
+		ejemploHashMapGeneral();
+		//ejemploHashMapEspecifico();
+	}
+}

src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashMap/Persona.java

@@ -0,0 +1,55 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo02_HashMap;
+
+public class Persona {
+
+	private String Dni;
+	private String Apellidos;
+	private String Nombre;
+	
+	
+	public Persona(String dni, String apellidos, String nombre) {
+		super();
+		Dni = dni;
+		Apellidos = apellidos;
+		Nombre = nombre;
+	}
+
+
+	public String getDni() {
+		return Dni;
+	}
+
+
+	public void setDni(String dni) {
+		Dni = dni;
+	}
+
+
+	public String getApellidos() {
+		return Apellidos;
+	}
+
+
+	public void setApellidos(String apellidos) {
+		Apellidos = apellidos;
+	}
+
+
+	public String getNombre() {
+		return Nombre;
+	}
+
+
+	public void setNombre(String nombre) {
+		Nombre = nombre;
+	}
+
+
+	@Override
+	public String toString() {
+		return "Persona [Dni=" + Dni + ", Apellidos=" + Apellidos + ", Nombre=" + Nombre + "]";
+	}
+	
+	
+	
+}

src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashTable/EjemploHashTable.java

@@ -0,0 +1,36 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo02_HashTable;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+public class EjemploHashTable {
+
+	public static void main(String[] args) {
+		
+		Hashtable ht = new Hashtable();
+		ht.put("st01", "String 01");
+		ht.put("st02", "String 02");
+		ht.put("st03", "String 03");
+		ht.put("st04", "String 04");
+		
+		ht.remove("st04");
+		
+		ht.size();
+		
+		Enumeration en = ht.elements();
+		while (en.hasMoreElements()) {
+			Object obj = en.nextElement();
+			System.out.println("Elemento: " + obj.toString());
+		}
+		
+
+		en = ht.keys();
+		while (en.hasMoreElements()) {
+			System.out.println("Elemento id: " + en.nextElement() + 
+					" - Obj: " + ht.get(en.nextElement()));
+		}
+		
+
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/EjemploDateCalendar.java

@@ -0,0 +1,213 @@
+package tutorialJava.capitulo7_Recursos;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.TimeZone;
+
+public class EjemploDateCalendar {
+
+	/**
+	 * 
+	 */
+	private static void ejemploCreacionNormalDate () {
+		// El constructor por defecto de java.util.Date nos permite crear un objeto con la fecha actual
+		Date fechaActual = new Date();
+		System.out.println("Fecha actual: " + fechaActual.toString());
+		// getTime() nos permite acceder a los millis que representan al objeto Date, muy importante conocer esto
+		System.out.println("Milisegundos actuales: " + fechaActual.getTime());
+	}
+	
+	/**
+	 * 
+	 */
+	private static void ejemploFormateoFecha () {
+		Date ahora = new Date();
+		
+		// El formateo de fechas se puede realizar a trav<61>s de SimpleDateFormat, de una forma sencilla.
+		// Consulta Javadoc SimpleDateFormat para más detalles
+		SimpleDateFormat sdf = new SimpleDateFormat ("EEE, MMM d, ''yy 'at' hh:mm:ss a z");
+		System.out.println("Fecha actual: " + sdf.format(ahora));
+		
+		SimpleDateFormat sdf2 = new SimpleDateFormat ("dd/MM/yyyy HH:mm:ss");
+		System.out.println("Fecha actual: " + sdf2.format(ahora));
+			
+		Date fechaParseada = null;
+		// El parseo de fechas debe obligatoriamente ser inspeccionado con un bloque de manejo de excepciones
+		try {
+			fechaParseada = sdf2.parse("19/03/1977 15:33:00");
+		} catch (ParseException e) {
+			System.out.println ("Error en el parseo de la fecha");
+			e.printStackTrace();
+		}
+		System.out.println("Fecha parseada: " + sdf.format(fechaParseada));
+	}
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploCalendarBasico () {
+		// Otra forma muy habitual de manejar fechas es a través de los objetos de tipo Calendar
+		Calendar fechaCalendar = new GregorianCalendar(1918, Calendar.APRIL, 01, 22, 05, 23);
+		System.out.println("Millis: " + fechaCalendar.getTimeInMillis());
+		// Es f<>cil y muy habitual convertir un Calendar en Date
+		Date fechaAPartirDeCalendar = new Date(fechaCalendar.getTimeInMillis());
+		System.out.println("Fecha a partir de Calendar : " + fechaAPartirDeCalendar);
+	}
+	
+	
+	
+	private static void ejemploCalendarConCamposIndividualizados () {
+		Calendar fechaCalendar = Calendar.getInstance(); // Instanciación por patrón Factory (Recuerda como funciona)
+
+		fechaCalendar.set(Calendar.YEAR, 2018);
+		// Sobre el mes, recuerda que Enero corresponde al valor int 0 y Diciembre al int 11. Mejor usa las variables estáticas
+		fechaCalendar.set(Calendar.MONTH, Calendar.APRIL);
+		fechaCalendar.set(Calendar.DAY_OF_MONTH, 01);
+
+		// Ejemplo de manejo de horas en formato AM/PM
+		fechaCalendar.set(Calendar.HOUR, 10);
+		fechaCalendar.set(Calendar.AM_PM, Calendar.PM);
+		// Puedes preferir el formato 24 horas
+		fechaCalendar.set(Calendar.HOUR_OF_DAY, 22);
+
+		fechaCalendar.set(Calendar.MINUTE, 05);
+		fechaCalendar.set(Calendar.SECOND, 23);
+		fechaCalendar.set(Calendar.MILLISECOND, 123);
+
+		// Conversión a date y formateo
+		Date fechaAPartirDeCalendar = new Date(fechaCalendar.getTimeInMillis());
+		System.out.println("Fecha a partir de Calendar con campos individualizados: " + 
+				new SimpleDateFormat ("dd/MM/yyyy HH:mm:ss").format(fechaAPartirDeCalendar));
+		
+	}
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploLecturaCamposIndividualizadosYLocaleEnImpresion () {
+//		Locale locale = Locale.getDefault();
+		Locale locale = Locale.ITALIAN;
+		Calendar ahora = Calendar.getInstance(locale);
+
+		System.out.println("Año: " + ahora.get(Calendar.YEAR));
+		System.out.println("Mes (0 es Enero): " + ahora.get(Calendar.MONTH));
+		ahora.set(Calendar.MONTH, Calendar.JANUARY);
+		System.out.println("Month (String): " + ahora.getDisplayName(Calendar.MONTH, Calendar.SHORT, locale));
+		System.out.println("D<EFBFBD>a del mes: " + ahora.get(Calendar.DAY_OF_MONTH));
+		System.out.println("D<EFBFBD>a de la semana (0 es Domingo): " + ahora.get(Calendar.DAY_OF_WEEK));
+		System.out.println("D<EFBFBD>a de la semana (String): "
+		            + ahora.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, locale));
+		System.out.println("Semana del año: " + ahora.get(Calendar.WEEK_OF_YEAR));
+		System.out.println("Semana del mes: " + ahora.get(Calendar.WEEK_OF_MONTH));
+		System.out.println("Día del año: " + ahora.get(Calendar.DAY_OF_YEAR));
+		System.out.println("Hora en formato 24H: " + ahora.get(Calendar.HOUR_OF_DAY));
+		System.out.println("Hora en formato 12H: " + ahora.get(Calendar.HOUR));
+		System.out.println("AM/PM: " + ahora.get(Calendar.AM_PM));
+		System.out.println("AM/PM: " + ahora.getDisplayName(Calendar.AM_PM, Calendar.LONG, locale));
+		System.out.println("Minutos: " + ahora.get(Calendar.MINUTE));
+		System.out.println("Segundos: " + ahora.get(Calendar.SECOND));
+		System.out.println("MiliSegundos: " + ahora.get(Calendar.MILLISECOND));
+		
+		// DST_Offset 
+		System.out.println("DST_OFFSET: " + ahora.get(Calendar.DST_OFFSET));
+	}
+	
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploSumaRestaFechas () {
+		Calendar ahora = Calendar.getInstance();
+		ahora.add(Calendar.DAY_OF_MONTH, 20);
+		System.out.println("Ahora más 20 días : " + ahora.getTime());
+
+		ahora = Calendar.getInstance();
+		ahora.add(Calendar.DAY_OF_MONTH, -20);
+		System.out.println("Ahora menos 20 días : " + ahora.getTime());
+	}
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploComparacionFechas () {
+		Calendar ahora = Calendar.getInstance();
+		Calendar despues = Calendar.getInstance();
+		despues.add(Calendar.HOUR_OF_DAY, 2);
+
+		Calendar antes = Calendar.getInstance();
+		antes.add(Calendar.HOUR_OF_DAY, -5);
+
+		System.out.println("Ahora es después que después: " + ahora.after(despues));
+		System.out.println("Ahora es antes que después: " + ahora.before(despues));
+		System.out.println("Ahora es después que antes: " + ahora.after(antes));
+		System.out.println("Ahora es antes que antes: " + ahora.before(antes));
+	}
+	
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploDiasEntreDosFechas () {
+		Calendar unDiaDeMarzo = Calendar.getInstance();
+		unDiaDeMarzo.set(Calendar.MONTH, Calendar.MARCH);
+
+		Calendar unDiaDeFebrero = Calendar.getInstance();
+		unDiaDeFebrero.set(Calendar.MONTH, Calendar.FEBRUARY);
+		      
+		long milis = unDiaDeMarzo.getTimeInMillis()-unDiaDeFebrero.getTimeInMillis();
+		long diasEntreFechas = milis/1000/60/60/24;
+		System.out.println("Days : " + diasEntreFechas);
+	}
+	
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploZonasHorarias () {
+		Calendar ahoraEnEspania = Calendar.getInstance(TimeZone.getDefault());
+		Calendar ahoraEnCanada = Calendar.getInstance(TimeZone.getTimeZone("Canada/Central"));
+		Calendar ahoraEnNewYork = Calendar.getInstance(TimeZone.getTimeZone("America/New_York"));
+		
+		System.out.println("Hora espa<70>ola: " + ahoraEnEspania.get(Calendar.HOUR_OF_DAY));
+		System.out.println("Hora canadiense: " + ahoraEnCanada.get(Calendar.HOUR_OF_DAY));
+		System.out.println("Hora en New York: " + ahoraEnNewYork.get(Calendar.HOUR_OF_DAY));
+		
+		// Podemos obtener todos las zonas horarias disponibles
+		String zonasHorarias[] = TimeZone.getAvailableIDs();
+		for (String str : zonasHorarias)
+			System.out.println("Zona horaria: " + str);
+//		System.out.println("Zona horaria disponible: " + Arrays.toString(zonasHorarias));
+		
+		// También podemos fabricarnos una zona horaria determinada, si no hallamos la que buscamos
+		// Cuidado con los horarios de verano!!!
+		Calendar unaZona= Calendar.getInstance(TimeZone.getTimeZone("GMT+8:00"));
+		Calendar otraZona= Calendar.getInstance(TimeZone.getTimeZone("GMT-4:00"));
+		System.out.println("GMT+8:00: " + unaZona.get(Calendar.HOUR_OF_DAY));
+		System.out.println("GMT-4:00: " + otraZona.get(Calendar.HOUR_OF_DAY));
+	}
+	
+	
+	public static void main(String[] args) {
+//		ejemploCreacionNormalDate();
+//		ejemploFormateoFecha();
+//		ejemploCalendarBasico();
+//		ejemploCalendarConCamposIndividualizados();
+//		ejemploLecturaCamposIndividualizadosYLocaleEnImpresion();
+//		ejemploSumaRestaFechas();
+//		ejemploComparacionFechas();
+		//ejemploDiasEntreDosFechas();
+		ejemploZonasHorarias();
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/EjemploFicheroPropiedades.java

@@ -0,0 +1,89 @@
+package tutorialJava.capitulo7_Recursos;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Properties;
+
+public class EjemploFicheroPropiedades {
+
+	private static Properties propiedades = null;
+
+	public EjemploFicheroPropiedades () {
+		super();
+	}
+	
+	/**
+	 * 
+	 * @return
+	 */
+	private static Properties getPropiedades() {
+		if (propiedades == null) {
+			propiedades = new Properties();
+		    
+			try {
+				// Una forma de leer el fichero de propiedades
+//				propiedades.load(propiedades.getClass().getResourceAsStream("/tutorialJava/capitulo6_Recursos/ejemplo.properties"));
+
+				// Otra forma de leer el fichero de propiedades
+				File file = new File("./src/tutorialJava/capitulo7_Recursos/ejemplo.properties");
+				System.out.println("Fichero encontrado: " + file.exists());
+				propiedades.load(new FileReader(file));
+			
+			} catch (FileNotFoundException e) {
+				e.printStackTrace();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+			 
+		}
+		return propiedades;
+	}
+
+	/**
+	 * 
+	 * @param nombrePropiedad
+	 * @return
+	 */
+	public static String getProperty(String nombrePropiedad) {
+		return getPropiedades().getProperty(nombrePropiedad);
+	}
+
+	
+	/**
+	 * 
+	 * @param nombrePropiedad
+	 * @return
+	 */
+	public static int getIntProperty (String nombrePropiedad) {
+		return Integer.parseInt(getPropiedades().getProperty(nombrePropiedad));
+	}
+	
+	
+	/**
+	 * 
+	 * @param nombrePropiedad
+	 * @return
+	 */
+	public static Float getFloatProperty (String nombrePropiedad) {
+		return Float.parseFloat(getPropiedades().getProperty(nombrePropiedad));
+	}
+	
+	
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main (String args[]) {
+		String usuario = EjemploFicheroPropiedades.getProperty("USUARIO");
+		String password = EjemploFicheroPropiedades.getProperty("PASSWORD");
+		int id = EjemploFicheroPropiedades.getIntProperty("ID_USUARIO");
+		
+		System.out.println("Usuario leído del fichero de propiedades: " + usuario);
+		System.out.println("Password leído del fichero de propiedades: " + password);
+		System.out.println("Id de usuario leído del fichero de propiedades: " + id);
+	}
+}

src/tutorialJava/capitulo7_Recursos/EjemploMath.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo7_Recursos;
+
+public class EjemploMath {
+
+	public static void main(String[] args) {
+		// La clase Math tiene una cantidad importante de métodos que podemos utilizar en cálculos muy diversos
+		
+		// Respecto a las propiedades encontramos dos propiedades estáticas
+		System.out.println("Valor de PI: " + Math.PI);
+		System.out.println("Valor de E: " + Math.E);
+		
+		// Métodos de interés
+		System.out.println("\nMétodos básicos:\nMáximo de dos números: " + Math.max(3, 4.5));
+		System.out.println("Mínimo de dos números: " + Math.min(3.5, 4));
+		System.out.println("Valor absoluto de -3: " + Math.abs(-3)); 
+		System.out.println("Redondeo del número 3.5: " + Math.round(3.5));
+		System.out.println("Número al azar entre 0 y 1: " + Math.random());
+		
+		System.out.println("\nPotenciación:\nPotencia de base 25 y exponente 0.5 (raiz cuadrada de 25): " + Math.pow(25, 0.5f));
+		System.out.println("Raiz cuadrada de 9: " + Math.sqrt(9));
+		System.out.println("Raiz cúbica de 27: " + Math.cbrt(27));
+		System.out.println("Potencia del número E con exponente 10: " + Math.exp(10));
+		System.out.println("Hipotenusa de un triángulo rectángulo, dados dos de los catetos del mismo: " + Math.hypot(3, 4));
+		System.out.println("Logaritmos:\nLogaritmo en base 10 del número 100: " + Math.log10(100));
+		System.out.println("Logaritmo en base E de la potencia de base E y exponente 2: " + Math.log(Math.pow(Math.E, 2)));
+
+		System.out.println("\nTrigonometría:\nPaso de 90 grados a radianes: " + Math.toRadians(90));
+		System.out.println("Paso de 1 radián a grados: " + Math.toDegrees(1));
+		System.out.println("Seno del ángulo de 1 radián: " + Math.sin(1));
+		System.out.println("Coseno del ángulo de 2 radianes: " + Math.cos(2));
+		System.out.println("Tangente del ángulo de 45 grados: " + Math.tan(Math.toRadians(45)));
+		System.out.println("Arcoseno del ángulo de 0.85 radianes: " + Math.asin(0.85)); 
+		System.out.println("Arcocoseno del ángulo de 0.15 radianes: " + Math.acos(0.15)); 
+		System.out.println("Arcotangente del ángulo de 45 grados: " + Math.atan(Math.toRadians(45))); 
+
+		// Existen otros pocos métodos más en la clase Math, si quieres puedes descubrirlos a través de Javadoc Math.
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/EjemploRecursividad_Factorial.java

@@ -0,0 +1,26 @@
+package tutorialJava.capitulo7_Recursos;
+
+public class EjemploRecursividad_Factorial {
+
+	public static void main(String[] args) {
+		System.out.println("Mediante no recursividad: " + factorialNoRecursivo(6));
+		System.out.println("Mediante recursividad: " + factorialRecursivo(6));
+	}
+	
+	
+	public static int factorialRecursivo(int n) {
+		if (n == 1) {
+			return 1;
+		}
+		return n * factorialRecursivo(n - 1);
+	}
+	
+	
+	public static int factorialNoRecursivo(int n) {
+		for (int i = n-1; i > 1; i--) {
+			n *= i;
+		}
+		return n;
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/EjemploString.java

@@ -0,0 +1,51 @@
+package tutorialJava.capitulo7_Recursos;
+
+public class EjemploString {
+
+	public static void main(String[] args) {
+		String str = "Cadena de texto de tamaño mediano";  
+		str = new String("Cadena de texto de tamaño mediano");
+		str = new String(new char[] {'C', 'a', 'd', 'e', 'n', 'a', ' ', 'd', 'e', ' ', 't', 'e', 'x', 't', 'o'});
+		str = new String(new StringBuffer("Cadena de texto de tamaño mediano"));
+		
+		System.out.println("Carácter en la posición 4: " + str.charAt(4));
+		System.out.println("Comparación con la cadena \"Hola\": " + str.compareTo("Hola"));
+		System.out.println("Concatenación con la cadena \" para practicar\": " + str.concat(" para practicar"));
+		System.out.println("Búsqueda booleana de la cadena \"texto\": " + str.contains("texto"));
+		System.out.println("Respuesta booleana a la terminación de la cadena con respecto a la cadena \"mediano\": " + str.endsWith("mediano"));
+		System.out.println("Comparación de cadena ignorando mayúsculas: " + str.equalsIgnoreCase("CADENA DE TEXTO DE TAMAÑO MEDIANO"));
+		System.out.println("Índice en el que se encuentra la cadena \"texto\" (-1 si no se encuentra la cadena): " + str.indexOf("texto"));
+		System.out.println("Está la cadena vacía?: " + str.isEmpty());
+		System.out.println("Índice de la última aparición del carácter 'a': " + str.lastIndexOf("a"));
+		System.out.println("Longitud de una cadena de texto: " + str.length());
+		System.out.println("Reemplazar todas las apariciones de 'a' por el carácter 'o': " + str.replace('a', 'o'));
+		System.out.println("Remplazo de todas las vocales a través de expresión regular: " + str.replaceAll("[aeiou]", "í"));
+		
+		// Ejemplo de separación de cadena en cadenas a través de split()
+		System.out.println("Separación de una cadena en otras cadenas a través de un espacio en blanco");
+		String[] palabras = str.split("[ ]{1,}");
+		for (int i = 0; i < palabras.length; i++) {
+			System.out.println("Palabra " + (i + 1) + ": " + palabras[i]);
+		}
+		
+		// Uso de split() con una expresión regular
+		System.out.println("Separación de una cadena en otras cadenas a través de la expresión regular [adt]");
+		palabras = str.split("[adt]");
+		for (int i = 0; i < palabras.length; i++) {
+			System.out.println("Palabra " + (i + 1) + ": " + palabras[i]);
+		}
+		
+		// Uso de split() con una expresión regular
+		System.out.println("Separación de una cadena en otras cadenas a través de la expresión regular \" {2,}\", \" \"");
+		palabras = new String("Cadena con 2 espacios  en medio").split(" {2,}");
+		for (int i = 0; i < palabras.length; i++) {
+			System.out.println("Palabra " + (i + 1) + ": " + palabras[i]);
+		}
+		
+		System.out.println("Subcadena de texto a partir de los índices de inicio y fin: " + str.substring(4, 15));
+		System.out.println("Paso a minúsculas: " + str.toLowerCase());
+		System.out.println("Paso a mayúsculas: " + str.toUpperCase());
+		System.out.println("Eliminación de los espacios en blanco iniciales: " + new String("        Cadena de texto de tamaño mediano").trim());
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/EjemploWrappersTiposPrimitivos.java

@@ -0,0 +1,64 @@
+package tutorialJava.capitulo7_Recursos;
+
+public class EjemploWrappersTiposPrimitivos {
+
+	public static void main (String args[]) {
+	
+		// Wrapper para el tipo de datos "int"
+		Integer integer = new Integer(15);
+		System.out.println("\nForma rápida de creación de un Integer: " + Integer.valueOf(15));
+		System.out.println("Valor entero de 15: " + integer.intValue());
+		System.out.println("Valor long de 15: " + integer.longValue());
+		System.out.println("Valor short de 15: " + integer.shortValue());
+		System.out.println("Valor float de 15: " + integer.floatValue());
+		System.out.println("Valor double de 15: " + integer.doubleValue());
+		System.out.println("Valor máximo para un Integer: " + Integer.MAX_VALUE);
+		System.out.println("Valor mínimo para un Integer: " + Integer.MIN_VALUE);
+		System.out.println("Tamaño en bits complemento a 2 para Integer: " + Integer.SIZE);
+		System.out.println("Decodificicación base decimal 255: " + Integer.decode("255"));
+		System.out.println("Decodificicación base hexadecimal 0xFF: " + Integer.decode("0xFF"));
+		System.out.println("Decodificicación base hexadecimal 0XFF: " + Integer.decode("0XFF"));
+		System.out.println("Decodificicación base hexadecimal #FF: " + Integer.decode("#FF"));
+		System.out.println("Decodificicación base octal O377: " + Integer.decode("0377"));
+		System.out.println("Parseo de una cadena de caracteres \"123456789\": " + Integer.parseInt("123456789"));
+		System.out.println("Otra forma de parsear cadenas de caracteres a Integer: " + Integer.valueOf("12345678"));
+		
+
+		// Wrapper para el tipo de datos "long"
+		System.out.println("\nValor máximo para un Long: " + Long.MAX_VALUE);
+		System.out.println("Valor mínimo para un Long: " + Long.MIN_VALUE);
+		System.out.println("Tamaño en bits complemento a 2 para Long: " + Long.SIZE);
+
+		// Wrapper para el tipo de datos "short"
+		System.out.println("\nValor máximo para un Short: " + Short.MAX_VALUE);
+		System.out.println("Valor mínimo para un Short: " + Short.MIN_VALUE);
+		System.out.println("Tamaño en bits complemento a 2 para Short: " + Short.SIZE);
+		
+		// Wrapper para el tipo de datos "boolean"
+		System.out.println("\nForma rápida de creación de un Boolean: " + Boolean.valueOf(true));
+		System.out.println("Parseo de una cadena de caracteres \"true\" a Boolean: " + Boolean.parseBoolean("true"));
+		
+		// Wrapper para el tipo de datos "float"
+		System.out.println("\nValor máximo para un Float: " + Float.MAX_VALUE);
+		System.out.println("Valor mínimo para un Float: " + Float.MIN_VALUE);
+		System.out.println("Tamaño en bits complemento a 2 para Float: " + Float.SIZE);
+		
+		// Wrapper para el tipo de datos "double"
+		System.out.println("\nValor máximo para un Double: " + Double.MAX_VALUE);
+		System.out.println("Valor mínimo para un Double: " + Double.MIN_VALUE);
+		System.out.println("Tamaño en bits complemento a 2 para Double: " + Double.SIZE);
+		
+		// Wrapper para el tipo de datos "Character"
+		char cadenaTexto[] = new char[] {'H', 'o', 'l', 'a', ' ', 'A', 'm', 'i', 'g', 'o', ' ', '2', '5', '5', '\n'};
+		System.out.println ("\nAnalizaré el array de caracteres: " + cadenaTexto.toString());
+		for (int i = 0; i < cadenaTexto.length; i++) {
+			System.out.println("'" + cadenaTexto[i] + "' es dígito: " + Character.isDigit(cadenaTexto[i]));
+			System.out.println("'" + cadenaTexto[i] + "' es letra: " + Character.isLetter(cadenaTexto[i]));
+			System.out.println("'" + cadenaTexto[i] + "' es letra o dígito: " + Character.isLetterOrDigit(cadenaTexto[i]));
+			System.out.println("'" + cadenaTexto[i] + "' es minúscula: " + Character.isLowerCase(cadenaTexto[i]));
+			System.out.println("'" + cadenaTexto[i] + "' es mayúscula: " + Character.isUpperCase(cadenaTexto[i]));
+			System.out.println("'" + cadenaTexto[i] + "' es un caracter similar a espacio en blanco: " + Character.isWhitespace(cadenaTexto[i]));
+		}
+		
+	}
+}

src/tutorialJava/capitulo7_Recursos/ejemplo.properties

@@ -0,0 +1,6 @@
+# Ejemplo de comentario en fichero de propiedades
+
+# Propiedades
+USUARIO=RafaelMunoz77
+PASSWORD=1<EFBFBD>DAWlosmejores
+ID_USUARIO=1523

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Madre.java

@@ -0,0 +1,14 @@
+package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener;
+
+public class Madre implements PersonaEntraListener {
+
+	public Madre() {
+		Principal.addPersonaEntraListener(this);
+	}
+	
+	@Override
+	public void entraPersona(PersonaEntraEvent e) {
+		System.out.println("Soy una madre y ha entrado " + e.getNombrePer());
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Padre.java

@@ -0,0 +1,14 @@
+package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener;
+
+public class Padre implements PersonaEntraListener {
+
+	public Padre() {
+		Principal.addPersonaEntraListener(this);
+	}
+	
+	@Override
+	public void entraPersona(PersonaEntraEvent e) {
+		System.out.println("Soy un padre y ha entrado " + e.getNombrePer());
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraEvent.java

@@ -0,0 +1,22 @@
+package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener;
+
+public class PersonaEntraEvent {
+	private String nombrePer;
+
+	
+	
+	public PersonaEntraEvent(String nombrePer) {
+		super();
+		this.nombrePer = nombrePer;
+	}
+
+	public String getNombrePer() {
+		return nombrePer;
+	}
+
+	public void setNombrePer(String nombrePer) {
+		this.nombrePer = nombrePer;
+	}
+	
+	
+}

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraListener.java

@@ -0,0 +1,6 @@
+package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener;
+
+public interface PersonaEntraListener {
+
+	public void entraPersona(PersonaEntraEvent e);
+}

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Principal.java

@@ -0,0 +1,42 @@
+package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import tutorialJava.Utils;
+
+public class Principal {
+
+	private static List<PersonaEntraListener> listeners = new ArrayList<PersonaEntraListener>();
+	
+	public static void addPersonaEntraListener (PersonaEntraListener p) {
+		listeners.add(p);
+	}
+	
+	public static void removePersonaEntraListener (PersonaEntraListener p) {
+		listeners.remove(p);
+	}
+	
+	private static void fireEntraPersona(String nombrePer) {
+		for (PersonaEntraListener l : listeners) {
+			l.entraPersona(new PersonaEntraEvent(nombrePer));
+		}
+	}
+	
+	public static void main(String[] args) {
+		
+		Padre p = new Padre();
+		Madre m = new Madre();
+		
+		do {
+			String nombrePer = Utils.obtenerCadenaConDescripcion("Quién ha entrado?: ");
+			
+			if (nombrePer.equalsIgnoreCase("maría") || nombrePer.equalsIgnoreCase("jesús")) {
+				// Lanzo notificació a la lista de listeners
+				fireEntraPersona(nombrePer);
+			}
+			
+		} while(true);
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/IntroduccionNumeros.java

@@ -0,0 +1,63 @@
+package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class IntroduccionNumeros {
+
+	private static List<NumeroImparListener> listNumeroImparListeners = 
+			new ArrayList<NumeroImparListener>();
+	
+	/**
+	 * 
+	 * @param l
+	 */
+	public static void addNumeroImparListener(NumeroImparListener l) {
+		listNumeroImparListeners.add(l);
+	}
+	
+	/**
+	 * 
+	 * @param l
+	 */
+	public static void removeNumeroImparListener(NumeroImparListener l) {
+		listNumeroImparListeners.remove(l);
+	}
+	
+	/**
+	 * 
+	 */
+	private static void fireNumeroImparListener(int numeroImparIntroducido) {
+		NumeroImparEvent event = new NumeroImparEvent(numeroImparIntroducido);
+		for (int i = listNumeroImparListeners.size() - 1; i >= 0; i--) {
+			listNumeroImparListeners.get(i).numeroImparIntroducido(event);
+		}
+	}
+	
+	
+	public static void main(String[] args) {
+		int num = 0;
+		Scanner sc = new Scanner(System.in);
+		
+		// doy de alta los listeners que quieren saber que se ha introducido un número impar
+		Mesa mesa1 = new Mesa();
+		addNumeroImparListener(mesa1);
+		Perro perro1 = new Perro();
+		addNumeroImparListener(perro1);
+		Mesa mesa2 = new Mesa();
+		addNumeroImparListener(mesa2);
+		
+		do {
+			System.out.println("Introduzca un número, por favor: ");
+			num = sc.nextInt();
+			System.out.println("\tEl número introducido es " + num); 
+			
+			if (num % 2 == 1) {
+				fireNumeroImparListener(num);
+			}
+			
+		} while (num != 0);
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Mesa.java

@@ -0,0 +1,13 @@
+package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener;
+
+public class Mesa implements NumeroImparListener {
+
+
+	
+	@Override
+	public void numeroImparIntroducido(NumeroImparEvent e) {
+		System.out.println("Soy una mesa y me han notificado que el usuario ha introducido "
+				+ "un número impar: " + e.getNumeroIntroducido());
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparEvent.java

@@ -0,0 +1,23 @@
+package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener;
+
+public class NumeroImparEvent {
+	private int numeroIntroducido;
+
+	/**
+	 * @param numeroIntroducido
+	 */
+	public NumeroImparEvent(int numeroIntroducido) {
+		super();
+		this.numeroIntroducido = numeroIntroducido;
+	}
+
+	public int getNumeroIntroducido() {
+		return numeroIntroducido;
+	}
+
+	public void setNumeroIntroducido(int numeroIntroducido) {
+		this.numeroIntroducido = numeroIntroducido;
+	}
+	
+	
+}

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparListener.java

@@ -0,0 +1,6 @@
+package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener;
+
+public interface NumeroImparListener {
+
+	public void numeroImparIntroducido(NumeroImparEvent e);
+}

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Perro.java

@@ -0,0 +1,14 @@
+package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener;
+
+public class Perro implements NumeroImparListener {
+
+	
+	
+	@Override
+	public void numeroImparIntroducido(NumeroImparEvent e) {
+		System.out.println("Soy un perro y me han notificado la introducción de un número "
+				+ "impar: " + e.getNumeroIntroducido());
+		IntroduccionNumeros.removeNumeroImparListener(this);
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/CorrectorOrtografico.java

@@ -0,0 +1,41 @@
+package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener;
+
+public class CorrectorOrtografico implements PalabraRepetidaListener {
+
+	String nombre;
+
+	public CorrectorOrtografico(String nombre) {
+		super();
+		this.nombre = nombre;
+		Principal.addPalabraRepetidaListener(this);
+	}
+
+	
+	
+	
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+
+
+
+	@Override
+	public void palabraRepetidaEncontrada(PalabraRepetidaEvent e) {
+		System.out.println("Soy " + this.nombre + " y hay una "
+				+ "palabra repetida: " + e.getPalabra());		
+	}
+	
+	
+}
+
+
+
+
+
+
+

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Informatica.java

@@ -0,0 +1,32 @@
+package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener;
+
+public class Informatica  implements PalabraRepetidaListener {
+
+	String nombre;
+
+	public Informatica(String nombre) {
+		super();
+		this.nombre = nombre;
+		Principal.addPalabraRepetidaListener(this);
+	}
+
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	@Override
+	public void palabraRepetidaEncontrada(PalabraRepetidaEvent e) {
+		System.out.println("Soy " + this.nombre + " y hay una palabra "
+				+ "repetida: " + e.getPalabra());		
+	}
+	
+	
+}
+
+
+
+

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaEvent.java

@@ -0,0 +1,19 @@
+package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener;
+
+public class PalabraRepetidaEvent {
+	String palabra;
+
+	public PalabraRepetidaEvent(String palabra) {
+		super();
+		this.palabra = palabra;
+	}
+
+	public String getPalabra() {
+		return palabra;
+	}
+
+	public void setPalabra(String palabra) {
+		this.palabra = palabra;
+	}
+	
+}

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaListener.java

@@ -0,0 +1,6 @@
+package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener;
+
+public interface PalabraRepetidaListener {
+	
+	public void palabraRepetidaEncontrada(PalabraRepetidaEvent e);
+}

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Principal.java

@@ -0,0 +1,68 @@
+package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class Principal {
+	
+	private static List<PalabraRepetidaListener> listeners = 
+			new ArrayList<PalabraRepetidaListener>();
+	
+	
+	private static void firePalabraRepetidaEncontrada(String palabra) {
+		PalabraRepetidaEvent event = new PalabraRepetidaEvent(palabra);
+		for (PalabraRepetidaListener listener : listeners) {
+			listener.palabraRepetidaEncontrada(event);
+		}
+	}
+	
+	
+	public static void addPalabraRepetidaListener(PalabraRepetidaListener l) {
+		listeners.add(l);
+	}
+	
+	public static void removePalabraRepetidaListener(PalabraRepetidaListener l) {
+		listeners.remove(l);
+	}
+	
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		String frase = "";
+		
+		CorrectorOrtografico alejandro = new CorrectorOrtografico("Alejandro");
+		CorrectorOrtografico sergio = new CorrectorOrtografico("Sergio");
+		Informatica carmen = new Informatica("Carmen");
+		
+		
+		do {
+			System.out.println("Dame una frase: ");
+			frase = sc.nextLine();
+			String palabras[] = frase.split("[ ]+");
+			List<String> listaPalabras = Arrays.asList(palabras);
+			
+			for (int i = 0; i < palabras.length; i++) {
+				String palabra = palabras[i];
+				if (listaPalabras.subList(0, i).contains(palabra)) {
+					System.out.println("La palabra " + palabra + " está "
+							+ "repetida");
+					firePalabraRepetidaEncontrada(palabra);
+				}
+			}
+			
+		} while (!frase.equals(""));
+
+	}
+
+}
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo7_Recursos/excepciones/EjemploExcepcionesBasico.java

@@ -0,0 +1,208 @@
+package tutorialJava.capitulo7_Recursos.excepciones;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+public class EjemploExcepcionesBasico {
+
+	/**
+	 * Ejemplo de Exception general
+	 */
+	private static void ejemploExceptionGeneral () {
+		String str = null;
+		
+		try {
+			System.out.println ("Contenido de str: " + str.toLowerCase());
+		}
+		catch(Exception e) {
+			System.out.println(e.getMessage());
+			e.printStackTrace();
+		}
+			
+		System.out.println("Terminando");
+	}
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploNullPointerException () {
+		Persona persona = new Persona (null, new Pierna(Pierna.IZQUIERDA));
+		
+		try {
+			System.out.println ("Pierna izquierda de la persona: " + persona.getPiernaIzquierda().toString());
+			System.out.println ("Pierna derecha de la persona: " + persona.getPiernaDerecha().toString());
+			String cadenas[] = new String[2];
+			System.out.println("cadena: " + cadenas[3]);
+		}
+		catch (NullPointerException ex) {
+			System.out.println("Exception NullPointer recogida");
+		}
+		catch (IndexOutOfBoundsException ex) {
+			System.out.println("Exception IndexOutOfBoundsException recogida");
+		}
+		catch (Exception ex) {
+			System.out.println("Exception general recogida");
+		}
+		
+		System.out.println("Fuera del catch");
+	}
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploArithmeticException () {
+		try {
+			int divisor = 0; 
+			System.out.println ("Divisi<EFBFBD>n: " + (50/divisor));
+		}
+		catch (ArithmeticException ex) {
+			System.out.println("Error aritmético");
+			System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n");
+			ex.printStackTrace();
+		}
+	}
+	
+
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploClassCastException () {
+		try {
+			Object persona = new Object(); 
+			Pierna pierna = (Pierna) persona;
+		}
+		catch (ClassCastException ex) {
+			System.out.println("Error de casting");
+			System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n");
+			ex.printStackTrace();
+		}
+	}
+	
+
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploIndexOutOfBoundsException () {
+		try {
+			List<Pierna> piernas = new ArrayList<Pierna>();
+			piernas.add(new Pierna(Pierna.DERECHA));
+			
+			System.out.println ("Pierna en array: " + piernas.get(1).toString());
+		}
+		catch (IndexOutOfBoundsException ex) {
+			System.out.println("Error de índice de acceso a un elemento en un array");
+			System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n");
+			ex.printStackTrace();
+		}
+	}
+	
+
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploNumberFormatException () {
+		try {
+			System.out.println("Parseo de n<>mero: " + Integer.parseInt("rafa"));
+		}
+		catch (NumberFormatException ex) {
+			System.out.println("Error de parseo a un número");
+			System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n");
+			ex.printStackTrace();
+		}
+	}
+	
+
+	
+	
+	/**
+	 * 
+	 */
+	private static void ejemploClassNotFoundException () {
+		try {
+			// Ejemplo de instanciaci<63>n de un objeto
+			Persona persona = (Persona) Class.forName("tutorialJava.capitulo7_Recursos.excepciones.Persona").newInstance();
+			System.out.println("Objeto instanciado: " + persona);
+			
+			// Ejemplo de obtenci<63>n de las propiedades de un objeto
+			Field propiedades[] = persona.getClass().getDeclaredFields();
+			System.out.println("\nListado de propiedades del objeto: ");
+			for (int i = 0; i < propiedades.length; i++) {
+				System.out.println("Campo: " +	propiedades[i].getName());
+			}
+			
+			// Ejemplo de obtenci<63>n de los m<>todos de un objeto
+			Method metodos[] = persona.getClass().getMethods();
+			System.out.println("\nListado de métodos del objeto: ");
+			for (int i = 0; i < metodos.length; i++) {
+				System.out.println("Método: " + metodos[i].getName() + "()");
+			}
+			
+			// Ejemplo de invocaci<63>n de un m<>todo de un objeto
+			System.out.println("\nInvocación pierna derecha: " + Persona.class.getMethod("getPiernaDerecha", null).invoke(persona, null));
+			
+		}
+		catch (ClassNotFoundException ex) {
+			System.out.println("Error por no encontrar una clase");
+			System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n");
+			ex.printStackTrace();
+		} catch (InstantiationException e) {
+			System.out.println("Error de instanciaci<63>n de una clase");
+			System.out.println("Mensaje de error: " + e.getMessage() + "\n\n");
+			e.printStackTrace();
+		} catch (IllegalAccessException e) {
+			System.out.println("Error de acceso ilegal a una clase");
+			System.out.println("Mensaje de error: " + e.getMessage() + "\n\n");
+			e.printStackTrace();
+		} catch (IllegalArgumentException e) {
+			System.out.println("IllegalArgumentException Error en la invocación de un método");
+			System.out.println("Mensaje de error: " + e.getMessage() + "\n\n");
+			e.printStackTrace();
+		} catch (InvocationTargetException e) {
+			System.out.println("InvocationTargetException Error en la invocación de un método");
+			System.out.println("Mensaje de error: " + e.getMessage() + "\n\n");
+			e.printStackTrace();
+		} catch (NoSuchMethodException e) {
+			System.out.println("NoSuchMethodException Error en la invocación de un método");
+			System.out.println("Mensaje de error: " + e.getMessage() + "\n\n");
+			e.printStackTrace();
+		} catch (SecurityException e) {
+			System.out.println("SecurityException Error en la invocación de un método");
+			System.out.println("Mensaje de error: " + e.getMessage() + "\n\n");
+			e.printStackTrace();
+		} catch(Exception ex) {
+			System.out.println("Exception no controlada");
+			System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n");
+			ex.printStackTrace();
+		}
+		
+	}
+	
+
+	
+	
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main (String args[]) {
+		
+//		ejemploExceptionGeneral();
+//		ejemploNullPointerException();
+//		ejemploArithmeticException();
+		//ejemploClassCastException();
+		//ejemploIndexOutOfBoundsException();
+		//ejemploNumberFormatException();
+		ejemploClassNotFoundException();	
+	}
+}

src/tutorialJava/capitulo7_Recursos/excepciones/EjemploLanzamientoExcepcionPropia.java

@@ -0,0 +1,63 @@
+package tutorialJava.capitulo7_Recursos.excepciones;
+
+public class EjemploLanzamientoExcepcionPropia {
+
+	/**
+	 * 
+	 * @param persona
+	 * @return
+	 * @throws PersonaNulaException
+	 * @throws PiernaNulaException
+	 */
+	private static String personaToString (Persona persona) throws PersonaNulaException, PiernaNulaException {
+		StringBuffer sb = new StringBuffer();
+		// A partir de una persona, vamos a construir un StringBuffer que recorra sus dos piernas
+		if (persona == null) {
+			throw new PersonaNulaException("El objeto persona es null");
+		}
+		else {
+			sb.append("El objeto persona tiene dos piernas: ");
+			
+			if (persona.getPiernaDerecha() == null) {
+				throw new PiernaNulaException("La pierna derecha del objeto persona es null");
+			}
+			else {
+				sb.append("la derecha ");
+				
+				if (persona.getPiernaIzquierda() == null) {
+					throw new PiernaNulaException("La pierna izquierda del objeto persona es null");
+				}
+				else {
+					sb.append("y la izquierda.");
+				}
+			}
+		}
+		
+		return sb.toString();
+	}
+	
+	
+	
+	
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		
+		try {
+//			Persona persona = new Persona(new Pierna(Pierna.DERECHA), new Pierna(Pierna.IZQUIERDA));
+			Persona persona = null;
+//			Persona persona = new Persona(null, new Pierna(Pierna.IZQUIERDA));
+//			Persona persona = new Persona(new Pierna(Pierna.DERECHA), null);
+			System.out.println(personaToString(persona));
+		} catch (PersonaNulaException e) {
+			System.out.println("Existen valores nulos en el objeto persona: " + e.getMessage());
+			e.printStackTrace();
+		} catch (PiernaNulaException e) {
+			System.out.println("Existen valores nulos en el objeto persona: " + e.getMessage());
+		}
+
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/excepciones/MartesException.java

@@ -0,0 +1,29 @@
+package tutorialJava.capitulo7_Recursos.excepciones;
+
+public class MartesException extends Exception {
+
+	public MartesException() {
+		// TODO Auto-generated constructor stub
+	}
+
+	public MartesException(String message) {
+		super(message);
+		// TODO Auto-generated constructor stub
+	}
+
+	public MartesException(Throwable cause) {
+		super(cause);
+		// TODO Auto-generated constructor stub
+	}
+
+	public MartesException(String message, Throwable cause) {
+		super(message, cause);
+		// TODO Auto-generated constructor stub
+	}
+
+	public MartesException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
+		super(message, cause, enableSuppression, writableStackTrace);
+		// TODO Auto-generated constructor stub
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/excepciones/Persona.java

@@ -0,0 +1,34 @@
+package tutorialJava.capitulo7_Recursos.excepciones;
+
+public class Persona {
+	protected Pierna piernaDerecha;
+	protected Pierna piernaIzquierda;
+	
+	public Persona() {
+		System.out.println("Constructor Persona sin argumentos");
+		this.piernaDerecha = new Pierna(Pierna.DERECHA);
+		this.piernaIzquierda = new Pierna(Pierna.IZQUIERDA);
+	}
+	
+	public Persona(Pierna piernaDerecha, Pierna piernaIzquierda) {
+		super();
+		this.piernaDerecha = piernaDerecha;
+		this.piernaIzquierda = piernaIzquierda;
+	}
+
+	public Pierna getPiernaDerecha() {
+		return piernaDerecha;
+	}
+
+	public void setPiernaDerecha(Pierna piernaDerecha) {
+		this.piernaDerecha = piernaDerecha;
+	}
+
+	public Pierna getPiernaIzquierda() {
+		return piernaIzquierda;
+	}
+
+	public void setPiernaIzquierda(Pierna piernaIzquierda) {
+		this.piernaIzquierda = piernaIzquierda;
+	}
+}

src/tutorialJava/capitulo7_Recursos/excepciones/PersonaNulaException.java

@@ -0,0 +1,8 @@
+package tutorialJava.capitulo7_Recursos.excepciones;
+
+public class PersonaNulaException extends Exception {
+
+	public PersonaNulaException(String msg) {
+        super(msg);
+    }
+}

src/tutorialJava/capitulo7_Recursos/excepciones/Pierna.java

@@ -0,0 +1,24 @@
+package tutorialJava.capitulo7_Recursos.excepciones;
+
+public class Pierna {
+	
+	public static int DERECHA = 0;
+	public static int IZQUIERDA = 1;
+	
+	protected int tipo;
+
+	public Pierna(int tipo) {
+		super();
+		this.tipo = tipo;
+	}
+
+	public int getTipo() {
+		return tipo;
+	}
+
+	public void setTipo(int tipo) {
+		this.tipo = tipo;
+	}
+	
+	
+}

src/tutorialJava/capitulo7_Recursos/excepciones/PiernaNulaException.java

@@ -0,0 +1,8 @@
+package tutorialJava.capitulo7_Recursos.excepciones;
+
+public class PiernaNulaException extends Exception {
+
+	public PiernaNulaException(String msg) {
+        super(msg);
+    }
+}

src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/PalabraRepetidaException.java

@@ -0,0 +1,13 @@
+package tutorialJava.capitulo7_Recursos.palabraRepetidaException;
+
+public class PalabraRepetidaException extends Exception {
+
+	public PalabraRepetidaException() {
+		super();
+	}
+
+	public PalabraRepetidaException(String message) {
+		super(message);
+	}
+
+}

src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/Principal.java

@@ -0,0 +1,65 @@
+package tutorialJava.capitulo7_Recursos.palabraRepetidaException;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Scanner;
+
+public class Principal {
+	
+
+	/**
+	 * @throws PalabraRepetidaException 
+	 * 
+	 */
+	private static void pideFrases() throws PalabraRepetidaException {
+		Scanner sc = new Scanner(System.in);
+		String frase = "";
+		
+		
+		do {
+			System.out.println("Dame una frase: ");
+			frase = sc.nextLine();
+			String palabras[] = frase.split("[ ]+");
+			List<String> listaPalabras = Arrays.asList(palabras);
+			
+			for (int i = 0; i < palabras.length; i++) {
+				String palabra = palabras[i];
+				if (listaPalabras.subList(0, i).contains(palabra)) {
+					System.out.println("La palabra " + palabra + " está "
+							+ "repetida");
+					throw new PalabraRepetidaException("La palabra " + 
+							palabra + " está repetida en la frase: " + 
+							frase);
+				}
+			}
+			
+		} while (!frase.equals(""));
+
+	}
+	
+	
+	
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		try {
+			pideFrases();
+		} catch (PalabraRepetidaException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+
+}
+
+
+
+
+
+
+
+
+

src/tutorialJava/examenes/examen20241213/Animal.java

@@ -0,0 +1,50 @@
+package tutorialJava.examenes.examen20241213;
+
+import tutorialJava.Utils;
+
+public abstract class Animal {
+	protected String nombre;
+	protected float peso;
+	
+	public Animal() {
+		super();
+	}
+
+	public Animal(String nombre) {
+		super();
+		this.nombre = nombre;
+		this.peso = Utils.obtenerNumeroAzar(1, 600);
+	}
+
+	public Animal(String nombre, float peso) {
+		super();
+		this.nombre = nombre;
+		this.peso = peso;
+	}
+	
+	public abstract float calcularEspacio();
+
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	public float getPeso() {
+		return peso;
+	}
+
+	public void setPeso(float peso) {
+		this.peso = peso;
+	}
+
+	@Override
+	public String toString() {
+		return "Animal [nombre=" + nombre + ", peso=" + peso + "]";
+	}
+	
+	
+	
+}

src/tutorialJava/examenes/examen20241213/Ave.java

@@ -0,0 +1,38 @@
+package tutorialJava.examenes.examen20241213;
+
+import tutorialJava.Utils;
+
+public class Ave extends Animal {
+
+	private float envergaduraAlas;
+
+	public Ave() {
+		super();
+	}
+
+	public Ave(String nombre) {
+		super(nombre);
+		this.envergaduraAlas = Utils.obtenerNumeroAzar(15, 200);
+	}
+
+	@Override
+	public float calcularEspacio() {
+		return (float) (this.peso * 1.5 + this.envergaduraAlas * 2);
+	}
+
+	public float getEnvergaduraAlas() {
+		return envergaduraAlas;
+	}
+
+	public void setEnvergaduraAlas(float envergaduraAlas) {
+		this.envergaduraAlas = envergaduraAlas;
+	}
+
+	@Override
+	public String toString() {
+		return "Ave [envergaduraAlas=" + envergaduraAlas + ", nombre=" + nombre + ", peso=" + peso
+				+ ", calcularEspacio()=" + calcularEspacio() + "]";
+	}
+	
+	
+}

src/tutorialJava/examenes/examen20241213/Mamifero.java

@@ -0,0 +1,52 @@
+package tutorialJava.examenes.examen20241213;
+
+import tutorialJava.Utils;
+
+public class Mamifero extends Animal {
+
+	private String tipoAlimentacion;
+	
+	public Mamifero() {
+		super();
+	}
+	
+	public Mamifero(String nombre) {
+		super(nombre);
+		
+		if (Utils.obtenerNumeroAzar(0, 1) == 0) { // Carnívoro
+			this.tipoAlimentacion = "Carnívoro";
+		}
+		else { // Herbívoro
+			this.tipoAlimentacion = "Herbívoro";
+		}
+	}
+
+
+	@Override
+	public float calcularEspacio() {
+		return this.peso * 3;
+	}
+
+	public String getTipoAlimentacion() {
+		return tipoAlimentacion;
+	}
+
+	public void setTipoAlimentacion(String tipoAlimentacion) {
+		this.tipoAlimentacion = tipoAlimentacion;
+	}
+
+	@Override
+	public String toString() {
+		return "Mamifero [tipoAlimentacion=" + tipoAlimentacion + ", nombre=" + nombre + ", peso=" + peso
+				+ ", calcularEspacio()=" + calcularEspacio() + "]";
+	}
+
+	
+}
+
+
+
+
+
+
+

src/tutorialJava/examenes/examen20241213/Principal.java

@@ -0,0 +1,141 @@
+package tutorialJava.examenes.examen20241213;
+
+import tutorialJava.Utils;
+import tutorialJava.examenes.examen20241211.Producto;
+
+public class Principal {
+
+	private static Animal[] animales = new Animal[Utils.obtenerNumeroAzar(10, 20)];
+	
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		
+		// Inicializo objetos en Array
+		for (int i = 0; i < animales.length; i++) {
+			if (i < (animales.length / 2)) {
+				animales[i] = new Mamifero("Mamífero_" + i);
+			}
+			else {
+				animales[i] = new Ave("Ave_" + i);
+			}
+		}
+
+		muestraAnimales();
+		ordenaBurbuja(animales);
+		System.out.println("\nAnimales ordenados");
+		muestraAnimales();
+		
+		System.out.println("\nEspacios necsarios");
+		System.out.println("Total espacio necesario: " + calcularEspacioTotal());
+		System.out.println("Total espacio mamíferos carnívoros: " + 
+				calcularEspacioMamiferosCarnivoros());
+		
+		System.out.println("\nEstadísticas");
+		System.out.println("Animal que más ocupa: " + animales[0].toString());
+		System.out.println("Animal que menos ocupa: " + 
+				animales[animales.length - 1].toString());
+		System.out.println("Total mamíferos herbívoros: " + contadorMamiferosHerbivoros());
+		System.out.println("Total aves gran envergadura: " + 
+				contadorAvesGranEnvergadura());
+	}
+	
+	/**
+	 * 
+	 */
+	private static void muestraAnimales() {
+		for (int i = 0; i < animales.length; i++) {
+			System.out.println(animales[i].toString());
+		}
+	}
+
+	
+	private static float calcularEspacioTotal() {
+		float espacio = 0;
+		for (int i = 0; i < animales.length; i++) {
+			espacio += animales[i].calcularEspacio();
+		}
+		return espacio;
+	}
+	
+	
+	private static float calcularEspacioMamiferosCarnivoros() {
+		float espacio = 0;
+		for (int i = 0; i < animales.length; i++) {
+			if (animales[i] instanceof Mamifero) {
+				Mamifero m = (Mamifero) animales[i];
+				if (m.getTipoAlimentacion().equalsIgnoreCase("Carnívoro")) {
+					espacio += animales[i].calcularEspacio();
+				}
+			}
+		}
+		return espacio;
+	}
+	
+	/**
+	 * 
+	 * @return
+	 */
+	private static int contadorMamiferosHerbivoros() {
+		int cont = 0;
+		for (int i = 0; i < animales.length; i++) {
+			if (animales[i] instanceof Mamifero) {
+				Mamifero m = (Mamifero) animales[i];
+				if (m.getTipoAlimentacion().equalsIgnoreCase("Herbívoro")) {
+					cont++;
+				}
+			}
+		}
+		return cont;
+	}
+	
+	/**
+	 * 
+	 * @return
+	 */
+	private static int contadorAvesGranEnvergadura() {
+		int cont = 0;
+		for (int i = 0; i < animales.length; i++) {
+			if (animales[i] instanceof Ave) {
+				Ave a = (Ave) animales[i];
+				if (a.getEnvergaduraAlas() > 100) {
+					cont++;
+				}
+			}
+		}
+		return cont;
+	}
+	
+	/**
+	 * 
+	 * @param a
+	 */
+	public static void ordenaBurbuja(Animal a[]) {
+		boolean hayIntercambios = false;
+		do {
+			hayIntercambios = false;
+			for (int i = 0; i < a.length - 1; i++) {
+				if (a[i].calcularEspacio() < a[i + 1].calcularEspacio()) {
+					Animal aux = a[i];
+					a[i] = a[i + 1];
+					a[i + 1] = aux;
+					hayIntercambios = true;
+				}
+			}
+		} while (hayIntercambios == true);
+		
+	}
+
+	
+	
+	
+}
+
+
+
+
+
+
+