feat(examen 19/6/25): solucionado

.classpath

@@ -6,5 +6,20 @@
 		</attributes>
 	</classpathentry>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="librerias/Driver_MySQL_Connector_J/mysql-connector-java-8.0.19.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/jpa/javax.persistence_2.1.0.v201304241213.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/jpa/org.eclipse.persistence.jpa.modelgen_2.5.2.v20140319-9ad6abd.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/jpa/org.eclipse.persistence.jpars_2.5.2.v20140319-9ad6abd.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/com.sun.tools.xjc_2.2.0.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/com.sun.xml.bind_2.2.0.v201004141950.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/javax.activation_1.1.0.v201108011116.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/javax.mail_1.4.0.v201005080615.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/javax.xml.bind_2.2.0.v201105210648.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/moxy/javax.xml.stream_1.0.1.v201004272200.jar"/>
+	<classpathentry kind="lib" path="librerias/EclipseLink2.5.2/jlib/eclipselink.jar"/>
+	<classpathentry kind="lib" path="librerias/Jackson/jackson-annotations-2.9.0.jar"/>
+	<classpathentry kind="lib" path="librerias/Jackson/jackson-core-2.9.5.jar"/>
+	<classpathentry kind="lib" path="librerias/Jackson/jackson-databind-2.9.5.jar"/>
+	<classpathentry kind="lib" path="librerias/mongoDB-Java-driver/mongo-java-driver-3.12.12.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

BBDDs/02_BBDD_EvaluacionCentroEducativo/evaluacionCentroEducativo.sql

