From c3f1b2b4183207d87935d9fd07cd5b2ab0f08a4f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=20Mu=C3=B1oz?= Date: Thu, 12 Sep 2024 13:36:06 +0200 Subject: [PATCH] feat(chapter to 4): added --- .gitignore | 2 + src/org/rmr/tutorial24_25/HolaMundo.java | 9 - src/tutorialJava/Utils.java | 185 ++++++++++++++++++ .../capitulo1/Ejemplo01_HolaMundo.java | 9 + .../capitulo1/Ejemplo02_TiposPrimitivos.java | 58 ++++++ .../Ejemplo03_IntroduccionString.java | 30 +++ ...ecturaDeDatosDelUsuarioConJOptionPane.java | 29 +++ ...05_LecturaDeDatosDelUsuarioConScanner.java | 18 ++ ...emplo06_OperacionesAritmeticasBasicas.java | 44 +++++ .../Ejemplo07_OperadoresANivelDeBits.java | 87 ++++++++ ...CalculoSolucionesEcuacionSegundoGrado.java | 23 +++ .../Ejemplo00_PrimerCondicional.java | 43 ++++ .../Ejemplo01_Condicionales.java | 142 ++++++++++++++ .../capitulo2_condicionales/EjemploMenu.java | 58 ++++++ .../capitulo3_bucles/Ejemplo01_Bucle_For.java | 143 ++++++++++++++ .../Ejemplo02_Bucle_While.java | 67 +++++++ .../Ejemplo03_Bucle_DoWhile.java | 51 +++++ .../Ej01_EjemploArraysPrimitivos.java | 102 ++++++++++ .../Ej02_OrdenacionDeUnArray.java | 44 +++++ .../Ej03_EjemploMatrices.java | 30 +++ .../Ej04_ComoHacerEjerciciosMatrices.java | 84 ++++++++ ...05_InicializarMatrizSinRepetirValores.java | 33 ++++ 22 files changed, 1282 insertions(+), 9 deletions(-) create mode 100644 .gitignore delete mode 100644 src/org/rmr/tutorial24_25/HolaMundo.java create mode 100644 src/tutorialJava/Utils.java create mode 100644 src/tutorialJava/capitulo1/Ejemplo01_HolaMundo.java create mode 100644 src/tutorialJava/capitulo1/Ejemplo02_TiposPrimitivos.java create mode 100644 src/tutorialJava/capitulo1/Ejemplo03_IntroduccionString.java create mode 100644 src/tutorialJava/capitulo1/Ejemplo04_LecturaDeDatosDelUsuarioConJOptionPane.java create mode 100644 src/tutorialJava/capitulo1/Ejemplo05_LecturaDeDatosDelUsuarioConScanner.java create mode 100644 src/tutorialJava/capitulo1/Ejemplo06_OperacionesAritmeticasBasicas.java create mode 100644 src/tutorialJava/capitulo1/Ejemplo07_OperadoresANivelDeBits.java create mode 100644 src/tutorialJava/capitulo1/Ejemplo08_CalculoSolucionesEcuacionSegundoGrado.java create mode 100644 src/tutorialJava/capitulo2_condicionales/Ejemplo00_PrimerCondicional.java create mode 100644 src/tutorialJava/capitulo2_condicionales/Ejemplo01_Condicionales.java create mode 100644 src/tutorialJava/capitulo2_condicionales/EjemploMenu.java create mode 100644 src/tutorialJava/capitulo3_bucles/Ejemplo01_Bucle_For.java create mode 100644 src/tutorialJava/capitulo3_bucles/Ejemplo02_Bucle_While.java create mode 100644 src/tutorialJava/capitulo3_bucles/Ejemplo03_Bucle_DoWhile.java create mode 100644 src/tutorialJava/capitulo4_Arrays/Ej01_EjemploArraysPrimitivos.java create mode 100644 src/tutorialJava/capitulo4_Arrays/Ej02_OrdenacionDeUnArray.java create mode 100644 src/tutorialJava/capitulo4_Arrays/Ej03_EjemploMatrices.java create mode 100644 src/tutorialJava/capitulo4_Arrays/Ej04_ComoHacerEjerciciosMatrices.java create mode 100644 src/tutorialJava/capitulo4_Arrays/Ej05_InicializarMatrizSinRepetirValores.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..dbc5cca --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +/bin/ +/.settings diff --git a/src/org/rmr/tutorial24_25/HolaMundo.java b/src/org/rmr/tutorial24_25/HolaMundo.java deleted file mode 100644 index 4742ba7..0000000 --- a/src/org/rmr/tutorial24_25/HolaMundo.java +++ /dev/null @@ -1,9 +0,0 @@ -package org.rmr.tutorial24_25; - -public class HolaMundo { - - public static void main(String[] args) { - System.out.println("Hola Mundo 2"); - } - -} diff --git a/src/tutorialJava/Utils.java b/src/tutorialJava/Utils.java new file mode 100644 index 0000000..e82da78 --- /dev/null +++ b/src/tutorialJava/Utils.java @@ -0,0 +1,185 @@ +package tutorialJava; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.util.Scanner; + +import javax.swing.JOptionPane; + +public class Utils { + + /** + * Método que obtiene y devuelve un número al azar, entre 0 y 100. + * @return Número generado al azar entre 0 y 100 + */ + public static int obtenerNumeroAzar () { + return (int) Math.round(Math.random() * 100); + } + + + /** + * + * @param min Límite inferior de generación del número al azar + * @param max Límite superior de generación del número al azar + * @return Número generado al azar entre dos límites. + */ + public static int obtenerNumeroAzar (int min, int max) { + return (int) Math.round(Math.random() * (max - min)) + min; + } + + + /** + * Pide un número entero al usuario + * @param mensaje String que va a mostrarse en consola para pedir el número + * @return Número entero introducido por el usuario + */ + public static int pideNumeroEntero (String mensaje) { + int n = 0; + boolean esNumeroCorrecto; + Scanner sc = new Scanner(System.in); + + do { + esNumeroCorrecto = false; + try { + System.out.println(mensaje); + n = Integer.parseInt(sc.nextLine()); + esNumeroCorrecto = true; + } + catch (Exception e) { + System.out.println("No ha introducido un número"); + } + } while (esNumeroCorrecto == false); + + return n; + } + + + + /** + * Obtiene un número entero introducido por el usuario, por el método de InputStreamReader + * @return Número entero introducido por el usuario. + */ + public static int obtenerEnteroPorInputStreamReader () { + int numero = 0; + try { + InputStreamReader isr = new InputStreamReader(System.in); + BufferedReader br = new BufferedReader (isr); + numero = Integer.parseInt (br.readLine()); + } catch (Exception e) { + e.printStackTrace(); + } + return numero; + } + + + /** + * Obtiene un número entero a través de un objeto Scanner + * @return Número entero introducido por el usuario. + */ + public static int obtenerEnteroPorScanner() { + Scanner sc = new Scanner(System.in); + + while (true) { + try { + return sc.nextInt(); + } catch (Exception ex) { + System.out.println("Error, introduce un número entero: "); + sc.nextLine(); + } + } + + } + + /** + * Obtiene un número entero a través de un JOptionPane + * @return Número entero introducido a través de un JOptionPane. + */ + public static int obtenerEnteroPorJOptionPane() { + String str = JOptionPane.showInputDialog("Introduce un número"); + int numEntero = Integer.parseInt(str); + return numEntero; + } + + + /** + * + * @param mensaje + * @return + */ + public static int obtenerEnteroPorJOptionPane (String mensaje) { + String str = JOptionPane.showInputDialog(mensaje); + int numEntero = Integer.parseInt(str); + return numEntero; + } + + + public static int obtenerEnteroConDescripcion(String desc) { + System.out.println(desc); + int num = obtenerEnteroPorScanner(); + return num; + } + + /** + * + * @return Número entero introducido por el usuario + */ + public static int obtenerEntero() { + return obtenerEnteroPorJOptionPane(); + } + + /** + * + * @param mensajeAlUsuario + * @param limiteInf + * @param limiteSup + * @return + */ + public static int obtenerEnteroEntreLimites (String mensajeAlUsuario, int limiteInf, + int limiteSup) { + int numeroADelvolver = 0; + + Scanner sc = new Scanner(System.in); + boolean datoCorrecto; + do { + try { + datoCorrecto = true; + System.out.println(mensajeAlUsuario); + numeroADelvolver = sc.nextInt(); + + if (numeroADelvolver < limiteInf || numeroADelvolver > limiteSup) { + datoCorrecto = false; + System.out.println("ERROR, debes introducir un número entre " + + limiteInf + " y " + limiteSup); + } + } + catch (Exception ex) { + System.out.println("ERROR, no has introducido un dato númerico entre " + + limiteInf + " y " + limiteSup); + sc.next(); + datoCorrecto = false; + } + } while (!datoCorrecto); + + return numeroADelvolver; + } + + /** + * + * @return + */ + public static String obtenerCadena () { + Scanner sc = new Scanner(System.in); + return sc.nextLine(); + } + + /** + * + * @return + */ + public static String obtenerCadenaConDescripcion (String desc) { + Scanner sc = new Scanner(System.in); + System.out.println(desc); + return sc.nextLine(); + } + +} diff --git a/src/tutorialJava/capitulo1/Ejemplo01_HolaMundo.java b/src/tutorialJava/capitulo1/Ejemplo01_HolaMundo.java new file mode 100644 index 0000000..491728d --- /dev/null +++ b/src/tutorialJava/capitulo1/Ejemplo01_HolaMundo.java @@ -0,0 +1,9 @@ +package tutorialJava.capitulo1; + +public class Ejemplo01_HolaMundo { + + public static void main(String[] args) { + System.out.println("Hola Mundo4"); + } + +} diff --git a/src/tutorialJava/capitulo1/Ejemplo02_TiposPrimitivos.java b/src/tutorialJava/capitulo1/Ejemplo02_TiposPrimitivos.java new file mode 100644 index 0000000..d841ab4 --- /dev/null +++ b/src/tutorialJava/capitulo1/Ejemplo02_TiposPrimitivos.java @@ -0,0 +1,58 @@ +package tutorialJava.capitulo1; + +public class Ejemplo02_TiposPrimitivos { + + /* + * Comentario multilínea + */ + public static void main (String args[]) { + int numEntero; // Declaración de una variable entera + float numFlotante; // Declaración de una variable real o flotante + double numDouble; // Declaración de una variable flotante larga + + numEntero = 4 + 6; // Asignación de un valor a una variable + numFlotante = (float) 4; // Casting de valor double a float + numDouble = 4.8; // Asignación de valor double a variable double + + // Impresión en la consola de salida de las variabless + System.out.print("El número entero es " + numEntero + + "\ny el número flotante es " + numFlotante + + "\ny el número double es: " + numDouble); + + } + + + + + + + + + + + + + + + + + + /* Esta es la funci�n resolucionEcuacionSegundoGrado, que + resuelve la ecuaci�n de segundo grado */ +/* public static void main (String args[]) { + int a = 1, b = 0, c = -1; + float x1, x2; + float determinante; + + determinante = (float) Math.sqrt(b*b - 4*a*c); + x1 = ((0 - b) + determinante) / (2 * a); + x2 = ((0 - b) - determinante) / (2 * a); + + System.out.println("La ecuaci�n es " + a + + "x(2) + " + b + "x + " + c + " = 0"); + System.out.println("La soluci�n x1 es " + x1 + + " y la soluci�n x2 es " + x2); + + } + */ +} diff --git a/src/tutorialJava/capitulo1/Ejemplo03_IntroduccionString.java b/src/tutorialJava/capitulo1/Ejemplo03_IntroduccionString.java new file mode 100644 index 0000000..a6768c8 --- /dev/null +++ b/src/tutorialJava/capitulo1/Ejemplo03_IntroduccionString.java @@ -0,0 +1,30 @@ +package tutorialJava.capitulo1; + +public class Ejemplo03_IntroduccionString { + + /** + * + * @param args + */ + public static void main (String args[]) { + String cadenaCarac = "Tutorial de Lenguaje de Programación Java 8."; // Creació de una cadena de caracteres + + System.out.println("Valor de cadenaCarac: " + cadenaCarac); // Imprime una cadena de caracteres + System.out.println("Longitud de cadenaCarac: " + cadenaCarac.length()); // Imprime l alongitud de una cadena + System.out.println("Localización por caracteres: " + cadenaCarac.indexOf("Lenguaje")); // Índice en el que encontramos una cadena + System.out.println("Localización por índices: " + cadenaCarac.charAt(12)); // Carácter encontrado en el índice 12, empezando por 0 + System.out.println("Uso de subcadenas: " + cadenaCarac.substring(12, 20)); // Obtener una subcadena dentro de una cadena + System.out.println("Uso de toLower: " + cadenaCarac.toLowerCase()); // Convertir una cadena de caracteres en minúscula + System.out.println("Uso de toUpper: " + cadenaCarac.toUpperCase()); // Convertir una cadena de caracteres en mayúscula. + } +} + + + + + + + + + + diff --git a/src/tutorialJava/capitulo1/Ejemplo04_LecturaDeDatosDelUsuarioConJOptionPane.java b/src/tutorialJava/capitulo1/Ejemplo04_LecturaDeDatosDelUsuarioConJOptionPane.java new file mode 100644 index 0000000..221e335 --- /dev/null +++ b/src/tutorialJava/capitulo1/Ejemplo04_LecturaDeDatosDelUsuarioConJOptionPane.java @@ -0,0 +1,29 @@ +package tutorialJava.capitulo1; + +import javax.swing.JOptionPane; + +public class Ejemplo04_LecturaDeDatosDelUsuarioConJOptionPane { + + /** + * + * @param args + */ + public static void main(String args[]) { + // Petición de un número entero + String stringNumero = JOptionPane.showInputDialog("Introduzca un número entero"); + int numero = Integer.parseInt(stringNumero); + System.out.println("Valor de numero: " + numero); + + // Petición de un número flotante + String stringNumeroFlotante = JOptionPane.showInputDialog("Introduzca un número flotante"); + float numeroFlotante = Float.parseFloat(stringNumeroFlotante); + System.out.println("Valor de numeroFlotante: " + numeroFlotante); + } +} + + + + + + + diff --git a/src/tutorialJava/capitulo1/Ejemplo05_LecturaDeDatosDelUsuarioConScanner.java b/src/tutorialJava/capitulo1/Ejemplo05_LecturaDeDatosDelUsuarioConScanner.java new file mode 100644 index 0000000..8d9f8a9 --- /dev/null +++ b/src/tutorialJava/capitulo1/Ejemplo05_LecturaDeDatosDelUsuarioConScanner.java @@ -0,0 +1,18 @@ +package tutorialJava.capitulo1; + +import java.util.Scanner; + +public class Ejemplo05_LecturaDeDatosDelUsuarioConScanner { + + public static void main (String args[]) { + Scanner sc = new Scanner(System.in); + + System.out.println("Dame un número entero: "); + int numEntero = sc.nextInt(); + System.out.println("Valor de numEntero: " + numEntero); + + System.out.println("Dame un flotante: "); + float numFlotante = sc.nextFloat(); + System.out.println("Valor de numFlotante: " + numFlotante); + } +} diff --git a/src/tutorialJava/capitulo1/Ejemplo06_OperacionesAritmeticasBasicas.java b/src/tutorialJava/capitulo1/Ejemplo06_OperacionesAritmeticasBasicas.java new file mode 100644 index 0000000..ef6dd9a --- /dev/null +++ b/src/tutorialJava/capitulo1/Ejemplo06_OperacionesAritmeticasBasicas.java @@ -0,0 +1,44 @@ +package tutorialJava.capitulo1; + +import java.util.Scanner; + +public class Ejemplo06_OperacionesAritmeticasBasicas { + + public static void main(String args[]) { + Scanner sc = new Scanner(System.in); + + System.out.println("Dame un número entero: "); + int num1 = sc.nextInt(); + System.out.println("Valor de numEntero: " + num1); + + System.out.println("Dame otro número entero: "); + int num2 = sc.nextInt(); + System.out.println("Valor de numEntero: " + num2); + + System.out.println("La suma de los valores es: " + (num1 + num2)); + System.out.println("La resta de los valores es: " + (num1 - num2)); + System.out.println("La multiplicación de los valores es: " + (num1 * num2)); + + System.out.println("La división de los valores es: " + (num1 / num2)); + + System.out.println("La potencia de los valores es: " + (Math.pow(num1, num2))); + + System.out.println("La raíz cuadrada del primer valor es: " + (Math.sqrt(num1))); + System.out.println("La raíz cúbica del primer valor es: " + (Math.cbrt(num1))); + System.out.println("La raíz n-ésima del primer valor con índice " + + "el segundo valor es: " + (Math.pow(num1, 1f / num2))); + + } +} + + + + + + + + + + + + diff --git a/src/tutorialJava/capitulo1/Ejemplo07_OperadoresANivelDeBits.java b/src/tutorialJava/capitulo1/Ejemplo07_OperadoresANivelDeBits.java new file mode 100644 index 0000000..04a6d37 --- /dev/null +++ b/src/tutorialJava/capitulo1/Ejemplo07_OperadoresANivelDeBits.java @@ -0,0 +1,87 @@ +package tutorialJava.capitulo1; + +public class Ejemplo07_OperadoresANivelDeBits { + + public static void main(String[] args) { + // Declaración de variables enteras, e inicialización de las mismas. + // Llamamos "inicialización de la variable" a la primera vez que + // esa variable toma un valor cualquiera en un operador de asignación. + // En la siguiente línea de código, se han declarado e inicializado + // dos variables. + // Por favor, recuerda el significado de "inicialización de variable", + // es muy importante y muy utilizado entre programadores. + int entero1 = 5, entero2 = 3; + + // Operación lógica AND. Esta operación, al igual que todas las de + // este ejercicio, actua a nivel de los bits que forman el valor + // contenido dentro de la variable. En concreto, en este ejemplo, + // intervienen el "entero1" toma el valor 30, que presentado en + // binario es 11110, y el "entero2" que toma el valor 3, que en + // binario es 00011. + // Al aplicar la operación lógica AND, el resultado en binario + // queda 00010, que corresponde al número 2 en decimal. + System.out.println("Operación lógica AND: " + (entero1 & entero2)); + + // Operación lógica OR. Al igual que antes, partimos del valor + // 11110 (30) y del valor 00011 (3). Al aplicar la operación OR, + // queda el valor 11111 (31). El carácter "|" se obtiene con la + // combinación de "Alt Gr + 1". + System.out.println("\nOperación lógica OR: " + (entero1 | entero2)); + + // Operación lógica NOT. Esta operación cambia todos los bits + // del valor sobre el que actua. El operador NOT también es + // llamado "complemento a uno". + // En DevC, se utilizan 4 Bytes para representar cada entero, + // por tanto, ya que 1 Byte = 8 bits, se utilizan 32 bits para + // cada valor definido como "int". De esta forma, el valor 30 + // estará representado como: + // 00000000 00000000 00000000 00011110 + // Al negar quedará: + // 11111111 11111111 11111111 11000001 + // + // En C, los números enteros pueden ser positivos o negativos. + // El signo positivo o negativo de un número viene dado por el + // bit que tiene situado a su izquierda, de manera que un valor + // 0 (cero) indica un número positivo, y un valor 1 (uno) indica + // un número negativo. + // Sin embargo, a la hora de imprimir, podemos utilizar el forma- + // teador %u, que viene de la palabra "unsigned". Es decir, mos- + // mostrará el valor contenido en la variable sin tener en cuenta + // que el bit de la izquierda indique un signo o no. De hecho, al + // imprimir en forma "unsigned", no podrán existir los números + // negativos. + // Para escribir en pantalla el símbolo "~", si tienes un teclado + // configurado como "Español Tradicional", podrás utilizar la + // combinación "Alt gr + 4", y deberás pulsar el cuatro un par de + // veces. + System.out.println("\nOperación lógica NOT: " + ~entero1); + + // Operación lógica XOR. Para escribir en pantalla el símbolo "^", + // si tienes un teclado configurado como "Español Tradicional", + // podrás utilizar la combinación "Mayúsculas + `" (tecla situada + // a la izquierda del símbolo "+", y deberás pulsar el ` un par de + // veces. + System.out.println("\nOperación lógica XOR: " + (entero1 ^ entero2)); + + // Operación de desplazamiento de bits. Si representamos el valor + // 30 de la siguiente forma: + // 00000000 00000000 00000000 00011110 + // y desplazamos la "tira de bits" un lugar a la izquierda, ahora + // se representará el valor: + // 00000000 00000000 00000000 00111100, que corresponde al + // valor 60, es decir, hemos multiplicado el número por 2. + // Sin embargo, si en lugar de desplazar a la izquierda, se + // desplaza a la derecha, el valor obtenido será: + // 00000000 00000000 00000000 00001111, que corresponde al + // valor decimal 15, es decir, se ha dividido entre 2. + // Para desplazar, se utilizan los operadores << y >>. De manera que + // la expresión: entero2 << 1, quiere decir que se desplacen un + // lugar a la izquierda los bits de entero2. De esta forma, la + // expresión: entero2 >> 2, quiere decir que se desplacen dos lugares + // a la derecha los bits de entero2. + System.out.println("\nOperación de desplazamiento izquierda: " + (entero2 << 1)); + System.out.println("\nOperación de desplazamiento derecha: " + (entero1 >> 2)); + + } + +} diff --git a/src/tutorialJava/capitulo1/Ejemplo08_CalculoSolucionesEcuacionSegundoGrado.java b/src/tutorialJava/capitulo1/Ejemplo08_CalculoSolucionesEcuacionSegundoGrado.java new file mode 100644 index 0000000..2ba13bc --- /dev/null +++ b/src/tutorialJava/capitulo1/Ejemplo08_CalculoSolucionesEcuacionSegundoGrado.java @@ -0,0 +1,23 @@ +package tutorialJava.capitulo1; + +import java.util.Scanner; + +public class Ejemplo08_CalculoSolucionesEcuacionSegundoGrado { + + public static void main (String args[]) { + Scanner sc = new Scanner(System.in); + + System.out.println("Introduzca el valor de a: "); + int a = sc.nextInt(); + System.out.println("Introduzca el valor de b: "); + int b = sc.nextInt(); + System.out.println("Introduzca el valor de c: "); + int c = sc.nextInt(); + + float contenidoRaiz = (float) Math.sqrt( Math.pow(b, 2) - 4 * a * c ); + float x1 = (-b + contenidoRaiz) / (2 * a); + float x2 = (-b - contenidoRaiz) / (2 * a); + + System.out.println("X1: " + x1 + " # x2: " + x2); + } +} diff --git a/src/tutorialJava/capitulo2_condicionales/Ejemplo00_PrimerCondicional.java b/src/tutorialJava/capitulo2_condicionales/Ejemplo00_PrimerCondicional.java new file mode 100644 index 0000000..8a59d07 --- /dev/null +++ b/src/tutorialJava/capitulo2_condicionales/Ejemplo00_PrimerCondicional.java @@ -0,0 +1,43 @@ +package tutorialJava.capitulo2_condicionales; + +import java.util.Scanner; + +public class Ejemplo00_PrimerCondicional { + + public static void unMetodo() { + int num; + + num = (int) Math.round(Math.random() * 100); + + System.out.println("El número al azar es: " + num); + + if (num >= 0 && num <= 25) { + System.out.println("El número está entre 0 y 25"); + } + else { + if (num > 25 && num <= 50) { + System.out.println("El número está entre 26 y 50"); + } + else { + System.out.println("El número es mayor de 50"); + } + } + } + + public static void main(String[] args) { + unMetodo(); + } +} + + + + + + + + + + + + + diff --git a/src/tutorialJava/capitulo2_condicionales/Ejemplo01_Condicionales.java b/src/tutorialJava/capitulo2_condicionales/Ejemplo01_Condicionales.java new file mode 100644 index 0000000..b110537 --- /dev/null +++ b/src/tutorialJava/capitulo2_condicionales/Ejemplo01_Condicionales.java @@ -0,0 +1,142 @@ +package tutorialJava.capitulo2_condicionales; + + +public class Ejemplo01_Condicionales { + + + /** + * + * @param args + */ + public static void main (String args[]) { +// primerEjemploCondicionalSimple(); +// ejemploCondicionalCompuesto(); +// ejemploCondicionalAnidado(); + ejemploCondicionalMultiple(); +// ejemploOperadorTernario(); + } + + + /** + * Cómo utilizar simplemente un operador if + */ + public static void primerEjemploCondicionalSimple () { + int numero = (int) Math.round(Math.random() * 100); // Pido un número entre 0 y 100 + System.out.println(numero); // Lo imprimo + + // Determino si el número está entre unos límites + if ( (numero >= 10 && numero <= 50) || (numero >= 70 && numero <= 90) ) { + System.out.println("Bingooooooooo"); + } + } + + + /** + * Ejemplo de operador if con else + */ + public static void ejemploCondicionalCompuesto () { + int numero = (int) Math.round(Math.random() * 100); // Obtengo número al azar + System.out.println("Var número: " + numero); + + // Determino si es mayor de 50 o no lo es + if (numero > 50) { + System.out.println("El número es mayor de 50"); + } + else { + System.out.println("El número es 50 o menor de 50"); + } + } + + + /** + * Los condicionales pueden anidarse unos dentro de otros + */ + public static void ejemploCondicionalAnidado () { + int numero = (int) Math.round(Math.random() * 100); // Pido número al azar + System.out.println("Número al azar: " + numero); + + if (numero > 0) { + System.out.println("Es positivo"); + } + else { + if (numero < 0) { + System.out.println("Es negativo"); + } + else { + System.out.println("El número es cero"); + } + } + + } + + + /** + * Ejemplo de switch + */ + public static void ejemploCondicionalMultiple () { + int nota = 1; + + // switch decidirá el camino a tomar en función del valor + // de la variable + switch (nota) { + case 0: + case 1: + case 2: + System.out.println("Muy deficiente"); // Se llega en los cases 0, 1 y 2 + break; // Con esta instrucción salimos del switch + case 3: + case 4: + System.out.println("Deficiente"); + break; + case 5: + System.out.println("Suficiente"); + break; + case 6: + System.out.println("Bien"); + break; + case 7: + case 8: + System.out.println("Notable"); + break; + case 9: + case 10: + System.out.println("Sobresaliente"); + break; + default: + System.out.println("Error, el valor no pertenece a ninguna nota"); + } + } + + + + /** + * Operador ternario, muy utilizado + */ + public static void ejemploOperadorTernario () { + int valor; + boolean esValorPositivo; + + // Forma habitual de asignar valor a una variable en función de una condición + valor = 1; + if (valor >= 0) { + esValorPositivo = true; + } + else { // valor < 0 + esValorPositivo = false; + } + + // Otra forma de hacerlo, a través del operador ternario + esValorPositivo = (valor >= 0)? true : false ; + + } + +} + + + + + + + + + diff --git a/src/tutorialJava/capitulo2_condicionales/EjemploMenu.java b/src/tutorialJava/capitulo2_condicionales/EjemploMenu.java new file mode 100644 index 0000000..277d93b --- /dev/null +++ b/src/tutorialJava/capitulo2_condicionales/EjemploMenu.java @@ -0,0 +1,58 @@ +package tutorialJava.capitulo2_condicionales; + +import javax.swing.JOptionPane; + +public class EjemploMenu { + + public static void main(String[] args) { + String str; + int opcion, numero1, numero2; + +// System.out.println("Menú:"); +// System.out.println("1.- Suma"); +// System.out.println("2.- Resta"); +// System.out.println("3.- Multiplicación"); +// System.out.println("4.- División"); + + str = JOptionPane.showInputDialog("Menú:" + + "\n1.- Suma\n2.- Resta\n3.- Multiplicación\n4.- División\n" + + "Introduzca la opción: "); + opcion = Integer.parseInt(str); + + str = JOptionPane.showInputDialog("Introduzca el primer número: "); + numero1 = Integer.parseInt(str); + str = JOptionPane.showInputDialog("Introduzca el segundo número: "); + numero2 = Integer.parseInt(str); + + + switch(opcion) { + case 1: + System.out.println("La suma vale: " + (numero1 + numero2)); + break; + case 2: + System.out.println("La resta vale: " + (numero1 - numero2)); + break; + case 3: + System.out.println("La multiplicación vale: " + (numero1 * numero2)); + break; + case 4: + System.out.println("La división vale: " + (numero1 / numero2)); + break; + default: + System.out.println("La opción " + opcion + " no está contemplada"); + } + } + +} + + + + + + + + + + + + diff --git a/src/tutorialJava/capitulo3_bucles/Ejemplo01_Bucle_For.java b/src/tutorialJava/capitulo3_bucles/Ejemplo01_Bucle_For.java new file mode 100644 index 0000000..d8c94ee --- /dev/null +++ b/src/tutorialJava/capitulo3_bucles/Ejemplo01_Bucle_For.java @@ -0,0 +1,143 @@ +package tutorialJava.capitulo3_bucles; + +import java.util.Scanner; + +import javax.swing.JOptionPane; + +public class Ejemplo01_Bucle_For { + + /** + * + * @param args + */ + public static void main (String args[]) { +// cuentaAdelanteYAtras(); +// cuentaAdelanteConMultiplos(); +// tablaMultiplicar(); +// mayorDeUnaSerieDeNumeros(); +// numerosPrimos(); + } + + + /** + * Ejemplo de como utilizar un bucle For para realizar cuenta delante y hacia atrás + */ + public static void cuentaAdelanteYAtras () { + + // Cuenta hacia delante + System.out.println("Cuenta adelante con bucle for"); + for (int i = 0; i < 10; i++) { + System.out.println("Valor de i: " + i); + } + + // Cuenta hacia atrás + System.out.println("Cuenta hacia atrás con bucle for"); + for (int i = 10; i > -1; i--) { + System.out.println("Valor de i: " + i); + } + } + + + /** + * Contar múltiplos hacia delante + */ + public static void cuentaAdelanteConMultiplos () { + int limite = 20; + int factor = 3; + + // Una forma de hacer múltiplos + for (int i = 0; (i * factor) < limite; i++) { + System.out.println("Valor de i * factor: " + (i * factor)); + } + + // Otra forma de hacer los múltiplos + for (int i = 0; i < limite; i+=5) { + System.out.println("Múltiplo de 5: " + i); + } + } + + /** + * Mostrar una tabla de multiplicar + */ + public static void tablaMultiplicar () { + int factor = Integer.parseInt(JOptionPane.showInputDialog("Introduzca número"));; + + for (int i = 1; i < 11; i++) { + System.out.println(i + " x " + factor + " = " + (i * factor)); + } + } + + + /** + * Obtener el mayor de varios números + */ + public static void mayorDeUnaSerieDeNumeros () { + int mayor = 0, num = 1; + + for (int i = 0; num != 0; i++) { + if (i == 0) { // Estoy en la primera iteración del bucle + mayor = Integer.parseInt(JOptionPane.showInputDialog("Introduzca número: ")); + } + else { + num = Integer.parseInt(JOptionPane.showInputDialog("Introduzca número: ")); + if (num > mayor && num!= 0) { + mayor = num; + } + } + } + System.out.println("El mayor introducido es: " + mayor); + } + + + /** + * Realizar factorial de un número + */ + public static void factorial () { + Scanner sc = new Scanner(System.in); + System.out.println ("Introduzca el número cuyo factorial desea conocer: "); + int factorial = sc.nextInt(); + + for (int i = factorial-1; i > 1; i--) { + factorial *= i; + } + + System.out.println("El valor del factorial equivale a " + factorial); + } + + + + /** + * Obtener números primos + */ + public static void numerosPrimos () { + + + for (int num = 1; num < 1000000; num++) { + boolean esPrimo = true; + + for (int i = 2; i < num; i++) { + if (num % i == 0) { + esPrimo = false; + } + } + + if (esPrimo == true) { + System.out.println(num + " es primo"); + } + } + + } + + + + + + + + + + + + + +} diff --git a/src/tutorialJava/capitulo3_bucles/Ejemplo02_Bucle_While.java b/src/tutorialJava/capitulo3_bucles/Ejemplo02_Bucle_While.java new file mode 100644 index 0000000..03b61b5 --- /dev/null +++ b/src/tutorialJava/capitulo3_bucles/Ejemplo02_Bucle_While.java @@ -0,0 +1,67 @@ +package tutorialJava.capitulo3_bucles; + +import tutorialJava.Utils; + +public class Ejemplo02_Bucle_While { + + /** + * + * @param args + */ + public static void main (String args[]) { + pedirNumerosAlUsuario(); + } + + + /** + * + */ + public static void cuentaAdelanteYCuentaAtras() { + int i; + + // Cuenta adelante + i = 0; + while (i < 10) { + System.out.println("Valor de i: " + i); + i++; + } + + // Cuenta atr�s + i = 10; + while (i >= 0) { + System.out.println("Valor de i: " + i); + i--; + } + } + + + /** + * + */ + public static void pedirNumerosAlUsuario () { + int numero = -1; + + while (numero != 0) { + System.out.println("Por favor, introduzca un n�mero (0 para terminar): "); + numero = Utils.obtenerEntero(); + } + System.out.println("Fin de la petici�n de n�meros"); + } + + + /** + * + */ + public static void pedirNumerosAlUsuarioYObtenerSuma () { + int numero = -1, acumulador = 0; + + while (numero != 0) { + System.out.println("Por favor, introduzca un n�mero (0 para terminar): "); + numero = Utils.obtenerEntero(); + acumulador += numero; // igual a acumulador = acumulador + numero; + } + System.out.println("Suma de todos los n�meros: " + acumulador); + } + + +} diff --git a/src/tutorialJava/capitulo3_bucles/Ejemplo03_Bucle_DoWhile.java b/src/tutorialJava/capitulo3_bucles/Ejemplo03_Bucle_DoWhile.java new file mode 100644 index 0000000..643abcd --- /dev/null +++ b/src/tutorialJava/capitulo3_bucles/Ejemplo03_Bucle_DoWhile.java @@ -0,0 +1,51 @@ +package tutorialJava.capitulo3_bucles; + +import tutorialJava.Utils; + +public class Ejemplo03_Bucle_DoWhile { + + /** + * + */ + public static void cuentaAdelante () { + int i; + + i = 0; + do { + System.out.println("Valor de la i: " + i); + i++; // Equivalente a i += 1 o i = i + 1 + } while (i < 11); + } + + + /** + * + */ + public static void cuentaAtras () { + int i; + + i = 10; + do { + System.out.println("Valor de la i: " + i); + i--; + } while (i > -1); + + } + + + + /** + * + */ + public static void pedirNumerosAlUsuario () { + int numero; + + do { // Vas a ejecutar las instrucciones del bucle al menos una vez. + System.out.println("Por favor, introduzca un n�mero (0 para terminar): "); + numero = Utils.obtenerEntero(); + } while (numero != 0); + + System.out.println("Fin de la petici�n de n�meros"); + } + +} diff --git a/src/tutorialJava/capitulo4_Arrays/Ej01_EjemploArraysPrimitivos.java b/src/tutorialJava/capitulo4_Arrays/Ej01_EjemploArraysPrimitivos.java new file mode 100644 index 0000000..f2bdc42 --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/Ej01_EjemploArraysPrimitivos.java @@ -0,0 +1,102 @@ +package tutorialJava.capitulo4_Arrays; + +import java.util.Scanner; + +public class Ej01_EjemploArraysPrimitivos { + + /** + * Método principal + * @param args + */ + public static void main(String[] args) { + primerEjemploArray(); +// segundoEjemploArray(); +// tercerEjemploArray(); + } + + + /** + * Ejemplo de declaración de un array, inicialización de valores al azar y mostrar el array en consola + */ + public static void primerEjemploArray () { + // Declaración del array, a través de la sentencia "new" + int numeros[] = new int[5]; + + // Inicialización de los valores del array + for (int i = 0; i < numeros.length; i++) { + numeros[i] = (int) Math.round(Math.random() * 100); + } + + // Recorrido del array para imprimir sus valores en pantalla + for (int i = 0; i < numeros.length; i++) { + System.out.print(numeros[i] + " "); + } + } + + + /** + * Ejemplo de una segunda forma de crear un array, en este caso lo creamos con unos valores directamente, en + * lugar de inicializarlo con valores al azar. + */ + public static void segundoEjemploArray() { + // Otra forma de inicializar el array + int array2[] = new int[] {88, 89, 90, 4, 5, 6, 7, 8, 9, 10}; + + // Recorrido del array para imprimir sus valores en pantalla. + // Este tipo de bucle se conoce como "for each". + for (int valorDentroDeArray : array2) { + System.out.println(valorDentroDeArray); + } + } + + + /** + * Método que crea e inicializa un array con 100 elementos al azar entre 0 y 100. + * Después calcula la suma, la media, el mayor y el menor de todos. + */ + public static void tercerEjemploArray() { + int suma = 0, mayor, menor; + float media; + + // Declaración del array + int array[] = new int[1000000]; + + // Recorro para inicializar el array + for (int i = 0; i < array.length; i++) { + array[i] = (int) Math.round(Math.random()*10000); + } + + // Recorro e imprimo en pantalla + for (int i = 0; i < array.length; i++) { + System.out.print(array[i] + " "); + } + System.out.println(""); + + // Recorro para obtener la suma + for (int i = 0; i < array.length; i++) { + suma += array[i]; + } + // Calculo la media + media = suma / ((float) array.length); + + // Mayor y menor + mayor = array[0]; + menor = array[0]; + for (int i = 1; i < array.length; i++) { + if (array[i] > mayor) mayor = array[i]; + if (array[i] < menor) menor = array[i]; + } + + // Impresión de resultados + System.out.println("suma: " + suma + " - media: " + media + + " - mayor: " + mayor + " - menor: " + menor); + } +} + + + + + + + + diff --git a/src/tutorialJava/capitulo4_Arrays/Ej02_OrdenacionDeUnArray.java b/src/tutorialJava/capitulo4_Arrays/Ej02_OrdenacionDeUnArray.java new file mode 100644 index 0000000..9f2d5fd --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/Ej02_OrdenacionDeUnArray.java @@ -0,0 +1,44 @@ +package tutorialJava.capitulo4_Arrays; + +public class Ej02_OrdenacionDeUnArray { + + public static void main(String[] args) { +// int array[] = new int[] {50, 100, 23, 2, 48, 66, 4}; + int array[] = new int[100]; + + for (int i = 0; i < array.length; i++) { + array[i] = (int) Math.round(Math.random() * 1000); + } + + + for (int i = 0; i < array.length; i++) { + System.out.println("Voy con la posición i=" + i); + // Simplemente muestro el array + System.out.print("El array está así: "); + for (int j = 0; j < array.length; j++) { + System.out.print(array[j] + " "); + } + System.out.println(""); + + + // Empieza el algoritmo de ordenación de un intervalo desde + // el valor de "i" hasta el final del array + int indiceMenor = i; + for (int j = i+1; j < array.length; j++) { + if (array[j] < array[indiceMenor]) { + indiceMenor = j; + } + } + + // Intercambio de variables + if (i != indiceMenor) { + int aux = array[i]; + array[i] = array[indiceMenor]; + array[indiceMenor] = aux; + } + + + } + } + +} diff --git a/src/tutorialJava/capitulo4_Arrays/Ej03_EjemploMatrices.java b/src/tutorialJava/capitulo4_Arrays/Ej03_EjemploMatrices.java new file mode 100644 index 0000000..8e58467 --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/Ej03_EjemploMatrices.java @@ -0,0 +1,30 @@ +package tutorialJava.capitulo4_Arrays; + +import tutorialJava.Utils; + +public class Ej03_EjemploMatrices { + + public static void main(String[] args) { + int m[][] = new int[4][3]; + int m2[][] = new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}}; + + int cont = 1; + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { +// m[i][j] = (int) Math.round(Math.random() * 100); + m[i][j] = cont; + cont++; + } + } + + m[0][2] = 1; + + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { + System.out.print(m[i][j] + " "); + } + System.out.println(); + } + + } +} diff --git a/src/tutorialJava/capitulo4_Arrays/Ej04_ComoHacerEjerciciosMatrices.java b/src/tutorialJava/capitulo4_Arrays/Ej04_ComoHacerEjerciciosMatrices.java new file mode 100644 index 0000000..751d976 --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/Ej04_ComoHacerEjerciciosMatrices.java @@ -0,0 +1,84 @@ +package tutorialJava.capitulo4_Arrays; + +import java.util.Iterator; + +import tutorialJava.Utils; + +public class Ej04_ComoHacerEjerciciosMatrices { + + /** + * + * @param args + */ + public static void main(String[] args) { + int m[][] = new int[][] { {1, 2, 3, 4, 0}, + {5, 6, 0, 8, 9}, + {10, 0, 12, 13, 14}, + {0, 16, 17, 18, 19}, + {20, 21, 22, 0, 24} }; + +// inicializaMatrizAlAzar(m); + imprimeMatriz(m); + System.out.println("Es positiva: " + esMatrizPositiva(m)); + } + + + /** + * + * @param m + */ + public static void inicializaMatrizAlAzar(int m[][]) { + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { + m[i][j] = (int) Math.round(Math.random() * 100); + } + } + } + + /** + * + * @param m + */ + public static void imprimeMatriz(int m[][]) { + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { + System.out.print(m[i][j] + "\t"); + } + System.out.println(); + } + } + + + /** + * + * @param m + * @return + */ + public static boolean esMatrizPositiva(int m[][]) { + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { + if (m[i][j] < 0) { + return false; + } + } + } + return true; + } +} + + + + + + + + + + + + + + + + + diff --git a/src/tutorialJava/capitulo4_Arrays/Ej05_InicializarMatrizSinRepetirValores.java b/src/tutorialJava/capitulo4_Arrays/Ej05_InicializarMatrizSinRepetirValores.java new file mode 100644 index 0000000..06180a9 --- /dev/null +++ b/src/tutorialJava/capitulo4_Arrays/Ej05_InicializarMatrizSinRepetirValores.java @@ -0,0 +1,33 @@ +package tutorialJava.capitulo4_Arrays; + +import tutorialJava.Utils; + +public class Ej05_InicializarMatrizSinRepetirValores { + + public static void main(String[] args) { + + int m[][] = new int[5][5]; + + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { + int num; + do { + num = Utils.obtenerNumeroAzar(0, 100); + } while (valorEstaEnMatriz(num, m)); + m[i][j] = num; + } + } + } + + + public static boolean valorEstaEnMatriz (int valor, int m[][]) { + for (int i = 0; i < m.length; i++) { + for (int j = 0; j < m[i].length; j++) { + if (valor == m[i][j]) { + return true; + } + } + } + return false; + } +}