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

@@ -114,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.
@@ -143,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/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/bloque02/articulosComestibles/ArtNoPerecedero.java

@@ -1,4 +1,4 @@
-package tutorialJava.capitulo5.ejercicios.bloque02_articulosComestibles;
+package tutorialJava.capitulo5.ejercicios.bloque02.articulosComestibles;
 
 public class ArtNoPerecedero extends Articulo {
 

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

@@ -1,4 +1,4 @@
-package tutorialJava.capitulo5.ejercicios.bloque02_articulosComestibles;
+package tutorialJava.capitulo5.ejercicios.bloque02.articulosComestibles;
 
 public class ArtPerecedero extends Articulo {
 

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

@@ -1,4 +1,4 @@
-package tutorialJava.capitulo5.ejercicios.bloque02_articulosComestibles;
+package tutorialJava.capitulo5.ejercicios.bloque02.articulosComestibles;
 
 public class Articulo {
 

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

@@ -1,4 +1,4 @@
-package tutorialJava.capitulo5.ejercicios.bloque02_articulosComestibles;
+package tutorialJava.capitulo5.ejercicios.bloque02.articulosComestibles;
 
 import tutorialJava.Utils;
 

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

@@ -1,4 +1,4 @@
-package tutorialJava.capitulo5.ejercicios.bloque02_ColeccionAntiguedades;
+package tutorialJava.capitulo5.ejercicios.bloque02.coleccionAntiguedades;
 
 public class Antiguedad {
 

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

@@ -1,4 +1,4 @@
-package tutorialJava.capitulo5.ejercicios.bloque02_ColeccionAntiguedades;
+package tutorialJava.capitulo5.ejercicios.bloque02.coleccionAntiguedades;
 
 public class Joya extends Antiguedad {
 

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("");
+	}
+
+}

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

@@ -0,0 +1,34 @@
+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,42 @@
+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(c3);
+		
+		for (CromoBaloncesto c : lista) {
+			System.out.println(c.getNombre());
+		}
+		
+		CromoBaloncesto c4 = new CromoBaloncesto(4, "Araceli Pacheco");
+		CromoBaloncesto c5 = new CromoBaloncesto(5, "María Jesús Joyanes");
+		CromoBaloncesto c6 = new CromoBaloncesto(6, "Candela Écija");
+
+		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,73 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo02_HashMap;
+
+import java.util.HashMap;
+import java.util.Iterator;
+
+public class EjemploHashMap {
+
+	/**
+	 * 
+	 */
+	private static void ejemploHashMapGeneral () {
+		// Creació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érez Pérez", "José"));
+		hm.put("2", new Persona ("22222222A", "Muñoz Muñ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érida Lérida", "Lucía"));
+		
+		// Recuperación de datos en un HashMap general
+		System.out.println("Objeto con id 1: " + hm.get("1"));  // Recuperación de un solo objeto
+		
+		// Inserción de un objeto con un tipo de identificador diferente
+		hm.put(6, new Persona ("66666666A", "Ramírez Ramírez", "Ramiro"));		
+		
+		// Recuperació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ón de un HashMap general
+		HashMap<String, Persona> hm = new HashMap<String, Persona>();
+		
+		// Inserción de datos en un HashMap general
+		hm.put("1", new Persona ("11111111A", "Pérez Pérez", "José"));
+		hm.put("2", new Persona ("22222222A", "Muñoz Muñ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érida Lérida", "Lucía"));
+
+		// Eliminación de algún elemento en el HM
+		hm.remove("5");
+		
+		// Recuperació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/capitulo6_ColeccionesDeDatos/ejercicios/bloque01_listas/Ejercicio01_ListasConInteger.java

@@ -0,0 +1,125 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejercicios.bloque01_listas;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import tutorialJava.Utils;
+
+public class Ejercicio01_ListasConInteger {
+
+	private static List<Integer> enteros = new ArrayList<Integer>();
+	
+	
+	public static void main(String[] args) {
+		int opcionMenu = 0, posicionAInsertar;
+		
+		do {
+			opcionMenu = mostrarMenu();
+			
+			switch(opcionMenu) {
+			case 1: // Crear aleatoriamente la lista de valores
+				enteros.clear();
+				enteros.addAll(creaLista());
+				break;
+			case 2: // suma, media, mayor y menor
+				calculaSumaMediaMayorMenor();
+				break;
+			case 3: // agregar una nueva cantidad de valores
+				posicionAInsertar = Utils.obtenerEnteroConDescripcion("Dime la posición a "
+						+ "insertar los nuevos valores en la lista");
+				enteros.addAll(posicionAInsertar, creaLista());
+				break;
+			case 4: // Eliminar elementos dentro de un intervalo
+				int eliminados = eliminarElementosEnIntervalo(
+						Utils.obtenerEnteroConDescripcion("Dame un mínimo para eliminar: "), 
+						Utils.obtenerEnteroConDescripcion("Dame un máximo para eliminar: "));
+				System.out.println("Se han eliminado: " + eliminados);
+				break;
+			case 5: // Imprime la lista
+				for (Integer e : enteros) {
+					System.out.print(e.intValue() + " ");
+				}
+				System.out.println();
+			}
+		} while(opcionMenu != 0);
+
+	}
+
+	
+	/**
+	 * Este método....... 
+	 * @param min Este parámetro....
+	 * @param max
+	 */
+	private static int eliminarElementosEnIntervalo (int min, int max) {
+		int contEliminados = 0;
+		for (int i = enteros.size()-1; i > -1 ; i--) {
+			if (enteros.get(i).intValue() > min && enteros.get(i).intValue() < max) {
+				enteros.remove(i);
+				contEliminados++;
+			}
+		}
+		return contEliminados;
+	}
+	
+	/**
+	 * 
+	 */
+	private static void calculaSumaMediaMayorMenor () {
+		int suma = 0;
+		int mayor = enteros.get(0).intValue();
+		int menor = enteros.get(0).intValue();
+		
+		for (Integer entero : enteros) {
+			suma += entero.intValue();
+			if (entero.intValue() > mayor) {
+				mayor = entero.intValue();
+			}
+			if (entero.intValue() < menor) {
+				menor = entero.intValue();
+			}
+		}
+		
+		System.out.println("La suma vale: " + suma);
+		System.out.println("La media vale: " + (suma / (float) enteros.size()) );
+		System.out.println("El menor es: " + menor);
+		System.out.println("El mayor es: " + mayor);
+	}
+	
+
+	
+	
+	
+	/**
+	 * 
+	 */
+	private static List<Integer> creaLista () {
+		List<Integer> lista = new ArrayList<Integer>();
+		int longitud = Utils.obtenerEnteroConDescripcion("Dame la longitud de la lista: ");
+		int max = Utils.obtenerEnteroConDescripcion("Valor máximo: ");
+		int min = Utils.obtenerEnteroConDescripcion("Valor mínimo: ");
+		
+		for (int i = 0; i < longitud; i++) {
+			lista.add(Utils.obtenerNumeroAzar(min, max));
+		}
+		return lista;
+	}
+	
+	/**
+	 * 
+	 * @return
+	 */
+	private static int mostrarMenu() {
+		System.out.println("MENÚ DEL PROGRAMA");
+		System.out.println("0.- Abandonar programa");
+		System.out.println("1.- Crear aleatoriamente lista de valores");
+		System.out.println("2.- Calcular suma, media, mínimo y máximo.");
+		System.out.println("3.- Agregar cantidad nuevos valores");
+		System.out.println("4.- Eliminar elementos en un intervalo");
+		System.out.println("5.- Imprimir lista");
+		
+		System.out.println("Escribe la opción (0-5):");
+		return new Scanner(System.in).nextInt();
+	}
+}

src/tutorialJava/capitulo6_ColeccionesDeDatos/ejercicios/bloque01_listas/FicheroTextoConListaDeStrings.java

@@ -0,0 +1,93 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejercicios.bloque01_listas;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+import tutorialJava.Utils;
+
+public class FicheroTextoConListaDeStrings {
+
+	private static List<String> fichero = new ArrayList<String>();
+	private static List<String> portapapeles = new ArrayList<String>();
+	
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		int opcion;
+		
+		do {
+			opcion = mostrarMenu();
+			
+			switch (opcion) {
+			case 1: // Agregar una línea al final del fichero
+				fichero.add(Utils.obtenerCadenaConDescripcion("Inserte la nueva línea: "));
+				break;
+			case 2: // Insertar una línea en cualquier lugar del fichero
+				fichero.add(
+						Utils.obtenerEnteroConDescripcion("Dame una posición para insertar la línea:"), 
+						Utils.obtenerCadenaConDescripcion("Dame la nueva línea: "));
+				break;
+			case 3: // Editar una línea
+				int posicionAEditar = Utils.obtenerEnteroConDescripcion("Posición a editar: ");
+				fichero.remove(posicionAEditar);
+				fichero.add(
+						posicionAEditar, 
+						Utils.obtenerCadenaConDescripcion("Dame la nueva línea: "));
+				break;
+			case 4: // elimiar una línea
+				fichero.remove(Utils.obtenerEnteroConDescripcion("Indica la línea a eliminar: "));
+				break;
+			case 5: // Llevar al portapapeles un conjunto de líneas
+				int lineaIni = Utils.obtenerEnteroConDescripcion("Primera línea a cortar: ");
+				int lineaFin = Utils.obtenerEnteroConDescripcion("Última línea a cortar: ");
+				
+				portapapeles.clear();
+				for (int i = lineaIni; i <= lineaFin; i++) {
+					portapapeles.add(fichero.get(lineaIni));
+					fichero.remove(lineaIni);
+				}
+				break;
+			case 6:
+				fichero.addAll(
+						Utils.obtenerEnteroConDescripcion("Indica dónde quieres insertar "
+								+ "las linás cortadas: "),
+						portapapeles);
+				break;
+			case 7: // Ver el fichero
+				System.out.println("Contenido del fichero: ");
+				for (String linea : fichero) {
+					System.out.println(linea);
+				}
+				System.out.println("\n");
+								
+				break;
+			}
+		} while (opcion != 0);
+
+	}
+
+	
+	
+	/**
+	 * 
+	 * @return
+	 */
+	private static int mostrarMenu() {
+		System.out.println("MENÚ DEL PROGRAMA");
+		System.out.println("0.- Abandonar programa");
+		System.out.println("1.- Agregar una línea al texto");
+		System.out.println("2.- Insertar una línea en cualquier posición del texto.");
+		System.out.println("3.- Editar una línea (reescribir su contenido)");
+		System.out.println("4.- Borrar una línea");
+		System.out.println("5.- Cortar un conjunto de líneas, (marcadas por su posición inicial y final).");
+		System.out.println("6.- Pegar un conjunto de líneas, (marcadas por su posición).");
+		System.out.println("7.- Imprimir el fichero");
+		
+		System.out.println("Escribe la opción (0-7):");
+		return new Scanner(System.in).nextInt();
+	}
+
+}

src/tutorialJava/capitulo6_ColeccionesDeDatos/ejercicios/bloque02_Hashmap/Articulo.java

@@ -0,0 +1,65 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejercicios.bloque02_Hashmap;
+
+public class Articulo {
+
+	private String nombre;
+	private int codigoDeBarras;
+	private int numeroDeEstante;
+	private int stock;
+
+	
+	
+	/**
+	 * 
+	 */
+	public Articulo() {
+		super();
+	}
+
+	/**
+	 * @param nombre
+	 * @param codigoDeBarras
+	 * @param numeroDeEstante
+	 * @param stock
+	 */
+	public Articulo(String nombre, int codigoDeBarras, int numeroDeEstante, int stock) {
+		super();
+		this.nombre = nombre;
+		this.codigoDeBarras = codigoDeBarras;
+		this.numeroDeEstante = numeroDeEstante;
+		this.stock = stock;
+	}
+	
+	public String getNombre() {
+		return nombre;
+	}
+	public void setNombre(String nombre) {
+		this.nombre = nombre;
+	}
+	public int getCodigoDeBarras() {
+		return codigoDeBarras;
+	}
+	public void setCodigoDeBarras(int codigoDeBarras) {
+		this.codigoDeBarras = codigoDeBarras;
+	}
+	public int getNumeroDeEstante() {
+		return numeroDeEstante;
+	}
+	public void setNumeroDeEstante(int numeroDeEstante) {
+		this.numeroDeEstante = numeroDeEstante;
+	}
+	public int getStock() {
+		return stock;
+	}
+	public void setStock(int stock) {
+		this.stock = stock;
+	}
+
+	@Override
+	public String toString() {
+		return "Articulo [nombre=" + nombre + ", codigoDeBarras=" + codigoDeBarras + ", numeroDeEstante="
+				+ numeroDeEstante + ", stock=" + stock + "]";
+	}
+	
+
+}

src/tutorialJava/capitulo6_ColeccionesDeDatos/ejercicios/bloque02_Hashmap/Principal.java

@@ -0,0 +1,116 @@
+package tutorialJava.capitulo6_ColeccionesDeDatos.ejercicios.bloque02_Hashmap;
+
+import java.util.HashMap;
+import java.util.Scanner;
+
+public class Principal {
+
+	
+	private static HashMap<Integer, Articulo> hm = 
+			new HashMap<Integer, Articulo> ();
+	
+	/**
+	 * 
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int opcion;
+		Articulo art = null;		
+		
+		do {
+			opcion = menu(); // Muestro menú y recojo selección del usuario
+			
+			// Trato la opción elegida
+			switch (opcion) {
+			case 0:
+				System.exit(0);
+				break;
+				
+			case 1: // Ver artículos
+				mostrarArticulos();
+				break;
+				
+			case 2: // Insertar artículo
+				insertarArticulo();
+				break;
+		
+			case 3: // Eliminar artículo
+				System.out.println("Introduzca el codigo de barras deel artículo a eliminar: ");
+				int codigoAEliminar = sc.nextInt();
+				hm.remove(codigoAEliminar);	
+				break;
+		
+			case 4: // Modificar artículo
+				modificarArticulo();
+				break;
+			}
+
+		} while (true);
+	}
+	
+	
+	/**
+	 * 
+	 * @return
+	 */
+	private static int menu() {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Elige lo que desea hacer:");
+		System.out.println("0.-Salir");
+		System.out.println("1.-Ver los objeatos del almecen");
+		System.out.println("2.-Insertar nuevo artículo");
+		System.out.println("3.-Eliminar un articulo");
+		System.out.println("4.-Actualizar un articulo");
+		return sc.nextInt();
+		
+	}
+
+	/**
+	 * 
+	 */
+	private static void mostrarArticulos() {
+		Object claves[] = hm.keySet().toArray();
+		for (int i = 0; i < claves.length; i++) {
+			System.out.println("Codigo de barras: " + claves[i] + 
+					"\nDatos del  " + hm.get(claves[i]));
+		}
+	}
+	
+	
+	/**
+	 * 
+	 */
+	private static void insertarArticulo() {
+		Scanner sc = new Scanner(System.in);
+		System.out.println("Introduzca codigo de barras: ");
+		int cB = sc.nextInt();
+		System.out.println("Introduzca nombre: ");
+		String nombre = sc.next();
+		System.out.println("Introduzca número de estanteria: ");
+		int estanteria = sc.nextInt();
+		System.out.println("Introduzca stock: ");
+		int cantidad = sc.nextInt();
+		
+		hm.put(cB, new Articulo(nombre, cB, estanteria, cantidad));
+
+	}
+	
+	/**
+	 * 
+	 */
+	private static void modificarArticulo() {
+		Scanner sc = new Scanner(System.in);
+		Articulo art = new Articulo();
+		System.out.println("Introzuca codigo de barras: ");
+		art.setCodigoDeBarras(sc.nextInt());
+		System.out.println("Introduzca nombre: ");
+		art.setNombre(sc.next());
+		System.out.println("Introduzca número de estanteria: ");
+		art.setNumeroDeEstante(sc.nextInt());
+		System.out.println("Introduzca stock: ");
+		art.setStock(sc.nextInt());
+		 
+		hm.replace(art.getCodigoDeBarras(), art);
+	}
+}

src/tutorialJava/capitulo7_Recursos/Ejemplo01_FicheroPropiedades.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 Ejemplo01_FicheroPropiedades {
+
+	private static Properties propiedades = null;
+
+	public Ejemplo01_FicheroPropiedades () {
+		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 = Ejemplo01_FicheroPropiedades.getProperty("USUARIO");
+		String password = Ejemplo01_FicheroPropiedades.getProperty("PASSWORD");
+		int id = Ejemplo01_FicheroPropiedades.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/Ejemplo01_Math.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo7_Recursos;
+
+public class Ejemplo01_Math {
+
+	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/Ejemplo01_String.java

@@ -0,0 +1,51 @@
+package tutorialJava.capitulo7_Recursos;
+
+public class Ejemplo01_String {
+
+	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/Ejemplo01_WrappersTiposPrimitivos.java

@@ -0,0 +1,64 @@
+package tutorialJava.capitulo7_Recursos;
+
+public class Ejemplo01_WrappersTiposPrimitivos {
+
+	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/Ejemplo02_DateCalendar.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 Ejemplo02_DateCalendar {
+
+	/**
+	 * 
+	 */
+	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ía del mes: " + ahora.get(Calendar.DAY_OF_MONTH));
+		System.out.println("Día de la semana (0 es Domingo): " + ahora.get(Calendar.DAY_OF_WEEK));
+		System.out.println("Dí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ñ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/Ejemplo05_Recursividad_Factorial.java

@@ -0,0 +1,39 @@
+package tutorialJava.capitulo7_Recursos;
+
+public class Ejemplo05_Recursividad_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/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/ejemplo03_excepciones/EjemploExcepcionesBasico.java

@@ -0,0 +1,210 @@
+package tutorialJava.capitulo7_Recursos.ejemplo03_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ó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/ejemplo03_excepciones/EjemploLanzamientoExcepcionPropia.java

@@ -0,0 +1,69 @@
+package tutorialJava.capitulo7_Recursos.ejemplo03_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());
+		} catch (Exception ex) {
+			ex.printStackTrace();
+		}
+
+	}
+
+}