feat(chapter to 4): added

.gitignore

@@ -0,0 +1,2 @@
+/bin/
+/.settings

src/org/rmr/tutorial24_25/HolaMundo.java

@@ -1,9 +0,0 @@
-package org.rmr.tutorial24_25;
-
-public class HolaMundo {
-
-	public static void main(String[] args) {
-		System.out.println("Hola Mundo 2");
-	}
-
-}

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

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

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<63>n resolucionEcuacionSegundoGrado, que
+	  resuelve la ecuaci<63>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<63>n es " + a + 
+				"x(2) + " + b + "x + " + c + " = 0");
+		System.out.println("La soluci<63>n x1 es " + x1 + 
+				" y la soluci<63>n x2 es " + x2);
+		
+	}
+	*/
+}

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.
+	}
+}
+
+
+
+
+
+
+
+
+
+

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

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

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

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

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

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

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 ;
+			
+	}
+	
+}
+
+
+
+
+
+
+
+
+

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

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

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<74>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<63>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);
+	}
+	
+	
+}

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<63>n de n<>meros");
+	}
+	
+}

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

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;
+			}
+			
+			
+		}
+	}
+
+}

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

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;
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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;
+	}
+}