feat(ch 5 & 6): examples added

src/tutorialJava/capitulo7_Recursos/EjemploDateCalendar.java

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

src/tutorialJava/capitulo7_Recursos/EjemploFicheroPropiedades.java

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

src/tutorialJava/capitulo7_Recursos/EjemploMath.java

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

src/tutorialJava/capitulo7_Recursos/EjemploRecursividad_Factorial.java

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

src/tutorialJava/capitulo7_Recursos/EjemploString.java

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

src/tutorialJava/capitulo7_Recursos/EjemploWrappersTiposPrimitivos.java

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

src/tutorialJava/capitulo7_Recursos/ejemplo.properties

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

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Madre.java

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

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Padre.java

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

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraEvent.java

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

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraListener.java

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

src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Principal.java

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

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/IntroduccionNumeros.java

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

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Mesa.java

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

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparEvent.java

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

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparListener.java

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

src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Perro.java

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

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/CorrectorOrtografico.java

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

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Informatica.java

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

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaEvent.java

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

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaListener.java

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

src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Principal.java

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

src/tutorialJava/capitulo7_Recursos/excepciones/EjemploExcepcionesBasico.java

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

src/tutorialJava/capitulo7_Recursos/excepciones/EjemploLanzamientoExcepcionPropia.java

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

src/tutorialJava/capitulo7_Recursos/excepciones/MartesException.java

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

src/tutorialJava/capitulo7_Recursos/excepciones/Persona.java

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

src/tutorialJava/capitulo7_Recursos/excepciones/PersonaNulaException.java

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

src/tutorialJava/capitulo7_Recursos/excepciones/Pierna.java

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

src/tutorialJava/capitulo7_Recursos/excepciones/PiernaNulaException.java

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

src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/PalabraRepetidaException.java

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

src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/Principal.java

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