@@ -0,0 +1,174 @@
+CREATE DATABASE  IF NOT EXISTS `centroeducativo` /*!40100 DEFAULT CHARACTER SET utf8 */;
+USE `centroeducativo`;
+-- MySQL dump 10.13  Distrib 5.6.13, for Win32 (x86)
+--
+-- Host: 127.0.0.1    Database: centroeducativo
+-- ------------------------------------------------------
+-- Server version	5.6.16-log
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+/*!40101 SET NAMES utf8 */;
+/*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
+/*!40103 SET TIME_ZONE='+00:00' */;
+/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
+/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
+/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
+/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
+
+--
+-- Table structure for table `curso`
+--
+
+DROP TABLE IF EXISTS `curso`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `curso` (
+  `id` int(11) NOT NULL,
+  `descripcion` varchar(45) DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `curso`
+--
+
+LOCK TABLES `curso` WRITE;
+/*!40000 ALTER TABLE `curso` DISABLE KEYS */;
+INSERT INTO `curso` VALUES (1,'2017-18');
+/*!40000 ALTER TABLE `curso` ENABLE KEYS */;
+UNLOCK TABLES;
+
+--
+-- Table structure for table `estudiante`
+--
+
+DROP TABLE IF EXISTS `estudiante`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `estudiante` (
+  `id` int(11) NOT NULL,
+  `nombre` varchar(150) DEFAULT NULL,
+  `apellido1` varchar(150) DEFAULT NULL,
+  `apellido2` varchar(150) DEFAULT NULL,
+  `dni` varchar(15) DEFAULT NULL,
+  `direccion` varchar(250) DEFAULT NULL,
+  `email` varchar(150) DEFAULT NULL,
+  `telefono` varchar(150) DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `estudiante`
+--
+
+LOCK TABLES `estudiante` WRITE;
+/*!40000 ALTER TABLE `estudiante` DISABLE KEYS */;
+INSERT INTO `estudiante` VALUES (1,'Julio','Mármol','Mármol','14785236A','dir, 21','adsf','654785214'),(2,'Francisco','Fernández','Fernández','52874369B','dir, 24','f@f.com','741258963'),(3,'Miguel','Palacios','Fernández','58963214C','dir, 26','m@m.com','632521478');
+/*!40000 ALTER TABLE `estudiante` ENABLE KEYS */;
+UNLOCK TABLES;
+
+--
+-- Table structure for table `materia`
+--
+
+DROP TABLE IF EXISTS `materia`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `materia` (
+  `id` int(11) NOT NULL,
+  `nombre` varchar(100) DEFAULT NULL,
+  `acronimo` varchar(15) DEFAULT NULL,
+  `curso_id` int(11) NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `fk_asignatura_curso1_idx` (`curso_id`),
+  CONSTRAINT `fk_asignatura_curso1` FOREIGN KEY (`curso_id`) REFERENCES `curso` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `materia`
+--
+
+LOCK TABLES `materia` WRITE;
+/*!40000 ALTER TABLE `materia` DISABLE KEYS */;
+INSERT INTO `materia` VALUES (1,'Programación','PROG',1),(2,'Lenguajes de Marcas y Sistemas de Gestión de la Información','LMSGI',1),(3,'Sistemas Informáticos','SI',1),(4,'Entornos de Desarrollo','EntDes',1),(5,'Bases de Datos','BD',1),(6,'Formación y Orientación Laboral','FOL',1);
+/*!40000 ALTER TABLE `materia` ENABLE KEYS */;
+UNLOCK TABLES;
+
+--
+-- Table structure for table `profesor`
+--
+
+DROP TABLE IF EXISTS `profesor`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `profesor` (
+  `id` int(11) NOT NULL,
+  `nombre` varchar(150) DEFAULT NULL,
+  `apellido1` varchar(150) DEFAULT NULL,
+  `apellido2` varchar(150) DEFAULT NULL,
+  `dni` varchar(15) DEFAULT NULL,
+  `direccion` varchar(250) DEFAULT NULL,
+  `email` varchar(150) DEFAULT NULL,
+  `telefono` varchar(150) DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `profesor`
+--
+
+LOCK TABLES `profesor` WRITE;
+/*!40000 ALTER TABLE `profesor` DISABLE KEYS */;
+INSERT INTO `profesor` VALUES (1,'Rafael Carlos','López','Ruiz','12345678b','Su casa, 34','asdf','sdaf'),(2,'Joaquín','Molinero','Suárez','23456789B','Su casa también, 42','joaquin@joaquin.com','654789322'),(3,'Miguel Ángel','Pérez','Carmona','98765432C','Otra casa, 12','miguel@miguel.com','654147852'),(4,'Alejandro','Fernández','Fernández','47125896D','Allí, 65','alejandro@alejandro.com','658974125'),(5,'Águeda','Cuenca','Cuenca','96325874','Graná, 25','','698521478');
+/*!40000 ALTER TABLE `profesor` ENABLE KEYS */;
+UNLOCK TABLES;
+
+--
+-- Table structure for table `valoracionmateria`
+--
+
+DROP TABLE IF EXISTS `valoracionmateria`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `valoracionmateria` (
+  `id` int(11) NOT NULL,
+  `idProfesor` int(11) NOT NULL,
+  `idEstudiante` int(11) NOT NULL,
+  `idMateria` int(11) NOT NULL,
+  `valoracion` float DEFAULT NULL,
+  PRIMARY KEY (`id`),
+  KEY `fk_asignatura_profesor_idx` (`idProfesor`),
+  KEY `fk_asignatura_estudiante1_idx` (`idEstudiante`),
+  KEY `fk_asignatura_asignatura1_idx` (`idMateria`),
+  CONSTRAINT `fk_asignatura_asignatura1` FOREIGN KEY (`idMateria`) REFERENCES `materia` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
+  CONSTRAINT `fk_asignatura_estudiante1` FOREIGN KEY (`idEstudiante`) REFERENCES `estudiante` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
+  CONSTRAINT `fk_asignatura_profesor` FOREIGN KEY (`idProfesor`) REFERENCES `profesor` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+/*!40101 SET character_set_client = @saved_cs_client */;
+
+--
+-- Dumping data for table `valoracionmateria`
+--
+
+LOCK TABLES `valoracionmateria` WRITE;
+/*!40000 ALTER TABLE `valoracionmateria` DISABLE KEYS */;
+INSERT INTO `valoracionmateria` VALUES (1,1,1,1,6),(2,1,1,2,7),(3,2,1,3,6),(4,3,1,4,6),(5,4,1,5,8),(6,5,1,6,4),(7,1,2,1,5),(8,1,2,2,7),(9,2,2,3,8),(10,3,2,4,5),(11,4,2,5,6),(12,5,2,6,4);
+/*!40000 ALTER TABLE `valoracionmateria` ENABLE KEYS */;
+UNLOCK TABLES;
+/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */;
+
+/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
+/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
+/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
+/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
+
+-- Dump completed on 2019-04-09 10:05:53

BBDDs/05_JSON_CCAA_Provincias_Poblaciones/ccaa.json

@@ -0,0 +1,97 @@
+[
+  {
+    "parent_code": "0",
+    "label": "Andalucía",
+    "code": "01"
+  },
+  {
+    "parent_code": "0",
+    "label": "Aragón",
+    "code": "02"
+  },
+  {
+    "parent_code": "0",
+    "label": "Asturias, Principado de",
+    "code": "03"
+  },
+  {
+    "parent_code": "0",
+    "label": "Balears, Illes",
+    "code": "04"
+  },
+  {
+    "parent_code": "0",
+    "label": "Canarias",
+    "code": "05"
+  },
+  {
+    "parent_code": "0",
+    "label": "Cantabria",
+    "code": "06"
+  },
+  {
+    "parent_code": "0",
+    "label": "Castilla y León",
+    "code": "07"
+  },
+  {
+    "parent_code": "0",
+    "label": "Castilla - La Mancha",
+    "code": "08"
+  },
+  {
+    "parent_code": "0",
+    "label": "Cataluńa",
+    "code": "09"
+  },
+  {
+    "parent_code": "0",
+    "label": "Comunitat Valenciana",
+    "code": "10"
+  },
+  {
+    "parent_code": "0",
+    "label": "Extremadura",
+    "code": "11"
+  },
+  {
+    "parent_code": "0",
+    "label": "Galicia",
+    "code": "12"
+  },
+  {
+    "parent_code": "0",
+    "label": "Madrid, Comunidad de",
+    "code": "13"
+  },
+  {
+    "parent_code": "0",
+    "label": "Murcia, Región de",
+    "code": "14"
+  },
+  {
+    "parent_code": "0",
+    "label": "Navarra, Comunidad Foral de",
+    "code": "15"
+  },
+  {
+    "parent_code": "0",
+    "label": "País Vasco",
+    "code": "16"
+  },
+  {
+    "parent_code": "0",
+    "label": "Rioja, La",
+    "code": "17"
+  },
+  {
+    "parent_code": "0",
+    "label": "Ceuta",
+    "code": "18"
+  },
+  {
+    "parent_code": "0",
+    "label": "Melilla",
+    "code": "19"
+  }
+]

BBDDs/05_JSON_CCAA_Provincias_Poblaciones/provincias.json

@@ -0,0 +1,262 @@
+[
+  {
+    "parent_code": "01",
+    "code": "04",
+    "label": "Almería"
+  },
+  {
+    "parent_code": "01",
+    "code": "11",
+    "label": "Cádiz"
+  },
+  {
+    "parent_code": "01",
+    "code": "14",
+    "label": "Córdoba"
+  },
+  {
+    "parent_code": "01",
+    "code": "18",
+    "label": "Granada"
+  },
+  {
+    "parent_code": "01",
+    "code": "21",
+    "label": "Huelva"
+  },
+  {
+    "parent_code": "01",
+    "code": "23",
+    "label": "Jaén"
+  },
+  {
+    "parent_code": "01",
+    "code": "29",
+    "label": "Málaga"
+  },
+  {
+    "parent_code": "01",
+    "code": "41",
+    "label": "Sevilla"
+  },
+  {
+    "parent_code": "02",
+    "code": "22",
+    "label": "Huesca"
+  },
+  {
+    "parent_code": "02",
+    "code": "44",
+    "label": "Teruel"
+  },
+  {
+    "parent_code": "02",
+    "code": "50",
+    "label": "Zaragoza"
+  },
+  {
+    "parent_code": "03",
+    "code": "33",
+    "label": "Asturias"
+  },
+  {
+    "parent_code": "04",
+    "code": "07",
+    "label": "Balears, Illes"
+  },
+  {
+    "parent_code": "05",
+    "code": "35",
+    "label": "Palmas, Las"
+  },
+  {
+    "parent_code": "05",
+    "code": "38",
+    "label": "Santa Cruz de Tenerife"
+  },
+  {
+    "parent_code": "06",
+    "code": "39",
+    "label": "Cantabria"
+  },
+  {
+    "parent_code": "07",
+    "code": "05",
+    "label": "Ávila"
+  },
+  {
+    "parent_code": "07",
+    "code": "09",
+    "label": "Burgos"
+  },
+  {
+    "parent_code": "07",
+    "code": "24",
+    "label": "León"
+  },
+  {
+    "parent_code": "07",
+    "code": "34",
+    "label": "Palencia"
+  },
+  {
+    "parent_code": "07",
+    "code": "37",
+    "label": "Salamanca"
+  },
+  {
+    "parent_code": "07",
+    "code": "40",
+    "label": "Segovia"
+  },
+  {
+    "parent_code": "07",
+    "code": "42",
+    "label": "Soria"
+  },
+  {
+    "parent_code": "07",
+    "code": "47",
+    "label": "Valladolid"
+  },
+  {
+    "parent_code": "07",
+    "code": "49",
+    "label": "Zamora"
+  },
+  {
+    "parent_code": "08",
+    "code": "02",
+    "label": "Albacete"
+  },
+  {
+    "parent_code": "08",
+    "code": "13",
+    "label": "Ciudad Real"
+  },
+  {
+    "parent_code": "08",
+    "code": "16",
+    "label": "Cuenca"
+  },
+  {
+    "parent_code": "08",
+    "code": "19",
+    "label": "Guadalajara"
+  },
+  {
+    "parent_code": "08",
+    "code": "45",
+    "label": "Toledo"
+  },
+  {
+    "parent_code": "09",
+    "code": "08",
+    "label": "Barcelona"
+  },
+  {
+    "parent_code": "09",
+    "code": "17",
+    "label": "Girona"
+  },
+  {
+    "parent_code": "09",
+    "code": "25",
+    "label": "Lleida"
+  },
+  {
+    "parent_code": "09",
+    "code": "43",
+    "label": "Tarragona"
+  },
+  {
+    "parent_code": "10",
+    "code": "03",
+    "label": "Alicante/Alacant"
+  },
+  {
+    "parent_code": "10",
+    "code": "12",
+    "label": "Castellón/Castelló"
+  },
+  {
+    "parent_code": "10",
+    "code": "46",
+    "label": "Valencia/València"
+  },
+  {
+    "parent_code": "11",
+    "code": "06",
+    "label": "Badajoz"
+  },
+  {
+    "parent_code": "11",
+    "code": "10",
+    "label": "Cáceres"
+  },
+  {
+    "parent_code": "12",
+    "code": "15",
+    "label": "Coruña, A"
+  },
+  {
+    "parent_code": "12",
+    "code": "27",
+    "label": "Lugo"
+  },
+  {
+    "parent_code": "12",
+    "code": "32",
+    "label": "Ourense"
+  },
+  {
+    "parent_code": "12",
+    "code": "36",
+    "label": "Pontevedra"
+  },
+  {
+    "parent_code": "13",
+    "code": "28",
+    "label": "Madrid"
+  },
+  {
+    "parent_code": "14",
+    "code": "30",
+    "label": "Murcia"
+  },
+  {
+    "parent_code": "15",
+    "code": "31",
+    "label": "Navarra"
+  },
+  {
+    "parent_code": "16",
+    "code": "01",
+    "label": "Araba/Álava"
+  },
+  {
+    "parent_code": "16",
+    "code": "48",
+    "label": "Bizkaia"
+  },
+  {
+    "parent_code": "16",
+    "code": "20",
+    "label": "Gipuzkoa"
+  },
+  {
+    "parent_code": "17",
+    "code": "26",
+    "label": "Rioja, La"
+  },
+  {
+    "parent_code": "18",
+    "code": "51",
+    "label": "Ceuta"
+  },
+  {
+    "parent_code": "19",
+    "code": "52",
+    "label": "Melilla"
+  }
+]

src/tutorialJava/Utils.java

@@ -53,6 +53,30 @@ public class Utils {
 		return n;
 	}
 	
+	/**
+	 * Pide un número entero al usuario
+	 * @param mensaje String que va a mostrarse en consola para pedir el número
+	 * @return Número entero introducido por el usuario
+	 */
+	public static float pideNumeroFloat (String mensaje) {
+		float n = 0;
+		boolean esNumeroCorrecto;
+		Scanner sc = new Scanner(System.in);
+		
+		do {
+			esNumeroCorrecto = false;
+			try {
+				System.out.println(mensaje);
+				n = Float.parseFloat(sc.nextLine());
+				esNumeroCorrecto = true;
+			}
+			catch (Exception e) {
+				System.out.println("No ha introducido un número");
+			}
+		} while (esNumeroCorrecto == false);
+		
+		return n;
+	}
 	
 	
 	/**
@@ -90,6 +114,41 @@ public class Utils {
 		
 	}
 	
+	/**
+	 * Obtiene un número entero a través de un objeto Scanner
+	 * @return Número entero introducido por el usuario.
+	 */
+	public static double obtenerDoublePorScanner() {
+		Scanner sc = new Scanner(System.in);
+		
+		while (true) {
+			try {
+				return sc.nextDouble();
+			} catch (Exception ex) {
+				System.out.println("Error, introduce un número double: ");
+				sc.nextLine();
+			}
+		}
+		
+	}
+	
+	/**
+	 * Obtiene un número entero a través de un objeto Scanner
+	 * @return Número entero introducido por el usuario.
+	 */
+	public static double obtenerDoublePorScanner(String mensaje) {
+		System.out.println(mensaje);
+		return obtenerDoublePorScanner();
+	}
+	
+	/**
+	 * Obtiene un número entero a través de un objeto Scanner
+	 * @return Número entero introducido por el usuario.
+	 */
+	public static float obtenerFloatPorScanner(String mensaje) {
+		return (float) obtenerDoublePorScanner(mensaje);
+	}
+	
 	/**
 	 * Obtiene un número entero a través de un JOptionPane
 	 * @return Número entero introducido a través de un JOptionPane.
@@ -119,6 +178,11 @@ public class Utils {
 		return num;
 	}
 	
+	public static double obtenerDoubleConDescripcion(String desc) {
+		System.out.println(desc);
+		return obtenerDoublePorScanner();
+	}
+	
 	/**
 	 * 
 	 * @return Número entero introducido por el usuario

src/tutorialJava/UtilsArrays.java

@@ -149,6 +149,19 @@ public class UtilsArrays {
 	}
 
 	
+	 /* 
+	 * @param m
+	 */
+	public static void imprimeMatriz (char m[][]) {
+		for (int i = 0; i < m.length; i++) {
+			for (int j = 0; j < m[i].length; j++) {
+				System.out.print(m[i][j] + " ");
+			}
+			System.out.println();
+		}
+	}
+
+	
 	public static void ordenaArray (int a[], boolean asc) {
 		boolean hayIntercambios;
 		do {

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque09/Ejercicio02_findAndReplace.java

@@ -23,7 +23,6 @@ public class Ejercicio02_findAndReplace {
 	 * @return
 	 */
 	public static void findAndReplace (int b[], int buscado, int reemplazo) {
-		StringBuffer sb = new StringBuffer();
 				
 		for (int i = 0; i < b.length; i++) {
 			if (b[i] == buscado) {

src/tutorialJava/capitulo4_Arrays/ejercicios/bloque10/Ejercicio04_MatrizConBordeYCeroAlAzar.java

@@ -4,13 +4,14 @@ public class Ejercicio04_MatrizConBordeYCeroAlAzar {
 
 	public static void main(String[] args) {
 		// Declaración de variables
-		char matriz[][] = new char[20][10];
+		char matriz[][] = new char[10][20];
 		int posicionAzarFila, posicionAzarColumna;
 		
 		// La relleno de espacios en blanco
 		for (int i = 0; i < matriz.length; i++) {
 			for (int j = 0; j < matriz[i].length; j++) {
-				if (i == 0 || i == (matriz.length - 1) || j == 0 || j == (matriz[0].length - 1)) {
+				if (i == 0 || i == (matriz.length - 1) || 
+						j == 0 || j == (matriz[0].length - 1)) {
 					matriz[i][j] = '*';
 				}
 				else {

src/tutorialJava/capitulo5/ej01_cromosBaloncesto/Cromo.java

@@ -0,0 +1,60 @@
+package tutorialJava.capitulo5.ej01_cromosBaloncesto;
+
+public class Cromo {
+	// Propiedades
+	protected String nombreJugador;
+	protected int puntuacion;
+	protected String equipo;
+	
+	public Cromo() {
+		this.nombreJugador = "Jugador por defecto";
+		this.puntuacion = 0;
+		this.equipo = "Sin equipo";
+	}
+
+	public Cromo(String nombreJugador, int puntuacion, String equipo) {
+		this.nombreJugador = nombreJugador;
+		this.puntuacion = puntuacion;
+		this.equipo = equipo;
+	}
+
+	
+	public void agregaMinimaPuntuacion() {
+		this.puntuacion++;
+	}
+	
+	
+	public String getNombreJugador() {
+		return nombreJugador;
+	}
+
+	public void setNombreJugador(String nombreJugador) {
+		this.nombreJugador = nombreJugador;
+	}
+
+	public int getPuntuacion() {
+		return puntuacion;
+	}
+
+	public void setPuntuacion(int puntuacion) {
+		this.puntuacion = puntuacion;
+	}
+
+	public String getEquipo() {
+		return equipo;
+	}
+
+	public void setEquipo(String equipo) {
+		this.equipo = equipo;
+	}
+
+	@Override
+	public String toString() {
+		return "Cromo [nombreJugador=" + nombreJugador + ", puntuacion=" + puntuacion + ", equipo=" + equipo + "]";
+	}
+
+
+
+
+	
+}

src/tutorialJava/capitulo5/ej01_cromosBaloncesto/CromoBaloncesto.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo5.ej01_cromosBaloncesto;
+
+public class CromoBaloncesto extends Cromo {
+	
+	private int altura;
+	
+	
+	public CromoBaloncesto() {
+		super();
+	}
+
+	public CromoBaloncesto(String nombreJugador, int puntuacion, String equipo) {
+		super(nombreJugador, puntuacion, equipo);
+	}
+
+	@Override
+	public void agregaMinimaPuntuacion() {
+		this.setPuntuacion(this.getPuntuacion() + 2);
+	}
+
+	@Override
+	public String toString() {
+		return "CromoBaloncesto [getNombreJugador()=" + getNombreJugador() + ", getPuntuacion()=" + getPuntuacion()
+				+ ", getEquipo()=" + getEquipo() + ", altura=" + altura + "]";
+	}
+
+
+}
+
+
+
+
+
+
+
+
+
+
+

src/tutorialJava/capitulo5/ej01_cromosBaloncesto/CromoFutbol.java

@@ -0,0 +1,11 @@
+package tutorialJava.capitulo5.ej01_cromosBaloncesto;
+
+public class CromoFutbol extends Cromo {
+
+	public CromoFutbol() {
+	}
+
+	public CromoFutbol(String nombreJugador, int puntuacion, String equipo) {
+	}
+
+}

src/tutorialJava/capitulo5/ej01_cromosBaloncesto/Principal.java

@@ -0,0 +1,16 @@
+package tutorialJava.capitulo5.ej01_cromosBaloncesto;
+
+public class Principal {
+
+	public static void main(String[] args) {
+		Cromo cromoSimple = new Cromo("Iniesta", 1000, "España");
+		System.out.println("Id del cromo: " + cromoSimple.hashCode());
+		System.out.println(cromoSimple.toString());
+		
+		
+		CromoBaloncesto cromo1 = new CromoBaloncesto("Ricky", 100, "Barcelona");
+		System.out.println("Id del cromo: " + cromo1.hashCode());
+		System.out.println(cromo1.toString());
+	}
+
+}

src/tutorialJava/capitulo5/ej02_independenceDay/CampoBatalla.java

@@ -0,0 +1,178 @@
+package tutorialJava.capitulo5.ej02_independenceDay;
+
+import java.util.Arrays;
+
+import tutorialJava.Utils;
+
+public class CampoBatalla {
+	
+	private String nombre;
+	private Humano humanos[] = new Humano[20];
+	private Malvado malvados[] = new Malvado[20];
+	
+	/**
+	 * 
+	 * @param nombre
+	 */
+	public CampoBatalla (String nombre) {
+		this.nombre = nombre;
+		
+		for (int i = 0; i < humanos.length; i++) {
+			humanos[i] = new Humano("H-" + i);
+		}
+//		humanos[humanos.length - 1].setPuntosVida(
+//				humanos[humanos.length - 1].getPuntosVida() * 2);
+		
+		Humano ultimoHumano = humanos[humanos.length - 1];
+		ultimoHumano.setPuntosVida(ultimoHumano.getPuntosVida() * 2);
+		
+		for (int i = 0; i < malvados.length; i++) {
+			malvados[i] = new Malvado("M-" + i);
+		}
+		// Establezco el doble de puntos de vida al último malvado
+		Malvado ultimoMalvado = malvados[malvados.length - 1];
+		ultimoMalvado.setPuntosVida(ultimoMalvado.getPuntosVida() * 2);
+	}
+
+	
+	public void mezclaHumanos () {
+		for (int i = 0; i < humanos.length; i++) {
+			int ind1 = Utils.obtenerNumeroAzar(0, humanos.length - 1);
+			int ind2 = Utils.obtenerNumeroAzar(0, humanos.length - 1);
+			Humano aux = humanos[ind1];
+			humanos[ind1] = humanos[ind2];
+			humanos[ind2] = aux;
+		}
+	}
+	
+	public void mezclaMalvados () {
+		for (int i = 0; i < malvados.length; i++) {
+			int ind1 = Utils.obtenerNumeroAzar(0, malvados.length - 1);
+			int ind2 = Utils.obtenerNumeroAzar(0, malvados.length - 1);
+			Malvado aux = malvados[ind1];
+			malvados[ind1] = malvados[ind2];
+			malvados[ind2] = aux;
+		}
+	}
+	
+	/**
+	 * 
+	 */
+	public void batalla () {
+		do {
+			// Disparo sobre el primer malvado vivo
+			Malvado m = getPrimerMalvadoVivo();
+			m.setPuntosVida(m.getPuntosVida() - 
+					Utils.obtenerNumeroAzar(5, 25));
+			if (m.getPuntosVida() <= 0) {
+				m.setVivo(false);
+				m.setPuntosVida(0);
+			}
+
+			// Sólo si queda algún malvado vivo, disparo sobre humano
+			if (getPrimerMalvadoVivo() != null) {
+				// Disparo sobre el primer humano vivo
+				Humano h = getPrimerHumanoVivo();
+				h.setPuntosVida(h.getPuntosVida() - 
+						Utils.obtenerNumeroAzar(5, 25));
+				if (h.getPuntosVida() <= 0) {
+					h.setVivo(false);
+					h.setPuntosVida(0);
+				}
+			}
+			
+			// Imprimo campo de batalla
+			System.out.println(toString());
+			System.out.println();
+			
+		} while(getPrimerHumanoVivo() != null &&
+				getPrimerMalvadoVivo() != null);
+		
+		// Si llego hasta aquí, un bando no tiene soldados vivos
+		if (getPrimerHumanoVivo() != null) {
+			System.out.println("Han ganado los humanos");
+		}
+		else {
+			System.out.println("Han ganado los malvados");
+		}
+		
+	}
+	
+	public Humano getPrimerHumanoVivo() {
+		for (int i = 0; i < humanos.length; i++) {
+			if (humanos[i].isVivo()) {
+				return humanos[i];
+			}
+		}
+		return null;
+	}
+	
+	public Malvado getPrimerMalvadoVivo() {
+		for (int i = 0; i < malvados.length; i++) {
+			if (malvados[i].isVivo()) {
+				return malvados[i];
+			}
+		}
+		return null;
+	}
+	
+	
+	
+	
+	
+	
+	
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	public Humano[] getHumanos() {
+		return humanos;
+	}
+
+	public void setHumanos(Humano[] humanos) {
+		this.humanos = humanos;
+	}
+
+	public Malvado[] getMalvados() {
+		return malvados;
+	}
+
+	public void setMalvados(Malvado[] malvados) {
+		this.malvados = malvados;
+	}
+
+	public String toString() {
+		StringBuffer sb = new StringBuffer("Campo: " + this.nombre);
+		sb.append("\nHumanos: ");
+		for (int i = 0; i < humanos.length; i++) {
+			if (humanos[i].isVivo()) {
+				sb.append(humanos[i].getNombre() + ":" +
+						humanos[i].getPuntosVida() + ":" + 
+						humanos[i].isVivo() + " ");
+			}
+		}
+
+		sb.append("\nMalvados: ");
+		for (int i = 0; i < malvados.length; i++) {
+			if (malvados[i].isVivo()) {
+				sb.append(malvados[i].getNombre() + ":" +
+						malvados[i].getPuntosVida() + ":" + 
+						malvados[i].isVivo() + " ");
+			}
+		}
+
+		return sb.toString();
+	}
+	
+	
+}
+
+
+
+
+

src/tutorialJava/capitulo5/ej02_independenceDay/Humano.java

@@ -0,0 +1,62 @@
+package tutorialJava.capitulo5.ej02_independenceDay;
+
+import tutorialJava.Utils;
+
+public class Humano {
+
+	private int puntosVida;
+	private String nombre;
+	private boolean vivo;
+	
+	/**
+	 * 
+	 */
+	public Humano() {
+	}
+
+	/**
+	 * 
+	 * @param puntosVida
+	 * @param nombre
+	 * @param vivo
+	 */
+	public Humano(String nombre) {
+		puntosVida = Utils.obtenerNumeroAzar(50, 100);
+		this.nombre = nombre;
+		vivo = true;
+	}
+
+	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 boolean isVivo() {
+		return vivo;
+	}
+
+	public void setVivo(boolean vivo) {
+		this.vivo = vivo;
+	}
+
+	public String toString() {
+		return "Humano [puntosVida=" + puntosVida + ", nombre=" + nombre + ", vivo=" + vivo + "]";
+	}
+	
+}
+
+
+
+
+

src/tutorialJava/capitulo5/ej02_independenceDay/Malvado.java

@@ -0,0 +1,53 @@
+package tutorialJava.capitulo5.ej02_independenceDay;
+
+import tutorialJava.Utils;
+
+public class Malvado {
+
+	private int puntosVida;
+	private String nombre;
+	private boolean vivo;
+	
+	public Malvado() {
+		super();
+	}
+
+	public Malvado(String nombre) {
+		this.puntosVida = Utils.obtenerNumeroAzar(50, 100);
+		this.nombre = nombre;
+		this.vivo = true;
+	}
+
+	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 boolean isVivo() {
+		return vivo;
+	}
+
+	public void setVivo(boolean vivo) {
+		this.vivo = vivo;
+	}
+
+	public String toString() {
+		return "Malvador [puntosVida=" + puntosVida + ", nombre=" + nombre + ", vivo=" + vivo + "]";
+	}
+	
+	
+	
+	
+	
+}

src/tutorialJava/capitulo5/ej02_independenceDay/Principal.java

@@ -0,0 +1,25 @@
+package tutorialJava.capitulo5.ej02_independenceDay;
+
+import tutorialJava.Utils;
+
+public class Principal {
+
+	public static void main(String[] args) {
+		CampoBatalla campo = new CampoBatalla("Rute");
+		
+		campo.mezclaHumanos();
+		campo.mezclaMalvados();
+		System.out.println(campo.toString());
+		
+		campo.batalla();
+		
+	}
+
+}
+
+
+
+
+
+
+

src/tutorialJava/capitulo5/ej03_independenceDayConHerencia/CampoBatalla.java

@@ -0,0 +1,161 @@
+package tutorialJava.capitulo5.ej03_independenceDayConHerencia;
+
+import java.util.Arrays;
+
+import tutorialJava.Utils;
+
+public class CampoBatalla {
+	
+	private String nombre;
+	private Humano humanos[] = new Humano[20];
+	private Malvado malvados[] = new Malvado[20];
+	
+	/**
+	 * 
+	 * @param nombre
+	 */
+	public CampoBatalla (String nombre) {
+		this.nombre = nombre;
+		
+		for (int i = 0; i < humanos.length; i++) {
+			humanos[i] = new Humano("H-" + i);
+		}
+//		humanos[humanos.length - 1].setPuntosVida(
+//				humanos[humanos.length - 1].getPuntosVida() * 2);
+		
+		Humano ultimoHumano = humanos[humanos.length - 1];
+		ultimoHumano.setPuntosVida(ultimoHumano.getPuntosVida() * 2);
+		
+		for (int i = 0; i < malvados.length; i++) {
+			malvados[i] = new Malvado("M-" + i);
+		}
+		// Establezco el doble de puntos de vida al último malvado
+		Malvado ultimoMalvado = malvados[malvados.length - 1];
+		ultimoMalvado.setPuntosVida(ultimoMalvado.getPuntosVida() * 2);
+	}
+
+	
+	public void mezclaPersonajes (Personaje a[]) {
+		for (int i = 0; i < a.length; i++) {
+			int ind1 = Utils.obtenerNumeroAzar(0, a.length - 1);
+			int ind2 = Utils.obtenerNumeroAzar(0, a.length - 1);
+			Personaje aux = a[ind1];
+			a[ind1] = a[ind2];
+			a[ind2] = aux;
+		}
+	}
+	
+	
+	
+	/**
+	 * 
+	 */
+	public void batalla () {
+		do {
+			// Disparo sobre el primer malvado vivo
+			Malvado m = (Malvado) getPrimerPersonajeVivo(malvados);
+			m.setPuntosVida(m.getPuntosVida() - 
+					Utils.obtenerNumeroAzar(5, 25));
+			if (m.getPuntosVida() <= 0) {
+				m.setVivo(false);
+				m.setPuntosVida(0);
+			}
+
+			// Sólo si queda algún malvado vivo, disparo sobre humano
+			if (getPrimerPersonajeVivo(malvados) != null) {
+				// Disparo sobre el primer humano vivo
+				Humano h = (Humano) getPrimerPersonajeVivo(humanos);
+				h.setPuntosVida(h.getPuntosVida() - 
+						Utils.obtenerNumeroAzar(5, 25));
+				if (h.getPuntosVida() <= 0) {
+					h.setVivo(false);
+					h.setPuntosVida(0);
+				}
+			}
+			
+			// Imprimo campo de batalla
+			System.out.println(toString());
+			System.out.println();
+			
+		} while(getPrimerPersonajeVivo(humanos) != null &&
+				getPrimerPersonajeVivo(malvados) != null);
+		
+		// Si llego hasta aquí, un bando no tiene soldados vivos
+		if (getPrimerPersonajeVivo(humanos) != null) {
+			System.out.println("Han ganado los humanos");
+		}
+		else {
+			System.out.println("Han ganado los malvados");
+		}
+		
+	}
+	
+	
+	public Personaje getPrimerPersonajeVivo(Personaje a[]) {
+		for (int i = 0; i < a.length; i++) {
+			if (a[i].isVivo()) {
+				return a[i];
+			}
+		}
+		return null;
+	}	
+	
+	
+	
+	
+	
+	
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	public Humano[] getHumanos() {
+		return humanos;
+	}
+
+	public void setHumanos(Humano[] humanos) {
+		this.humanos = humanos;
+	}
+
+	public Malvado[] getMalvados() {
+		return malvados;
+	}
+
+	public void setMalvados(Malvado[] malvados) {
+		this.malvados = malvados;
+	}
+
+	public String toString() {
+		StringBuffer sb = new StringBuffer("Campo: " + this.nombre);
+		sb.append("\nHumanos: ");
+		for (int i = 0; i < humanos.length; i++) {
+			if (humanos[i].isVivo()) {
+				sb.append(humanos[i].getNombre() + ":" +
+						humanos[i].getPuntosVida() + ":" + 
+						humanos[i].isVivo() + " ");
+			}
+		}
+
+		sb.append("\nMalvados: ");
+		for (int i = 0; i < malvados.length; i++) {
+			if (malvados[i].isVivo()) {
+				sb.append(malvados[i].getNombre() + ":" +
+						malvados[i].getPuntosVida() + ":" + 
+						malvados[i].isVivo() + " ");
+			}
+		}
+
+		return sb.toString();
+	}
+	
+	
+}
+
+
+
+
+

src/tutorialJava/capitulo5/ej03_independenceDayConHerencia/Humano.java

@@ -0,0 +1,23 @@
+package tutorialJava.capitulo5.ej03_independenceDayConHerencia;
+
+import tutorialJava.Utils;
+
+public class Humano extends Personaje {
+
+	public int altura;
+	
+	public Humano() {
+		super();
+	}
+
+	public Humano(String nombre) {
+		super(nombre);
+	}
+
+	
+}
+
+
+
+
+

src/tutorialJava/capitulo5/ej03_independenceDayConHerencia/Malvado.java

@@ -0,0 +1,15 @@
+package tutorialJava.capitulo5.ej03_independenceDayConHerencia;
+
+import tutorialJava.Utils;
+
+public class Malvado extends Personaje {
+
+	public Malvado() {
+		super();
+	}
+
+	public Malvado(String nombre) {
+		super(nombre);
+	}
+
+}

src/tutorialJava/capitulo5/ej03_independenceDayConHerencia/Personaje.java

@@ -0,0 +1,64 @@
+package tutorialJava.capitulo5.ej03_independenceDayConHerencia;
+
+import tutorialJava.Utils;
+
+public class Personaje {
+
+	private int puntosVida;
+	private String nombre;
+	private boolean vivo;
+	
+	public Personaje() {
+		super();
+	}
+
+	
+	
+	public Personaje(String nombre) {
+		super();
+		this.puntosVida = Utils.obtenerNumeroAzar(50, 100);
+		this.nombre = nombre;
+		this.vivo = true;
+	}
+
+
+
+	public Personaje(int puntosVida, String nombre, boolean vivo) {
+		super();
+		this.puntosVida = puntosVida;
+		this.nombre = nombre;
+		this.vivo = vivo;
+	}
+
+	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 boolean isVivo() {
+		return vivo;
+	}
+
+	public void setVivo(boolean vivo) {
+		this.vivo = vivo;
+	}
+
+	@Override
+	public String toString() {
+		return "Personaje [puntosVida=" + puntosVida + ", nombre=" + nombre + ", vivo=" + vivo + "]";
+	}
+
+	
+
+}

src/tutorialJava/capitulo5/ej03_independenceDayConHerencia/Principal.java

@@ -0,0 +1,25 @@
+package tutorialJava.capitulo5.ej03_independenceDayConHerencia;
+
+import tutorialJava.Utils;
+
+public class Principal {
+
+	public static void main(String[] args) {
+		CampoBatalla campo = new CampoBatalla("Rute");
+		
+		campo.mezclaPersonajes(campo.getHumanos());
+		campo.mezclaPersonajes(campo.getMalvados());
+		System.out.println(campo.toString());
+		
+		campo.batalla();
+		
+	}
+
+}
+
+
+
+
+
+
+

src/tutorialJava/capitulo5/ej04_EjemploAbstraccionFiguras/Circulo.java

@@ -0,0 +1,21 @@
+package tutorialJava.capitulo5.ej04_EjemploAbstraccionFiguras;
+
+public class Circulo extends Figura {
+	
+	private float radio;
+	
+	public Circulo(float radio) {
+		this.radio = radio;
+	}
+
+	@Override
+	public float calcularArea() {
+		return (float) (Math.PI * this.radio * this.radio);
+	}
+
+	@Override
+	public float calcularPerimetro() {
+		return (float) (2 * Math.PI * this.radio);
+	}
+
+}

src/tutorialJava/capitulo5/ej04_EjemploAbstraccionFiguras/Figura.java

@@ -0,0 +1,12 @@
+package tutorialJava.capitulo5.ej04_EjemploAbstraccionFiguras;
+
+public abstract class Figura {
+
+	public abstract float calcularArea();
+	public abstract float calcularPerimetro();
+	
+	public String toString() {
+		return "Área: " + calcularArea() + 
+				" - Perímetro: " + calcularPerimetro();
+	}
+}

src/tutorialJava/capitulo5/ej04_EjemploAbstraccionFiguras/Principal.java

@@ -0,0 +1,18 @@
+package tutorialJava.capitulo5.ej04_EjemploAbstraccionFiguras;
+
+public class Principal {
+
+
+	public static void main(String[] args) {
+		
+		Figura figuras[] = new Figura[2]; 
+		figuras[0] = new Circulo(1.4f);
+		figuras[1] = new Rectangulo(2, 4);
+		
+		for (int i = 0; i < figuras.length; i++) {
+			System.out.println(figuras[i].toString());
+		}
+		
+	}
+
+}

src/tutorialJava/capitulo5/ej04_EjemploAbstraccionFiguras/Rectangulo.java

@@ -0,0 +1,23 @@
+package tutorialJava.capitulo5.ej04_EjemploAbstraccionFiguras;
+
+public class Rectangulo extends Figura {
+
+	private float base;
+	private float altura;
+	
+	public Rectangulo(float base, float altura) {
+		this.base = base;
+		this.altura = altura;
+	}
+
+	@Override
+	public float calcularArea() {
+		return this.base * this.altura;
+	}
+
+	@Override
+	public float calcularPerimetro() {
+		return 2 * this.base + 2 * this.altura;
+	}
+
+}

src/tutorialJava/capitulo5/ej05_EjemploUsoVariableEstatica/Principal.java

@@ -0,0 +1,12 @@
+package tutorialJava.capitulo5.ej05_EjemploUsoVariableEstatica;
+
+public class Principal {
+
+	public static void main(String[] args) {
+		for (int i = 0; i < 100; i++) {
+			Usuario u = new Usuario();
+			System.out.println(u.toString());
+		}
+	}
+
+}

src/tutorialJava/capitulo5/ej05_EjemploUsoVariableEstatica/Usuario.java

@@ -0,0 +1,29 @@
+package tutorialJava.capitulo5.ej05_EjemploUsoVariableEstatica;
+
+public class Usuario {
+
+	private static int CONTADOR_USUARIOS = 1;
+	private String id;
+
+	public Usuario() {
+		super();
+		this.id = "Usuario_" + CONTADOR_USUARIOS;
+		CONTADOR_USUARIOS++;
+	}
+
+
+	public String getId() {
+		return id;
+	}
+
+	public void setId(String id) {
+		this.id = id;
+	}
+
+	@Override
+	public String toString() {
+		return "Usuario [id=" + id + "]";
+	}
+	
+	
+}

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/ejercicios/bloque01_ArrayPersonas/Persona.java

@@ -0,0 +1,82 @@
+package tutorialJava.capitulo5.ejercicios.bloque01_ArrayPersonas;
+
+public class Persona {
+
+	private String nombre;
+	private String apellidos;
+	private String dni;
+	private String direccion;
+	private String telefono;
+	
+	
+	public Persona() {
+		
+	}
+
+
+	public Persona(String nombre, String apellidos, String dni, String direccion, String telefono) {
+		super();
+		this.nombre = nombre;
+		this.apellidos = apellidos;
+		this.dni = dni;
+		this.direccion = direccion;
+		this.telefono = telefono;
+	}
+
+
+	public String getNombre() {
+		return nombre;
+	}
+
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+
+	public String getApellidos() {
+		return apellidos;
+	}
+
+
+	public void setApellidos(String apellidos) {
+		this.apellidos = apellidos;
+	}
+
+
+	public String getDni() {
+		return dni;
+	}
+
+
+	public void setDni(String dni) {
+		this.dni = dni;
+	}
+
+
+	public String getDireccion() {
+		return direccion;
+	}
+
+
+	public void setDireccion(String direccion) {
+		this.direccion = direccion;
+	}
+
+
+	public String getTelefono() {
+		return telefono;
+	}
+
+
+	public void setTelefono(String telefono) {
+		this.telefono = telefono;
+	}
+
+
+	@Override
+	public String toString() {
+		return "Persona [nombre=" + nombre + ", apellidos=" + apellidos + ", dni=" + dni + ", direccion=" + direccion
+				+ ", telefono=" + telefono + "]";
+	}
+}

src/tutorialJava/capitulo5/ejercicios/bloque01_ArrayPersonas/Principal.java

@@ -0,0 +1,63 @@
+package tutorialJava.capitulo5.ejercicios.bloque01_ArrayPersonas;
+
+import java.util.Scanner;
+
+public class Principal {
+
+	private static Persona personas[] = new Persona[3];
+	
+
+	public static void main(String[] args) {
+		int opcion = 0;
+		Scanner sc = new Scanner(System.in);
+		
+		do {
+			opcion = muestraMenu();
+			
+			switch (opcion) {
+			case 1:
+				for (int i = 0; i < personas.length; i++) {
+					personas[i] = new Persona();
+					System.out.println("Introduzca nombre de persona");
+					personas[i].setNombre(sc.nextLine());
+					System.out.println("Introduzca apellidos de persona");
+					personas[i].setApellidos(sc.nextLine());
+					System.out.println("Introduzca dni de persona");
+					personas[i].setDni(sc.nextLine());
+					System.out.println("Introduzca dirección de persona");
+					personas[i].setDireccion(sc.nextLine());
+					System.out.println("Introduzca telefono de persona");
+					personas[i].setTelefono(sc.nextLine());
+				}
+				
+				break;		
+			case 2:
+				for (int i = 0; i < personas.length; i++) {
+					System.out.println(personas[i].toString());
+				}
+				break;
+			}
+			
+		} while (opcion != 0);
+		
+	}
+
+	/*
+	 * 
+	 */
+	public static int muestraMenu() {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("\n\nMenú" +
+				"\n0.- Salir" +
+				"\n1.- Introducir datos" +
+				"\n2.- Visualizar datos" +
+				"\n\tIntroduzca su opción: ");
+		return Integer.parseInt(sc.nextLine());
+	}
+	
+}
+
+
+
+
+

src/tutorialJava/capitulo5/ejercicios/bloque02/articulosComestibles/ArtNoPerecedero.java

@@ -0,0 +1,14 @@
+package tutorialJava.capitulo5.ejercicios.bloque02.articulosComestibles;
+
+public class ArtNoPerecedero extends Articulo {
+
+	public ArtNoPerecedero() {
+		// TODO Auto-generated constructor stub
+	}
+
+	public ArtNoPerecedero(String codigo, String nombre, float precio) {
+		super(codigo, nombre, precio);
+		// TODO Auto-generated constructor stub
+	}
+
+}

src/tutorialJava/capitulo5/ejercicios/bloque02/articulosComestibles/ArtPerecedero.java

@@ -0,0 +1,29 @@
+package tutorialJava.capitulo5.ejercicios.bloque02.articulosComestibles;
+
+public class ArtPerecedero extends Articulo {
+
+	private String fechaCaducidad;
+	
+	public ArtPerecedero() {
+	}
+
+	public ArtPerecedero(String codigo, String nombre, float precio) {
+		super(codigo, nombre, precio);
+	}
+
+	public String getFechaCaducidad() {
+		return fechaCaducidad;
+	}
+
+	public void setFechaCaducidad(String fechaCaducidad) {
+		this.fechaCaducidad = fechaCaducidad;
+	}
+
+	@Override
+	public String toString() {
+		return "ArtPerecedero [fechaCaducidad=" + fechaCaducidad + ", getCodigo()=" + getCodigo() + ", getNombre()="
+				+ getNombre() + ", getPrecio()=" + getPrecio() + "]";
+	}
+
+	
+}

src/tutorialJava/capitulo5/ejercicios/bloque02/articulosComestibles/Articulo.java

@@ -0,0 +1,48 @@
+package tutorialJava.capitulo5.ejercicios.bloque02.articulosComestibles;
+
+public class Articulo {
+
+	private String codigo;
+	private String nombre;
+	private float precio;
+	
+	public Articulo() {
+	}
+
+	public Articulo(String codigo, String nombre, float precio) {
+		super();
+		this.codigo = codigo;
+		this.nombre = nombre;
+		this.precio = precio;
+	}
+
+	public String getCodigo() {
+		return codigo;
+	}
+
+	public void setCodigo(String codigo) {
+		this.codigo = codigo;
+	}
+
+	public String getNombre() {
+		return nombre;
+	}
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	public float getPrecio() {
+		return precio;
+	}
+
+	public void setPrecio(float precio) {
+		this.precio = precio;
+	}
+
+	@Override
+	public String toString() {
+		return "Articulo [codigo=" + codigo + ", nombre=" + nombre + ", precio=" + precio + "]";
+	}
+
+}

src/tutorialJava/capitulo5/ejercicios/bloque02/articulosComestibles/Tienda.java

@@ -0,0 +1,48 @@
+package tutorialJava.capitulo5.ejercicios.bloque02.articulosComestibles;
+
+import tutorialJava.Utils;
+
+public class Tienda {
+
+	public Tienda() {
+	}	
+	
+	public static void main(String args[]) {
+		Articulo articulos[] = new Articulo[4];
+		
+		for (int i = 0; i < articulos.length; i++) {
+			if (i < 2) {
+				System.out.println("Introduzca datos de Art perecedero: ");
+				ArtPerecedero artPer = new ArtPerecedero();
+				artPer.setCodigo(Utils.
+						obtenerCadenaConDescripcion("Dame código:"));
+				artPer.setNombre(Utils.
+						obtenerCadenaConDescripcion("Dame nombre:"));
+				artPer.setPrecio(Utils.
+						pideNumeroFloat("Dame precio"));
+				artPer.setFechaCaducidad(Utils.
+						obtenerCadenaConDescripcion("Dame fecha caducidad:"));
+				articulos[i] = artPer;
+			}
+			else {
+				System.out.println("Introduzca datos de Art perecedero: ");
+				ArtNoPerecedero artNoPer = new ArtNoPerecedero();
+				artNoPer.setCodigo(Utils.
+						obtenerCadenaConDescripcion("Dame código:"));
+				artNoPer.setNombre(Utils.
+						obtenerCadenaConDescripcion("Dame nombre:"));
+				artNoPer.setPrecio(Utils.
+						pideNumeroFloat("Dame precio"));
+				articulos[i] = artNoPer;
+			}
+		}
+		
+		// Muestro los valores
+		for (int i = 0; i < articulos.length; i++) {
+			System.out.println(articulos[i].toString());
+		}
+	}
+}
+
+
+

src/tutorialJava/capitulo5/ejercicios/bloque02/coleccionAntiguedades/Antiguedad.java

@@ -0,0 +1,50 @@
+package tutorialJava.capitulo5.ejercicios.bloque02.coleccionAntiguedades;
+
+public class Antiguedad {
+
+	private int anio;
+	private String origen;
+	private float precio;
+	
+	public Antiguedad() {
+	}
+
+	public Antiguedad(int anio, String origen, float precio) {
+		super();
+		this.anio = anio;
+		this.origen = origen;
+		this.precio = precio;
+	}
+
+	public int getAnio() {
+		return anio;
+	}
+
+	public void setAnio(int anio) {
+		this.anio = anio;
+	}
+
+	public String getOrigen() {
+		return origen;
+	}
+
+	public void setOrigen(String origen) {
+		this.origen = origen;
+	}
+
+	public float getPrecio() {
+		return precio;
+	}
+
+	public void setPrecio(float precio) {
+		this.precio = precio;
+	}
+
+	@Override
+	public String toString() {
+		return "Antiguedad [anio=" + anio + ", origen=" + origen + ", precio=" + precio + "]";
+	}
+
+	
+	
+}

src/tutorialJava/capitulo5/ejercicios/bloque02/coleccionAntiguedades/Joya.java

@@ -0,0 +1,28 @@
+package tutorialJava.capitulo5.ejercicios.bloque02.coleccionAntiguedades;
+
+public class Joya extends Antiguedad {
+
+	private String material;
+	
+	public Joya() {
+	}
+
+	public Joya(int anio, String origen, float precio) {
+		super(anio, origen, precio);
+	}
+
+	public String getMaterial() {
+		return material;
+	}
+
+	public void setMaterial(String material) {
+		this.material = material;
+	}
+
+	@Override
+	public String toString() {
+		return super.toString() + " material: " + this.material;
+	}
+
+	
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/instrumentos/Bateria.java

@@ -0,0 +1,12 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.instrumentos;
+
+class Bateria extends Instrumento {
+    public Bateria(String nombre) {
+        super(nombre);
+    }
+
+    @Override
+    public void tocar() {
+        System.out.println(nombre + " (Batería): Marcando el ritmo con tambores");
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/instrumentos/Guitarra.java

@@ -0,0 +1,12 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.instrumentos;
+
+class Guitarra extends Instrumento {
+    public Guitarra(String nombre) {
+        super(nombre);
+    }
+
+    @Override
+    public void tocar() {
+        System.out.println(nombre + " (Guitarra): Tocando acordes de rock");
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/instrumentos/Instrumento.java

@@ -0,0 +1,12 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.instrumentos;
+
+abstract class Instrumento {
+    protected String nombre;
+
+    public Instrumento(String nombre) {
+        this.nombre = nombre;
+    }
+
+    // Método abstracto
+    public abstract void tocar();
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/instrumentos/Piano.java

@@ -0,0 +1,12 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.instrumentos;
+
+class Piano extends Instrumento {
+    public Piano(String nombre) {
+        super(nombre);
+    }
+
+    @Override
+    public void tocar() {
+        System.out.println(nombre + " (Piano): Tocando una melodía clásica");
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/instrumentos/Principal.java

@@ -0,0 +1,18 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.instrumentos;
+
+public class Principal {
+    public static void main(String[] args) {
+        // Crear una lista de instrumentos
+        Instrumento[] instrumentos = new Instrumento[] {
+            new Guitarra("Fender Stratocaster"),
+            new Piano("Yamaha U1"),
+            new Bateria("Pearl Export"),
+            new Guitarra("Gibson Les Paul")
+        };
+
+        // Recorrer la lista y llamar al método tocar() de cada instrumento
+        for (Instrumento instrumento : instrumentos) {
+            instrumento.tocar();
+        }
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/sonidosAnimales/Animal.java

@@ -0,0 +1,27 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.sonidosAnimales;
+
+abstract class Animal {
+    protected String nombre;
+
+    public Animal(String nombre) {
+        this.nombre = nombre;
+    }
+
+    // Método abstracto
+    public abstract void emitirSonido();
+
+    public String getNombre() {
+        return nombre;
+    }
+
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+
+	@Override
+	public String toString() {
+		return "Animal [nombre=" + nombre + "]";
+	}
+    
+    
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/sonidosAnimales/Gato.java

@@ -0,0 +1,12 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.sonidosAnimales;
+
+class Gato extends Animal {
+    public Gato(String nombre) {
+        super(nombre);
+    }
+
+    @Override
+    public void emitirSonido() {
+        System.out.println(nombre + " dice: ¡Miau, miau!");
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/sonidosAnimales/Perro.java

@@ -0,0 +1,12 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.sonidosAnimales;
+
+class Perro extends Animal {
+    public Perro(String nombre) {
+        super(nombre);
+    }
+
+    @Override
+    public void emitirSonido() {
+        System.out.println(nombre + " dice: ¡Guau, guau!");
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/sonidosAnimales/Principal.java

@@ -0,0 +1,22 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.sonidosAnimales;
+
+public class Principal {
+    public static void main(String[] args) {
+    	
+    	int a[] = new int[] {1, 2, 3};
+    	
+        // Crear un array de tipo Animal
+        Animal[] animales = new Animal[] {
+            new Perro("Max"),
+            new Gato("Luna"),
+            new Perro("Buddy"),
+            new Gato("Mimi")
+        };
+
+        // Llamar al método emitirSonido() para cada animal
+        for (Animal animal : animales) {
+            System.out.println("Animal: ");
+            animal.emitirSonido();
+        }
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/vehiculos/Bicicleta.java

@@ -0,0 +1,19 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.vehiculos;
+
+class Bicicleta extends Vehiculo {
+    public Bicicleta(String modelo) {
+        super(modelo);
+    }
+
+    @Override
+    public void acelerar() {
+        velocidadActual += 5; // Incrementa velocidad en 5
+        System.out.println(modelo + " (Bicicleta) acelera a " + velocidadActual + " km/h");
+    }
+
+    @Override
+    public void frenar() {
+        velocidadActual = Math.max(0, velocidadActual - 3); // Reduce velocidad en 3
+        System.out.println(modelo + " (Bicicleta) frena a " + velocidadActual + " km/h");
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/vehiculos/Coche.java

@@ -0,0 +1,19 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.vehiculos;
+
+class Coche extends Vehiculo {
+    public Coche(String modelo) {
+        super(modelo);
+    }
+
+    @Override
+    public void acelerar() {
+        velocidadActual += 20; // Incrementa velocidad en 20
+        System.out.println(modelo + " (Coche) acelera a " + velocidadActual + " km/h");
+    }
+
+    @Override
+    public void frenar() {
+        velocidadActual = Math.max(0, velocidadActual - 15); // Reduce velocidad en 15
+        System.out.println(modelo + " (Coche) frena a " + velocidadActual + " km/h");
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/vehiculos/Principal.java

@@ -0,0 +1,22 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.vehiculos;
+
+public class Principal {
+    public static void main(String[] args) {
+        // Crear instancias de vehículos
+        Vehiculo[] vehiculos = new Vehiculo[] {
+            new Coche("Toyota Corolla"),
+            new Bicicleta("BMX Pro"),
+            new Coche("Ford Mustang"),
+            new Bicicleta("Mountain Bike")
+        };
+
+        // Simular la aceleración y el frenado
+        for (Vehiculo vehiculo : vehiculos) {
+            System.out.println("Vehículo: " + vehiculo.getModelo());
+            vehiculo.acelerar();
+            vehiculo.acelerar();
+            vehiculo.frenar();
+            System.out.println("------------------------");
+        }
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque03_clasesYMetodosAbstractos/vehiculos/Vehiculo.java

@@ -0,0 +1,38 @@
+package tutorialJava.capitulo5.ejercicios.bloque03_clasesYMetodosAbstractos.vehiculos;
+
+abstract class Vehiculo {
+    protected int velocidadActual;
+    protected String modelo;
+
+    public Vehiculo(String modelo) {
+        this.modelo = modelo;
+        this.velocidadActual = 0; // La velocidad inicial es 0
+    }
+
+    // Métodos abstractos
+    public abstract void acelerar();
+    public abstract void frenar();
+
+    public int getVelocidadActual() {
+        return velocidadActual;
+    }
+
+    public String getModelo() {
+        return modelo;
+    }
+
+	public void setVelocidadActual(int velocidadActual) {
+		this.velocidadActual = velocidadActual;
+	}
+
+	public void setModelo(String modelo) {
+		this.modelo = modelo;
+	}
+
+	@Override
+	public String toString() {
+		return "Vehiculo [velocidadActual=" + velocidadActual + ", modelo=" + modelo + "]";
+	}
+    
+    
+}

src/tutorialJava/capitulo5/ejercicios/bloque04_instanciasVsStatic/banco/Banco.java

@@ -0,0 +1,16 @@
+package tutorialJava.capitulo5.ejercicios.bloque04_instanciasVsStatic.banco;
+
+public class Banco {
+    private static double tasaDeInteres = 2.5; // Tasa de interés inicial (porcentaje)
+
+    // Método estático para cambiar la tasa de interés
+    public static void cambiarTasaDeInteres(double nuevaTasa) {
+        tasaDeInteres = nuevaTasa;
+        System.out.println("La nueva tasa de interés es: " + tasaDeInteres + "%");
+    }
+
+    // Método estático para obtener la tasa de interés
+    public static double obtenerTasaDeInteres() {
+        return tasaDeInteres;
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque04_instanciasVsStatic/banco/Cuenta.java

@@ -0,0 +1,24 @@
+package tutorialJava.capitulo5.ejercicios.bloque04_instanciasVsStatic.banco;
+
+class Cuenta {
+    private String titular;
+    private double saldo;
+
+    // Constructor
+    public Cuenta(String titular, double saldo) {
+        this.titular = titular;
+        this.saldo = saldo;
+    }
+
+    // Método para calcular el interés basado en la tasa actual
+    public double calcularInteres() {
+        return saldo * Banco.obtenerTasaDeInteres() / 100;
+    }
+
+    // Método para mostrar información de la cuenta
+    public void mostrarInformacion() {
+        System.out.println("Titular: " + titular);
+        System.out.println("Saldo: " + saldo);
+        System.out.println("Interés generado: " + calcularInteres());
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque04_instanciasVsStatic/banco/Principal.java

@@ -0,0 +1,22 @@
+package tutorialJava.capitulo5.ejercicios.bloque04_instanciasVsStatic.banco;
+
+public class Principal {
+    public static void main(String[] args) {
+        // Crear cuentas
+        Cuenta cuenta1 = new Cuenta("Juan Pérez", 5000);
+        Cuenta cuenta2 = new Cuenta("Ana López", 10000);
+
+        // Calcular intereses con la tasa inicial
+        System.out.println("Intereses con la tasa inicial:");
+        cuenta1.mostrarInformacion();
+        cuenta2.mostrarInformacion();
+
+        // Cambiar la tasa de interés
+        Banco.cambiarTasaDeInteres(3.5);
+
+        // Calcular intereses con la nueva tasa
+        System.out.println("\nIntereses con la nueva tasa:");
+        cuenta1.mostrarInformacion();
+        cuenta2.mostrarInformacion();
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque04_instanciasVsStatic/productos/Principal.java

@@ -0,0 +1,20 @@
+package tutorialJava.capitulo5.ejercicios.bloque04_instanciasVsStatic.productos;
+
+public class Principal {
+    public static void main(String[] args) {
+        // Crear instancias de Producto
+        Producto p1 = new Producto("Producto A");
+        Producto p2 = new Producto("Producto B");
+        Producto p3 = new Producto("Producto C");
+
+        // Verificar el valor del contador
+        System.out.println("Número total de productos creados: " + 
+        		Producto.obtenerContador());
+
+        // Mostrar nombres de los productos
+        System.out.println("Productos creados:");
+        System.out.println(p1.getNombre());
+        System.out.println(p2.getNombre());
+        System.out.println(p3.getNombre());
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque04_instanciasVsStatic/productos/Producto.java

@@ -0,0 +1,22 @@
+package tutorialJava.capitulo5.ejercicios.bloque04_instanciasVsStatic.productos;
+
+public class Producto {
+    private static int CONTADOR = 0; // Contador estático de instancias
+    private String nombre;
+
+    // Constructor
+    public Producto(String nombre) {
+        this.nombre = nombre;
+        CONTADOR++; // Incrementar el contador cada vez que se crea una instancia
+    }
+
+    // Método estático para obtener el contador
+    public static int obtenerContador() {
+        return CONTADOR;
+    }
+
+    // Método para obtener el nombre del producto
+    public String getNombre() {
+        return nombre;
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque04_instanciasVsStatic/usuarios/Principal.java

@@ -0,0 +1,25 @@
+package tutorialJava.capitulo5.ejercicios.bloque04_instanciasVsStatic.usuarios;
+
+public class Principal {
+    public static void main(String[] args) {
+        // Crear usuarios
+        Usuario usuario1 = new Usuario("Alicia");
+        Usuario usuario2 = new Usuario("Juan");
+        Usuario usuario3 = new Usuario("Mafalda");
+
+        // Mostrar el total de usuarios registrados
+        System.out.println("Total de usuarios registrados: " + Usuario.obtenerTotalUsuarios());
+
+        // Eliminar un usuario
+        usuario2.eliminarUsuario();
+
+        // Mostrar el total de usuarios después de la eliminación
+        System.out.println("Total de usuarios registrados: " + Usuario.obtenerTotalUsuarios());
+
+        // Eliminar otro usuario
+        usuario1.eliminarUsuario();
+
+        // Mostrar el total de usuarios después de otra eliminación
+        System.out.println("Total de usuarios registrados: " + Usuario.obtenerTotalUsuarios());
+    }
+}

src/tutorialJava/capitulo5/ejercicios/bloque04_instanciasVsStatic/usuarios/Usuario.java

@@ -0,0 +1,33 @@
+package tutorialJava.capitulo5.ejercicios.bloque04_instanciasVsStatic.usuarios;
+
+public class Usuario {
+    private static int totalUsuarios = 0; // Contador estático para total de usuarios
+    private String nombre;
+
+    // Constructor
+    public Usuario(String nombre) {
+        this.nombre = nombre;
+        totalUsuarios++; // Incrementar contador al crear un usuario
+        System.out.println("Usuario registrado: " + nombre);
+    }
+
+    // Método para eliminar un usuario
+    public void eliminarUsuario() {
+        if (totalUsuarios > 0) {
+            totalUsuarios--; // Decrementar contador al eliminar un usuario
+            System.out.println("Usuario eliminado: " + nombre);
+        } else {
+            System.out.println("No hay usuarios registrados para eliminar.");
+        }
+    }
+
+    // Método estático para obtener el total de usuarios
+    public static int obtenerTotalUsuarios() {
+        return totalUsuarios;
+    }
+
+    // Método para obtener el nombre del usuario
+    public String getNombre() {
+        return nombre;
+    }
+}

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,52 @@
+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)); // Deprecado
+			numeros.add(Integer.valueOf(100 + i));
+//			numeros.add(100 + i); // Creación de Integer por defecto
+		}
+		
+		// Agrego un elemento
+		numeros.add(1000);
+		
+		// Elimino un elemento
+		numeros.remove(Integer.valueOf(102));
+
+		// Inserto un elemento en una posición concreta
+		numeros.add(2, 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("");
+	}
+
+}