diff --git a/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejercicios/bloque02_Hashmap/Articulo.java b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejercicios/bloque02_Hashmap/Articulo.java new file mode 100644 index 0000000..7280fc5 --- /dev/null +++ b/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 + "]"; + } + + +} diff --git a/src/tutorialJava/capitulo7_Recursos/Ejemplo05_Recursividad_Factorial.java b/src/tutorialJava/capitulo7_Recursos/Ejemplo05_Recursividad_Factorial.java index c2890d4..16341f3 100644 --- a/src/tutorialJava/capitulo7_Recursos/Ejemplo05_Recursividad_Factorial.java +++ b/src/tutorialJava/capitulo7_Recursos/Ejemplo05_Recursividad_Factorial.java @@ -24,3 +24,16 @@ public class Ejemplo05_Recursividad_Factorial { } } + + + + + + + + + + + + + diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio01_TablaConCaracteristicasDeTiposPrimitivos.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio01_TablaConCaracteristicasDeTiposPrimitivos.java new file mode 100644 index 0000000..232237b --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio01_TablaConCaracteristicasDeTiposPrimitivos.java @@ -0,0 +1,37 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque01_WrappersDeTiposPrimitivos; + +public class Ejercicio01_TablaConCaracteristicasDeTiposPrimitivos { + + public static void main(String[] args) { + + // Características de un Integer + 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); + + // Características de un 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); + + // Características de un 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); + + // Características de un 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); + + // Características de un 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" + System.out.println("Tamaño en bits complemento a 2 para Character: " + Character.SIZE); + + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio02_PedirPasswordConRequisitos.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio02_PedirPasswordConRequisitos.java new file mode 100644 index 0000000..7e05fba --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio02_PedirPasswordConRequisitos.java @@ -0,0 +1,43 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque01_WrappersDeTiposPrimitivos; + +import java.util.Scanner; + +public class Ejercicio02_PedirPasswordConRequisitos { + + public static void main(String[] args) { + boolean mayuscula = false; + boolean minuscula = false; + boolean digito = false; + boolean noAlfanumerico = false; + Scanner sc = new Scanner(System.in); + + do { + mayuscula = false; + minuscula = false; + digito = false; + noAlfanumerico = false; + + System.out.println("Dame una contraseña con mayúsculas, minúsculas, dígitos y algún carácter no alfanumérico: "); + String password = sc.next(); + + for (int i = 0; i < password.length(); i++) { + if (Character.isUpperCase(password.charAt(i))) { + mayuscula = true; + } + if (Character.isLowerCase(password.charAt(i))) { + minuscula = true; + } + if (Character.isDigit(password.charAt(i))) { + digito = true; + } + if (!Character.isLetterOrDigit(password.charAt(i))) { + noAlfanumerico = true; + } + } + } while (!(mayuscula && minuscula && digito && noAlfanumerico)); + + // Contraseña establecida + System.out.println("Contraseña establecida :-)"); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio03_100PrimerosNumerosEnHexadecimal.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio03_100PrimerosNumerosEnHexadecimal.java new file mode 100644 index 0000000..77eb581 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio03_100PrimerosNumerosEnHexadecimal.java @@ -0,0 +1,11 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque01_WrappersDeTiposPrimitivos; + +public class Ejercicio03_100PrimerosNumerosEnHexadecimal { + + public static void main(String[] args) { + + for (int i = 0; i < 101; i++) { + System.out.println("Decimal: " + i + " - Hexadecimal: 0x" + Integer.toHexString(i)); + } + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio04.properties b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio04.properties new file mode 100644 index 0000000..d730587 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio04.properties @@ -0,0 +1,7 @@ +# Ejemplo de comentario en fichero de propiedades + +# Propiedades +USUARIO=RafaelMunoz77 +PASSWORD=1ºDAWlosmejores +ID_USUARIO=1523 +TODO_CORRECTO=true diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio04_LecturaFicheroPropiedades.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio04_LecturaFicheroPropiedades.java new file mode 100644 index 0000000..b68039d --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio04_LecturaFicheroPropiedades.java @@ -0,0 +1,95 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque01_WrappersDeTiposPrimitivos; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.Properties; + + + +public class Ejercicio04_LecturaFicheroPropiedades { + private static Properties propiedades = null; + + + /** + * + * @return + */ + private static Properties getPropiedades() { + if (propiedades == null) { + propiedades = new Properties(); + + try { + // Otra forma de leer el fichero de propiedades + File file = new File("./src/tutorialJava/capitulo7_Recursos/ejercicios/bloque01_WrappersDeTiposPrimitivos/Ejercicio04.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 nombrePropiedad + * @return + */ + public static Boolean getBooleanProperty (String nombrePropiedad) { + return Boolean.parseBoolean(getPropiedades().getProperty(nombrePropiedad)); + } + + + /** + * + * @param args + */ + public static void main (String args[]) { + String usuario = Ejercicio04_LecturaFicheroPropiedades.getProperty("USUARIO"); + String password = Ejercicio04_LecturaFicheroPropiedades.getProperty("PASSWORD"); + int id = Ejercicio04_LecturaFicheroPropiedades.getIntProperty("ID_USUARIO"); + boolean todoCorrecto = Ejercicio04_LecturaFicheroPropiedades.getBooleanProperty("TODO_CORRECTO"); + + 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); + System.out.println("Todo correcto: " + todoCorrecto); + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio01_PuntoDeCorteDeDosGraficas.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio01_PuntoDeCorteDeDosGraficas.java new file mode 100644 index 0000000..9d76b02 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio01_PuntoDeCorteDeDosGraficas.java @@ -0,0 +1,21 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque02_MathDateCalendar; + +public class Ejercicio01_PuntoDeCorteDeDosGraficas { + + public static void main(String[] args) { + + double x = 0, y1 = 0, y2 = 0; + + for (x = 0; x < 1; x+=0.0001) { + y1 = Math.sqrt(x); + y2 = - Math.log(x); + + if (Math.abs(y1 - y2) < 0.001) { + break; + } + } + + System.out.println("Cruce encontrado en x: " + x + " y: " + ((y1 + y2) / 2f)); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio02_PI_SeriesInfinitas_GregoryLeibniz.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio02_PI_SeriesInfinitas_GregoryLeibniz.java new file mode 100644 index 0000000..2508773 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio02_PI_SeriesInfinitas_GregoryLeibniz.java @@ -0,0 +1,20 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque02_MathDateCalendar; + +public class Ejercicio02_PI_SeriesInfinitas_GregoryLeibniz { + + public static void main(String[] args) { + + double PI = 0; + int signo = 1; + int denominador = 1; + + while (Math.abs(Math.PI - PI) > 0.00001) { + PI += signo * (4f / denominador); + signo = -signo; + denominador += 2; + } + + System.out.println("PI: " + PI); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio03_Hipotenusa.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio03_Hipotenusa.java new file mode 100644 index 0000000..d08d514 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio03_Hipotenusa.java @@ -0,0 +1,12 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque02_MathDateCalendar; + +public class Ejercicio03_Hipotenusa { + + public static void main(String[] args) { + + System.out.println("Hipotenusa de un triángulo rectángulo con catetos 4 y 5cm: " + + Math.hypot(4, 5)); + + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio04_DateCalendar.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio04_DateCalendar.java new file mode 100644 index 0000000..79a70eb --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio04_DateCalendar.java @@ -0,0 +1,57 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque02_MathDateCalendar; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Calendar; +import java.util.Date; +import java.util.Scanner; + +import javax.swing.JOptionPane; + +public class Ejercicio04_DateCalendar { + + public static void main(String[] args) { + + Date date = pideFechaConFormat("dd/MM/yyyy"); + Calendar calendar = Calendar.getInstance(); + calendar.setTimeInMillis(date.getTime()); + + System.out.println("Año del date: " + new SimpleDateFormat("yyyy").format(date)); + System.out.println("Mes del date: " + new SimpleDateFormat("MMM").format(date)); + System.out.println("Día del date: " + new SimpleDateFormat("dd").format(date)); + System.out.println("Hora del date: " + new SimpleDateFormat("HH").format(date)); + System.out.println("Minuto del date: " + new SimpleDateFormat("mm").format(date)); + System.out.println("Segundo del date: " + new SimpleDateFormat("ss").format(date)); + + System.out.println("\nAño del calendar: " + calendar.get(Calendar.YEAR)); + System.out.println("Mes del calendar: " + calendar.get(Calendar.MONTH)); + System.out.println("Día del calendar: " + calendar.get(Calendar.DAY_OF_MONTH)); + System.out.println("Hora del calendar: " + calendar.get(Calendar.HOUR_OF_DAY)); + System.out.println("Minuto del calendar: " + calendar.get(Calendar.MINUTE)); + System.out.println("Segundo del calendar: " + calendar.get(Calendar.SECOND)); + + calendar.add(Calendar.DAY_OF_YEAR, 3); System.out.println("\nCalendar más 3 días: " + calendar.getTime()); + calendar.add(Calendar.DAY_OF_YEAR, -14); System.out.println("Calendar menos 2 semanas: " + calendar.getTime()); + calendar.add(Calendar.DAY_OF_YEAR, 300); System.out.println("Calendar más 300 días: " + calendar.getTime()); + calendar.add(Calendar.YEAR, 4); System.out.println("Calendar más 4 años: " + calendar.getTime()); + } + + + + /** + * + * @param formato + * @return + */ + private static Date pideFechaConFormat (String formato) { + SimpleDateFormat sdf = new SimpleDateFormat(formato); + + do { + try { + return sdf.parse(JOptionPane.showInputDialog("Introduzca una fecha con formato dd/MM/yyyy: ")); + } catch (ParseException e) { + System.out.println("Fecha con formato incorrecto. Vuelva a intentarlo"); + } + } while (true); + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio05_DiferenciaHorariaEntreCiudades.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio05_DiferenciaHorariaEntreCiudades.java new file mode 100644 index 0000000..85a9588 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque02_MathDateCalendar/Ejercicio05_DiferenciaHorariaEntreCiudades.java @@ -0,0 +1,21 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque02_MathDateCalendar; + +import java.util.Calendar; +import java.util.TimeZone; + +public class Ejercicio05_DiferenciaHorariaEntreCiudades { + + public static void main(String[] args) { + + Calendar ahoraEnRoma = Calendar.getInstance(TimeZone.getTimeZone("Europe/Rome")); + Calendar ahoraEnWashington = Calendar.getInstance(TimeZone.getTimeZone("EST")); + + int horaEnRoma = ahoraEnRoma.get(Calendar.HOUR_OF_DAY); + int horaEnWashington = ahoraEnWashington.get(Calendar.HOUR_OF_DAY); + + System.out.println("Diferencia horaria entre Roma y Wasington: " + Math.abs(horaEnRoma - horaEnWashington)); + + + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/MinimoNumeroDePalabrasNoAlcanzadoException.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/MinimoNumeroDePalabrasNoAlcanzadoException.java new file mode 100644 index 0000000..1ac3092 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/MinimoNumeroDePalabrasNoAlcanzadoException.java @@ -0,0 +1,38 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque03_Excepciones.ExcepcionPorFraseConPalabraBombilla; + +public class MinimoNumeroDePalabrasNoAlcanzadoException extends Exception { + + private int minimoNumeroPalabras; + + public MinimoNumeroDePalabrasNoAlcanzadoException(int minimoNumeroPalabras) { + this.minimoNumeroPalabras = minimoNumeroPalabras; + // TODO Auto-generated constructor stub + } + + public MinimoNumeroDePalabrasNoAlcanzadoException(String message) { + super(message); + // TODO Auto-generated constructor stub + } + + public MinimoNumeroDePalabrasNoAlcanzadoException(Throwable cause) { + super(cause); + // TODO Auto-generated constructor stub + } + + public MinimoNumeroDePalabrasNoAlcanzadoException(String message, Throwable cause) { + super(message, cause); + // TODO Auto-generated constructor stub + } + + public MinimoNumeroDePalabrasNoAlcanzadoException(String message, Throwable cause, boolean enableSuppression, + boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + // TODO Auto-generated constructor stub + } + + public int getMinimoNumeroPalabras() { + return minimoNumeroPalabras; + } + + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/PalabraBombillaNoEncontradaException.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/PalabraBombillaNoEncontradaException.java new file mode 100644 index 0000000..5ef2530 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/PalabraBombillaNoEncontradaException.java @@ -0,0 +1,30 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque03_Excepciones.ExcepcionPorFraseConPalabraBombilla; + +public class PalabraBombillaNoEncontradaException extends Exception { + + public PalabraBombillaNoEncontradaException() { + // TODO Auto-generated constructor stub + } + + public PalabraBombillaNoEncontradaException(String message) { + super(message); + // TODO Auto-generated constructor stub + } + + public PalabraBombillaNoEncontradaException(Throwable cause) { + super(cause); + // TODO Auto-generated constructor stub + } + + public PalabraBombillaNoEncontradaException(String message, Throwable cause) { + super(message, cause); + // TODO Auto-generated constructor stub + } + + public PalabraBombillaNoEncontradaException(String message, Throwable cause, boolean enableSuppression, + boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/PalabraOfensivaException.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/PalabraOfensivaException.java new file mode 100644 index 0000000..8bb72ed --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/PalabraOfensivaException.java @@ -0,0 +1,30 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque03_Excepciones.ExcepcionPorFraseConPalabraBombilla; + +public class PalabraOfensivaException extends Exception { + + public PalabraOfensivaException() { + // TODO Auto-generated constructor stub + } + + public PalabraOfensivaException(String message) { + super(message); + // TODO Auto-generated constructor stub + } + + public PalabraOfensivaException(Throwable cause) { + super(cause); + // TODO Auto-generated constructor stub + } + + public PalabraOfensivaException(String message, Throwable cause) { + super(message, cause); + // TODO Auto-generated constructor stub + } + + public PalabraOfensivaException(String message, Throwable cause, boolean enableSuppression, + boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/Principal.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/Principal.java new file mode 100644 index 0000000..72fe351 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/Principal.java @@ -0,0 +1,64 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque03_Excepciones.ExcepcionPorFraseConPalabraBombilla; + +import java.util.Iterator; +import java.util.Scanner; + +import javax.swing.JOptionPane; + +public class Principal { + + + private static String getFraseConPalabraBombilla () throws SoloEspaciosEnBlancoException, + MinimoNumeroDePalabrasNoAlcanzadoException, + PalabraBombillaNoEncontradaException, + PalabraOfensivaException { + String frase = JOptionPane.showInputDialog("Introduzca una frase con la palabra \"bombilla\""); + + // No frase formada por espacios en blanco + if (frase.trim().equals("")) { + throw new SoloEspaciosEnBlancoException("No hay palabras en la frase introducida"); + } + // Mínimo número de palabras en 3. + String palabras[] = frase.split("[ ]{1,}"); + if (palabras.length < 3) { + throw new MinimoNumeroDePalabrasNoAlcanzadoException(3); + } + + // No aparece la palabra bombilla + if (frase.toUpperCase().indexOf("BOMBILLA") == -1) { + throw new PalabraBombillaNoEncontradaException(); + } + + // Comprobar palabras ofensivas + String palabrasOfensivas[] = new String[] {"tonto", "tonta", "idiota"}; + for (String palabraOfensiva : palabrasOfensivas) { + if (frase.toLowerCase().indexOf(palabraOfensiva) != -1) { + throw new PalabraOfensivaException("Palabra " + palabraOfensiva + " encontrada"); + } + } + + return frase; + } + + + public static void main(String[] args) { + + try { + System.out.println(getFraseConPalabraBombilla()); + } catch (SoloEspaciosEnBlancoException e) { + System.out.println(e.getMessage()); + } catch (MinimoNumeroDePalabrasNoAlcanzadoException e) { + System.out.println("Tu frase debería ser más larga, al menos: " + + e.getMinimoNumeroPalabras() + " palabras"); + } catch (PalabraBombillaNoEncontradaException e) { + e.printStackTrace(); + } catch (PalabraOfensivaException e) { + System.out.println(e.getMessage()); + } catch (Exception e) { + e.printStackTrace(); + } + + + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/SoloEspaciosEnBlancoException.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/SoloEspaciosEnBlancoException.java new file mode 100644 index 0000000..8f8d092 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorFraseConPalabraBombilla/SoloEspaciosEnBlancoException.java @@ -0,0 +1,30 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque03_Excepciones.ExcepcionPorFraseConPalabraBombilla; + +public class SoloEspaciosEnBlancoException extends Exception { + + public SoloEspaciosEnBlancoException() { + // TODO Auto-generated constructor stub + } + + public SoloEspaciosEnBlancoException(String message) { + super(message); + // TODO Auto-generated constructor stub + } + + public SoloEspaciosEnBlancoException(Throwable cause) { + super(cause); + // TODO Auto-generated constructor stub + } + + public SoloEspaciosEnBlancoException(String message, Throwable cause) { + super(message, cause); + // TODO Auto-generated constructor stub + } + + public SoloEspaciosEnBlancoException(String message, Throwable cause, boolean enableSuppression, + boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorNumeroPar/NumeroImparException.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorNumeroPar/NumeroImparException.java new file mode 100644 index 0000000..06a390f --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorNumeroPar/NumeroImparException.java @@ -0,0 +1,29 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque03_Excepciones.ExcepcionPorNumeroPar; + +public class NumeroImparException extends Exception { + + public NumeroImparException() { + // TODO Auto-generated constructor stub + } + + public NumeroImparException(String arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + + public NumeroImparException(Throwable arg0) { + super(arg0); + // TODO Auto-generated constructor stub + } + + public NumeroImparException(String arg0, Throwable arg1) { + super(arg0, arg1); + // TODO Auto-generated constructor stub + } + + public NumeroImparException(String arg0, Throwable arg1, boolean arg2, boolean arg3) { + super(arg0, arg1, arg2, arg3); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorNumeroPar/Principal.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorNumeroPar/Principal.java new file mode 100644 index 0000000..6e822ca --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque03_Excepciones/ExcepcionPorNumeroPar/Principal.java @@ -0,0 +1,32 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque03_Excepciones.ExcepcionPorNumeroPar; + +import java.util.Scanner; + +public class Principal { + + private static int getNumeroPar () throws NumeroImparException { + System.out.println("Introduzca número par: "); + Scanner sc = new Scanner (System.in); + int numero = sc.nextInt(); + + if (numero % 2 == 0) { + return numero; + } + else { + throw new NumeroImparException("El número: " + numero + " no es par"); + } + } + + + + public static void main(String[] args) { + + try { + getNumeroPar(); + } catch (NumeroImparException e) { + e.printStackTrace(); + } + + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque04_Listener/Principal.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque04_Listener/Principal.java new file mode 100644 index 0000000..583ea23 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque04_Listener/Principal.java @@ -0,0 +1,111 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque04_Listener; + +import java.util.Scanner; + +public class Principal { + + + /** + * + * @param args + */ + public static void main(String[] args) { + Scanner scanner = new Scanner(System.in); + int choice; + + do { + System.out.println("\nMenú de Operaciones Matemáticas:"); + System.out.println("1. Suma"); + System.out.println("2. Resta"); + System.out.println("3. Multiplicación"); + System.out.println("4. División"); + System.out.println("5. Raíz Cuadrada"); + System.out.println("6. Salir"); + System.out.print("Seleccione una opción: "); + + choice = scanner.nextInt(); // Get user choice + + switch (choice) { + case 1: + // Suma + System.out.print("Ingrese el primer número: "); + int sum1 = scanner.nextInt(); + System.out.print("Ingrese el segundo número: "); + int sum2 = scanner.nextInt(); + System.out.println("Resultado de la suma: " + (sum1 + sum2)); + break; + + case 2: + // Resta + System.out.print("Ingrese el primer número: "); + int sub1 = scanner.nextInt(); + System.out.print("Ingrese el segundo número: "); + int sub2 = scanner.nextInt(); + System.out.println("Resultado de la resta: " + (sub1 - sub2)); + break; + + case 3: + // Multiplicación + System.out.print("Ingrese el primer número: "); + int mul1 = scanner.nextInt(); + System.out.print("Ingrese el segundo número: "); + int mul2 = scanner.nextInt(); + System.out.println("Resultado de la multiplicación: " + (mul1 * mul2)); + break; + + case 4: + // División + System.out.print("Ingrese el dividendo: "); + int dividend = scanner.nextInt(); + System.out.print("Ingrese el divisor: "); + int divisor = scanner.nextInt(); + + if (divisor != 0) { + System.out.println("Resultado de la división: " + (dividend / divisor)); + } + break; + + case 5: + // Raíz cuadrada + System.out.print("Ingrese el número: "); + int number = scanner.nextInt(); + + if (number >= 0) { + System.out.println("Resultado de la raíz cuadrada: " + Math.sqrt(number)); + } + break; + + case 6: + System.out.println("Saliendo del programa. ¡Adiós!"); + break; + + default: + System.out.println("Opción no válida. Intente de nuevo."); + break; + } + + } while (choice != 6); + + scanner.close(); + } + + + /** + * + * @return + */ + private int menu() { + Scanner scanner = new Scanner(System.in); + + System.out.println("\nMenú de Operaciones Matemáticas:"); + System.out.println("1. Suma"); + System.out.println("2. Resta"); + System.out.println("3. Multiplicación"); + System.out.println("4. División"); + System.out.println("5. Raíz Cuadrada"); + System.out.println("6. Salir"); + System.out.print("Seleccione una opción: "); + + return scanner.nextInt(); + } +} \ No newline at end of file diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque05_recursividad/Ejercicio01_FibonacciRecursivo.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque05_recursividad/Ejercicio01_FibonacciRecursivo.java new file mode 100644 index 0000000..2425dff --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque05_recursividad/Ejercicio01_FibonacciRecursivo.java @@ -0,0 +1,26 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque05_recursividad; + +public class Ejercicio01_FibonacciRecursivo { + + /** + * + * @param args + */ + public static void main(String[] args) { + int n = 7; + System.out.println("El término " + n + " de la secuencia de Fibonacci es: " + fibonacci(n)); + } + + /** + * + * @param n + * @return + */ + public static int fibonacci(int n) { + if (n <= 1) { + return n; // Caso base: fibonacci(0) = 0 y fibonacci(1) = 1 + } + return fibonacci(n - 1) + fibonacci(n - 2); // Llamadas recursivas + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque05_recursividad/Ejercicio02_PotenciaRecursiva.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque05_recursividad/Ejercicio02_PotenciaRecursiva.java new file mode 100644 index 0000000..b4c9ef8 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque05_recursividad/Ejercicio02_PotenciaRecursiva.java @@ -0,0 +1,32 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque05_recursividad; + +public class Ejercicio02_PotenciaRecursiva { + + + /** + * + * @param base + * @param exponent + * @return + */ + public static int potencia(int base, int exponente) { + // Cualquier número elevado a 0 es 1 + if (exponente == 0) { + return 1; + } + + return base * potencia(base, exponente - 1); + } + + /** + * + * @param args + */ + public static void main(String[] args) { + // Pruebas + int base = 2; + int exponent = 7; + + System.out.println(base + " elevado a la " + exponent + " es: " + potencia(base, exponent)); + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque05_recursividad/Ejercicio03_ConteoRegresivo.java b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque05_recursividad/Ejercicio03_ConteoRegresivo.java new file mode 100644 index 0000000..014af53 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejercicios/bloque05_recursividad/Ejercicio03_ConteoRegresivo.java @@ -0,0 +1,27 @@ +package tutorialJava.capitulo7_Recursos.ejercicios.bloque05_recursividad; + +public class Ejercicio03_ConteoRegresivo { + + /** + * + * @param args + */ + public static void main(String[] args) { + int numero = 10; + System.out.println("Conteo regresivo desde " + numero + ":"); + conteoRegresivo(numero); + } + + /** + * + * @param n + */ + public static void conteoRegresivo(int n) { + if (n == 0) { + return; // Cuando n llega a 0, termina la recursividad + } + System.out.println(n); + conteoRegresivo(n - 1); // Llamada recursiva con n-1 + } + +}