Curso de Java

Eclipse

Es el editor de código más concretamente IDE (Integrated development Enviroment) que vamos a usar.

Descarga

Existen otros:

De código libre:

• Netbeans
• BlueJ
• Dr. Java
• Spring Toolsuite
• jGRASP

De código propietario

• IntelliJIDEA
• JCreator
• Jbuilder

¿Qué es Java?

• Lenguaje de programación orientado a objetos.
• Creado por la empresa Sun Microsystems, actualmente es propiedad de Oracle.
• Su base es el lenguaje C++.
• Diseñado para ser independiente de la plataforma de ejecución.

Descarga de Workspace

Denominación

Desde v1.2 hasta v1.5 se denominó “Java 2” y se dividió en:

• Java 2 Platform Standard Edition (J2SE) . Es la base para todas
• Java 2 Platform Enterprise Edition (J2EE).
• Java 2 Platform Mobile/Micro Edition (J2ME).

A partir de la versión 5, quita el 2 de su nombre.

• Java Platform, Standard Edition, Java SE.
• Java Platform, Enterprise Edition, Java EE.
• Java Platform, Mobile Edition, Java ME.

Tipos de aplicaciones Java:

• Aplicación Standalone (escritorio)
  • Programa ejecutado en local mediante la JVM.
  • No requiere navegador para su ejecución.
• Applet
  • Integrados dentro de una página Web.
  • El applet y la Web se ejecutan de forma local.
• Servlet
  • Programa ejecutado en servidor
  • Responde a las peticiones realizadas en la web.

La máquina Virtual Java (JVM)

1. El código fuente se escribe en un archivo de texto plano con extensión Java.
2. El código es compilado a archivos .class que contienen bytecodes. En el caso de Eclipse, estos ficheros se almacenan en la carpeta bin del proyecto.
3. Al ejecutar, la aplicación es interpretada por la JVM, transformando los bytecodes en código nativo para el tipo de procesador.

La Máquina Virtual Java es el intérprete Java, es decir, es el mecanismo que reconoce el bytecode. Es propia de cada máquina.

El bytecode es independiente de la plataforma y es la JVM la que lo transforma.

JDK (Java Development Kit)

Llamado SDK hasta la versión 5. Luego, JDK.

El JDK se compone de:

• Compilador java (ejecutable javac), documentación, bibliotecas, herramientas y ejemplos para el desarrollo.
• JRE (Java Runtime Enviroment, la máquina virtual). Es lo único que necesitan los clientes para ejecutar sus aplicaciones Java.

Links de interés

API de Java:
http://docs.oracle.com/javase/6/docs/api/

Descarga de la API de Java:
http://www.oracle.com/technetwork/java/javase/downloads/index.html#docs

Ejemplos de uso:
http://www.programcreek.com/java-api-examples/?action=index

Certificación:

Consta de 77 preguntas tipo test. Debemos acertar un 65% de las respuestas correctas. La duración del examen es 2h 30′ y tiene un coste de 212€.

• testking.com
• test-king.com

Buscador de centros homologados para certificarse

Aplicación con preguntas similares a las de la certificación

Resolución de problemas

Precisaremos capacidad de abstracción.

Abstracción:Capacidad que permite representar las características esenciales (atributos y propiedades) de un objeto sin preocuparse de las restantes características (no esenciales).

Ejemplo: Tenemos un grupo de gatitos que o están jugando o están durmiendo. Queremos pasar este situación al mundo de la programación.

1. Análisis del problema
   • Conocer los datos de entrada y salida
   • Entender como se realiza la transformación
   • 
2. Construcción del algoritmo
   • Se puede expresar mediante gráficos o pseudocódigo
   • 
3. Codificación (programar)
   • Creamos el código fuente

   • Gato.javapublic class Gato{
     	String nombre;
     	int edad;
     
     	public void jugar(){
     		...
     	}
     	public void dormir(){
     		...
     	}
     }

4. Compilar
   • Traducimos el código fuente a código máquina, que será entendido por el ordenador.

Clases

Plantilla o molde a partir de la cual se construye un objeto. Una clase contiene:

• atributos: propiedades de los objetos (edad, marca, altura, peso…)
• métodos: acciones que pueden realizar los objetos (corrar, saltar, traducir, pensar…)

public class Gato{
	String nombre;
	int edad;

	public void jugar(){
		...
	}
	public void dormir(){
		...
	}
}

<modificador> class <NombreClase>{
	// Declaración de atributos
	<modificador> <tipo> <atributo>;
	// Declaración de métodos
	<modificador> <tipo> <método> (<args>){
		... 
	}
}

	

Objetos

Se podría decir que un objeto (o instancia de una clase) es una clase con valores concretos.

Clase:

Objeto;

Nomenclatura

• Paquetes: estoesunpaquete
• Clases, interfaces y constructores: EstoEsUnaClase
• Métodos: estoEsUnMetodo()
• Variables: estoEsUnaVariable
• Constante: ESTO_ES_UNA_CONSTANTE

Hola Mundo

public class Programa {
	
	public static void main(String[] args) { // Este método es el punto de inicio de toda aplicación JSE

		System.out.println("Hola");
	
	}
}

System.out.println();
Nos permite escribir trazas en la consola.

El atajo para ejecutar una aplicación J2SE en eclipse es:
alt + shift + x + j

En eclipse, escribiendo:

• sysout y pulsando ctrl+espacio se nos escribe automáticamente la línea: System.out.println()
• main y pulsando ctrl+espacio se nos escribe automáticamente el método public static void main.

Comentarios

public class B_comentarios {
	public static void main(String[] args) {
		//Esto es un comentario de una sola linea
		/*
		 * Y esto un comentario de varias lineas
		 * */
		System.out.println("Hola Mundo2");
	}
}

Output:
Hola Mundo2

Variables

Una variable es un espacio de memoria cuya información puede variar durante la ejecución de la aplicación.

En java las variables son altamente tipadas.

Declaración:int n;
int a,b,c;
<tipo> <identificador>; 
<tipo> <identificador_1>,  <identificador_2>...;

Asignación:numero = 42;
<variable> = <expresión>;

La parte izquierda será una variable

La parte derecha puede ser un literal, una variable, una función o una combinación de todos.

Ejemplos:public class Variables {
	public static void main(String[] args) {
		String cadena = "Soy una cadena";
		int i = 5;
		int j = 3;
		System.out.println(cadena);
		System.out.println(i+" + "+j);
		System.out.println(i+j);
		System.out.println(""+i+j);
	}
}

Output:
Soy una cadena
5 + 3
8
53

Tipos de variables:

Primitivas:

• Sus valores se almacenan en el Stack.
• int i = 1; Crea una variable en el stack que con el nombre i le pone en binario el valor 1.
• Sólo puedo acceder al valor de i utilizando el nombre de la variable.

Referencias a objetos.

• Sus valores se almacenan en el Heap.
• La variable contiene la dirección en memoria del objeto, y no el propio objeto. Por tanto, es posible modificar un objeto mediante diferentes variables.

Stack y Heap: son dos zonas de memoria diferentes en la JVM.

Ej:
int i = 3;
StringBuffer cadenaModificable = new StringBuffer(“Pepe”);

Características de las variables primitivas

Problema de conversión de tipos

Al convertir la información de un tipo de dato a otro tipo de dato en el que no cabe dicha información, el valor almacenado se verá modificado.

int int_x = 32767;
int int_y = 32768;
int int_z = 32769;
// El rango de un dato de tipo short llega hasta 32767

short short_x = (short) int_x;
short short_y = (short) int_y;
short short_z = (short) int_z;

System.out.println("1 - Conversión a short de 32767: " + short_x);
System.out.println("2 - Conversión a short de 32768: " + short_y);
System.out.println("2 - Conversión a short de 32769: " + short_z);

byte byte_x = (byte) int_x;
byte byte_y = (byte) int_y;
byte byte_z = (byte) int_z;

System.out.println("3 - Conversión a byte de 32767: " + byte_x);
System.out.println("4 - Conversión a byte de 32768: " + byte_y);
System.out.println("5 - Conversión a byte de 100: " + byte_z);

Output:
1 – Conversión a short de 32767: 32767
2 – Conversión a short de 32768: -32768
2 – Conversión a short de 32769: -32767
3 – Conversión a byte de 32767: -1
4 – Conversión a byte de 32768: 0
5 – Conversión a byte de 100: 1

El rango del tipo de dato short es: -32768 to 32767
El rango del tipo de dato byte es: -128 to 127

Casting

Una primitiva grande puede almacenar la información de una de menor tamaño.

Una primitiva pequeña puede almacenar la información de una de mayor tamaño, pero habrá pérdida de información.

El tipo de la variable apuntadora tiene que ser el mismo o más genérico que el tipo de la variable a la que apunta.

Animal animal = new Gato();

Ejercicios variables

1. Declarar una variable ‘i’ de tipo int, una variable ‘d’ de tipo double y una variable ‘c’ de tipo char. Asignar un valor a cada una. Mostrar por pantalla el valor de cada variable utilizando tres llamadas a System.out.println(). Tener en cuenta que:
   1. Para dar valor a una variable de tipo double ponemos una “d” al final del valor.
   2. Para dar valor a una variable de tipo char, esta debe ir entre comillas simples.
   Declarar variables
2. Intercambiar el contenido de dos variables
   Intercambiar variables en Java

   int a = 5;
   int b = 7;
   // aquí hay que poner código
   System.out.println(a); //Debería mostrar 7
   System.out.println(b); //Debería mostrar 5

Constantes

Una constante es un espacio de memoria cuya información no puede variar durante la ejecución del programa.

Van precedidas del modificador final.

Si descomento la línea, obtendré un error.

final double pi = 3.14;
System.out.println(pi);
//pi=5;

Operador de concatenación

String maravilloso = "de mierda";
System.out.println("amor " + "maravilloso");
System.out.println("amor " + maravilloso);

Ejercicio Saludo

Que se muestre un mensaje que diga: “Buenas tardes Jose”, dónde Jose será el valor de una variable.

Operadores aritméticos

System.out.println(7+2);
System.out.println(7-2);
System.out.println(7*2);
System.out.println(7/2);
System.out.println(7%2);

Operadores lógicos o booleanos

System.out.println(7>2);
System.out.println(7<2);
System.out.println(7>=2);
System.out.println(7<=2);
System.out.println(7==2);
System.out.println(7!=2);

Lectura de datos

Lectura del texto introducido por teclado.

Scanner lector = new Scanner(System.in);
System.out.println("Introduzca un texto, por favor: ");
String variable = lector.next();	
System.out.println("Lectura utilizando la clase Scanner: " + variable);

Según el tipo de datos que estemos usando, utilizaremos:

lector.nextInt();
nextFloat();
...

Ejercicios con operadores aritméticos

1. Escribir un programa que calcule el número de segundos que existen en un día. Como todo el mundo sabe, un día tiene 86400 segundos.
   Segundos por día
2. Hacer un conversor de euros a dólares. El usuario introduce una cantidad de euros y obtiene su valor en dólares. Supondremos que un euro son dos dólares
   Conversor euros a dólares
3. El IVA para ciertos artículos es del 21%. Realiza un programa que pida un precio y calcule su precio con IVA.
4. Leer un número entero por teclado y mostrar por pantalla el doble y el triple.
5. Realiza un programa que recoja el ancho y el alto de un rectángulo y calcule el perímetro y el área.
   s
6. Hacer un conversor de grados centígrados a grados Fahrenheit. Para ello deberé multiplicar por 9/5 y sumar 32. Como todo el mundo sabe, 20 grados centígrados son 68 grados Farenheit.
7. Vamos a mandar al usuario la caja de sus sueños. Para ello, debemos solicitarle que introduzca su nombre, el material de la caja que quiere recibir, sus dimensiones, y algún comentario. Debemos concatenar esta información para obtener por consola el siguiente mensaje:
   "[nombre] ha pedido una caja de [material] con unas dimensiones [dimensiones]. [comentario].
   Pablo ha pedido una caja de Madera con unas dimensiones diminutas. Que sea muy bonita

Estructura de control If

int dato1 = 3;
int dato2 = 5;
if(dato2 > dato1){
	System.out.println("dato2 es mayor que dato1");
}

If - else

int dato1 = 3;
int dato2 = 5;
if(dato1 > dato2){
	System.out.println("dato1 es mayor que dato2");
}else{
	System.out.println("Va a ser que no");
}

If – else if

int dato1 = 3;
int dato2 = 5;
if(dato1 > dato2){
	System.out.println("dato1 es mayor que dato2");
}else if(dato2 == dato1){
	System.out.println("va a ser que no");
}else{
	System.out.println("éxito");
}

Ejercicios if

1. Dada una variable que contiene la nota de un examen que va de 0 a 10...
   • Si es mayor que cinco mostrar el texto "Aprobado".
   • Si es igual a cinco, mostrar el texto "Aprobado por los pelos"
   • Si es menor que cinco, mostrar el texto "Suspenso".
2. Declara una variable 'i' de tipo entero y asígnale un valor. Mostrar un mensaje indicando si el valor de 'i' es positivo o negativo, si es par o impar, si es múltiplo de 5, si es múltiplo de 10 y si es mayor o menor que 100. Consideraremos el 0 como positivo. evaluar i

If especial – operador ternario

int a = 5;
int b = 3;

if(a>b){System.out.println("a es mayor que b");}
else{System.out.println("b es mayor que a");}
		
String resultado = (a>b)?"a es mayor que b":"b es mayor que a";
System.out.println(resultado);

Ejercicios operador ternario

1. Declare una variable 'b' de tipo entero y asignarle un valor. Mostrar un mensaje indicando si el valor de 'b' es positivo o negativo. Consideraremos el 0 como positivo. Utiliza el operador condicional (? : ) dentro del println para resolverlo.
2. Declarar una variable 'i' de tipo entero y asignarle un valor. Muestra un mensaje indicando si 'i' es par o impar. Utiliza el operador condicional ( ? : ) dentro del println para resolverlo.

Comparar dos cadenas de texto

String cadena1 = new String("Hola");
String cadena2 = new String("Hola");
String cadena3 = "Adios";
String cadena4 = "Adios";
if (cadena1.equals(cadena2)){
   System.out.println("Son iguales usando el equals");
}
if (cadena1==cadena2){
   System.out.println("Son iguales usando el ==");
}
if (cadena3==cadena4){
   System.out.println("Son iguales usando el = cuando la cadena es creada en un pool");
}

Output:
Son iguales usando el equals
Son iguales usando el = cuando la cadena es creada en un pool

Dado que para objetos se comparan las direcciones de memoria de los mismos, estas no serán iguales puesto que son objetos distintos que almacenan la información en direcciones de memoria distintas.

Cómo convertir una cadena en un entero

String cadena = "3";
Integer numero = Integer.parseInt(cadena);
System.out.println(numero);

Ejercicio calculadora

Hacer una calculadora que determine la operación a realizar por medio de una estructura de control if.

La calculadora debe hacer uso de los operadores aritméticos +, -, * y /.

Estructura de control: Switch

A partir del JDK 7 puede recibir como parámetro un String, antes, no

char opcion = 'b';
switch(opcion){
	case 'a':
		System.out.println("Solucion1");
	break;
	case 'b':
		System.out.println("Solucion2");
	break;
	default:
		System.out.println("default");
}

Nota: Para evaluar cadenas de texto (String) en vez de letras (char), pondré estos caracteres entre comillas dobles en vez de simples.

Output:
Solucion2

Ejercicio – Hacer una calculadora con switch

Hacer una calculadora que determine la operación a realizar por medio de una estructura de control switch.

La calculadora debe hacer uso de los operadores aritméticos +, -, *, / y

Estructura de control: bucle for

for(int i=0; i<10;i++){
	System.out.println(i);
}

0
1
2
3
4
5
6
7
8
9

Ejercicios bucle for

1. Imprimir los números pares que hay dentro de los 100 primeros números naturales.

   Nota: No utilizar la estructura de control if para resolver este ejercicio.

2. Imprimir los números pares que hay dentro de los 100 primeros números naturales

   Utilizaremos el operador % para separar los pares de los impares.

   Nota: El operador “%” nos da el resto de dividir un número entre otro.
   Ej: 7%2=1

3. Imprimir los números del 1 al 20.

   • Para números divisibles por 3, imprimir “Fizz”.
   • Para números divisibles por 5, imprimir “Buzz”.
   • Para números divisibles por 3 y 5, imprimir “FizzBuzz”.
   • En cualquier otro caso, imprimir el número.

   Notas:

   if(i>5 && i<7) 		//¿i es mayor que 5 y menor que 7?
   if(i==5 || i== 3) 	//¿i es igual a 5 o igual a 3?

4. Adivinar el número secreto. En cada iteración del bucle for, se le preguntará al usuario cuál es el número secreto (un número del 1 al 5). Si al cabo de tres intentos no lo ha acertado, el usuario pierde. Si lo acierta, gana.

   

   Notas:

   Para romper la repetición de un bucle, podemos utilizar el comando break;

Estructura de control: bucle while

String quieroJugar = "si";
while(quieroJugar.equals("si")){
	...
	System.out.println("¿Quieres seguir jugando?");
	quieroJugar = scanner.next();
}

int i = 0;
while(i<10){
	System.out.println(i);
	i++;
}

Output:
0
1
2
3
4
5
6
7
8
9

Ejercicios bucles

1. Repetir el juego del número secreto, pero ahora después de jugar se le preguntará al usuario si desea seguir jugando. Si no desea seguir jugando la variable booleana "quieroJugar" que evalúa el bucle while valdrá false, con lo cual termina el juego.

2. Calcular utilizando un bucle for, la enésima potencia de un número. Debemos recoger del usuario la base y el exponente. La 4ª potencia será:
   2 x 2 x 2 x 2 = 16

   

3. El usuario debe introducir su nombre, en el caso de que haya introducido información, se le preguntará si los datos son correctos. Si responde que sí, se le indicará que puede seguir con el exámen. Si responde que no, volveremos a la pregunta inicial. En caso de que al principio de todo no hubiese escrito nada, se mostrará un mensaje con la palabra "error"

   

4. El factorial de un número entero positivo se define como el producto de todos los números naturales anteriores o iguales a él. Se escribe n!, y se lee "n factorial". (Por definición el factorial de 0 es 1: 0!=1) Por ejemplo, 5! = 5·4·3·2·1 = 120

   

   Variaciones del ejercicio para los que terminen antes : Este ejercicio se puede resolver, en general, de cuatro formas diferentes, con un bucle for, con un bucle while, y multiplicando los factoriales de mayor a menor o de menor a mayor.
5. Mostrar la tabla de multiplicar de un número. Usaremos un bucle for.
6. Mostrar la tabla de multiplicar de los números del 1 al 9. Usaremos dos bucles anidados.
7. Leer números hasta que el usuario introduzca un -1 y contar cuántos acaban en 2.

Métodos

Son funciones aplicadas a objetos.

Una función es un subprograma que realiza una tarea específica y devuelve un valor

Métodos para trabajo con cadenas

String nombre = "Rodolfo";
System.out.println(nombre.substring(0, 3));
System.out.println(nombre.indexOf('d'));
System.out.println(nombre.toUpperCase());
System.out.println(nombre.toLowerCase());
System.out.println(nombre.length());

Output:
Rod
2
RODOLFO
rodolfo
7

Ejercicio con cadenas de texto

1. En el texto "Dábale arroz a la zorra el Abad", contar el número de veces que aparece la letra "a". Usaremos una estructura "if" con substring e equals que irá dentro de un bucle for.

Método que no devuelve nada (void), sin parámetros

public class MetodoNoDevuelveNada {

	public void saludar(){
		System.out.println("Buenas tardes!");
	}

	public static void main(String[] args) {
		MetodoNoDevuelveNada metodoNoDevuelveNada;
		metodoNoDevuelveNada = new MetodoNoDevuelveNada();
		metodoNoDevuelveNada.saludar();
		
		//La siguiente línea daría error porque el método no devuelve nada
		//String valorDevuelto = MetodoNoDevuelveNada.saludar();
	}
}

Método que no devuelve nada, con parámetros

public class Main {

	public void saludar(String nombre){
		System.out.println("Buenas tardes " + nombre + "!");
	}
	public static void main(String[] args) {
		Main main = new Main();
		main.saludar("Juan");
		//La siguiente línea daría error porque el método no devuelve nada
		//String valorDevuelto = b_metodoNoDevuelveNada.saludar("Juan");
	}
}

Ejercicios con funciones

Resolveremos los siguientes ejercicios definiendo una función con parámetros de entrada y que siempre devolverá un valor que procesaremos en la clase main,

1. Crear y llamar a una función que recibe un número y calcula su cubo.
2. Crear y llamar a una función que recibe la velocidad en Km/hora y la muestre en metros/hora.
3. Crear y llamar a una función que recibe el ancho y el alto de un rectángulo y calcula su perímetro.
   Perímetro: 2*ancho + 2*alto
   Cuando una función recibe varios parámetros, estos irán separados por coma. Ejemplo:

   calculaPerimetro(int alto, int ancho);
4. Crear y llamar a una función que recibe la base y la altura de un triángulo y calcula su área.
   Area triángulo = base*altura/2
5. Utilizando estas dos funciones:
   • calculaPerimetro(int radio);
     Perímetro de la circunferencia = 2*PI*Radio
   • calculaArea(int radio);
     Area de la circunferencia = PI*Radio²
   Leer por teclado el valor del radio de una circunferencia y mostrar por pantalla su perímetro y area.
6. Repetir el ejercicio de la calculadora utilizando funciones para las operaciones aritméticas. Debemos declarar 4 funciones con dos parámetros de entrada cada una: suma(int a, int b), resta(int a, int b,), multiplicacion(int a, int b), division(int a, int b).

Métodos que devuelven algo

Nativos de Javaint valor = lector.nextInt();

//Esta línea da error porque no podemos almacenar en una variable lo que devuelve el método println, ya que no devuelve nada	
String valor2 = System.out.println("hola");

Desarrollados por nosotrospublic class Main {
	public String saludar(String parametroEntrada){
		String respuesta = "Buenas tardes " + parametroEntrada;
		return respuesta;
	}
	public static void main(String[] args) {
		Main main = new Main();
		String valorDevuelto = main.saludar("Juan");
		System.out.println(valorDevuelto);
	}
}

Ejercicios return

Repetir los 6 ejercicios anteriores, pero añadiendo un return a las funciones y utilizando el valor que estas devuelven.

Ejercicio coste viaje

A lo largo de este ejercicio, deberemos programar 3 funciones:

• costeHotel()
• costeAvion().
• costeAlquilerCoche().

Ejercicio - coste hotel

Además del public static void main que te paso más bajo, crea una función llamada costeHotel() que recibe como parámetro el número de noches. La función debe devolver cuanto es necesario pagar teniendo en cuenta que cada noche cuesta 140 euros.

public static void main (String [] args){
	Scanner scanner = new Scanner(System.in);
	System.out.println("Introduzca el número de noches: ");
	int numNoches = scanner.nextInt();

	CosteViaje costeViaje = new CosteViaje();
	int resultado1 = costeViaje.costeHotel(numNoches);
	int sumaCostes = resultado1;
	System.out.println("Coste total: " + sumaCostes);
}

Ejercicio – Coste avión

La función costeAvion() tiene como parámetro de entrada el nombre de la ciudad. El coste corresponderá al indicado en la siguiente tabla.

Los costes por ciudad son los siguientes:
"Oviedo": 15
"Tokyo": 700
"Madrid": 90
"Barcelona": 90

Ejercicio – Coste alquiler coche

La función costeAlquilerCoche() tiene como parámetro de entrada el número de noches y devolverá un coste en función de dicho parámetro, teniendo los siguientes aspectos en cuenta:

• Cada día de alquiler cuesta 40 €.
• Si alquilas un coche por 3 días o más, obtienes un descuento de 20€ sobre el total.
• Si alquilas un coche por 7 días o más, obtienes un descuento de 50€ sobre el total (no acumulable con los 20€ de haber alquilado por más de 3 días).

Colección de ejercicios

Ver colección de ejercicios.

Ver el código fuente de los ejercicios.

Paso de parámetros

• Por referencia: cuando paso la dirección del dato.
• Por valor: cuando paso el dato.

En Java se pasa siempre por valor, pero:

• cuando paso un objeto, paso una dirección de memoria.
• cuando paso una primitiva, paso directamente su valor.

public class PasoParametros {
    public static void modificaLetra(char letraParam) {
        letraParam = 'A';
    }
    public static void modificaStringBuffer(StringBuffer stringBufferParam) {
        stringBufferParam.append("C");
    }
    public static void modificaLetras(char[] letrasParam) {
        letrasParam[0] = 'A';
    }
    public static void modificaPalabras(String[] palabrasParam) {
        palabrasParam[0] = "B";
    }
    public static void modificaString(String stringParam) {
        stringParam = "B";
    }
    public static void main(String[] args) {
        char letra = 'a';
        StringBuffer stringBuffer = new StringBuffer("c");
        char[] letras = {'a'};
        String[]palabras = {"b"};
        String string = "b";

        modificaLetra(letra);
        modificaStringBuffer(stringBuffer);
        modificaLetras(letras);
        modificaPalabras(palabras);
        modificaString(string);

        System.out.println("La nueva letra vale: " + letra);
        System.out.println("El nuevo stringBuffer vale: " + stringBuffer);
        System.out.println("El nuevo letras vale: " + letras[0]);
        System.out.println("El nuevo palabras vale: " + palabras[0]);
       
        System.out.println("El nuevo String vale: " + string);
    }
}

Output:
La nueva letra vale: a
El nuevo stringBuffer vale: cC
El nuevo letras vale: A
El nuevo palabras vale: B
El nuevo String vale: b

Métodos static

No precisan de una instancia para ser invocados.

public class G_metodosStatic {
	public static void saludar(String nombre){
		System.out.println("Hola " + nombre);
	}
	public static void main(String[] args) {
		G_metodosStatic.saludar("Pepe");
	}
}

Si llamo a un método static desde una instancia, me da un warning, pero compila.

public class H_notaMetodosStatic {
	public static void saludar(String nombre){
		System.out.println("Hola " + nombre);
	}
	public static void main(String[] args) {
		G_metodosStatic g_metodosStatic = new G_metodosStatic();
		g_metodosStatic.saludar("Pepe");
	}
}

Los métodos static no pueden usar las características no static de una clase.

public class I_notaMetodosStaticII {

	String variableNoEstatica = null;
	public static void saludar(String nombre){
		variableNoEstatica = "Rodolfo";
	}
}

Ejercicio

Rehacer la calculadora, pero convirtiendo sus cuatro métodos en static.

Tipos de variables por su posición

public class VariablesSegunPosicion {
	/*
	* VARIABLES MIEMBRO O DE INSTANCIA
	* 
	* - Se crean al hacer una instancia de la clase.
	* - Se destruyen cuando el garbage colector destruye dicha instancia. 
	* - Si no las inicializo, se inicializan solas, ya sea con el valor 0 o null según el caso.
	* 
	*/
	
	String variableMiembro;
	
	public void metodo(){
		/*
		*VARIABLES LOCALES O AUTOMATICAS
		* 
		* - Se crean cuando se lee su línea en el método. 
		* - Se destruyen cuando termina de leerse dicha variable.
		* - Debo inicializarlas para poder usarlas.
		*
		*/	
		
		String variableAutomatica=null;

		/*
		*VARIABLES DE CLASE
		* 
		* - Usan el modificador static. 
		* - Su valor es compartido por todas las instancias de la clase
		* 
		*/	
		
		String variableAutomatica=null;


	}
}

Variables static

Van precedidas del modificador static.

El modificador static permite acceder a las variables y métodos aunque no tengamos una instancia del objeto que los contiene.

Al contrario que con las variables no static, no habrá una por cada instancia de una clase, sino una para todas las instancias de la clase.

public class VariableStatic {
	static int variableEstatica = 0;
	int variableNoEstatica = 0;
	public static void main(String [] args){
		//Incrementamos la variable estática
		VariableStatic.variableEstatica++;
		VariableStatic.variableEstatica++;

		//Incrementamos la variable no estática
		VariableStatic  variableStatic_1 = new VariableStatic();
		VariableStatic  variableStatic_2 = new VariableStatic();

		variableStatic_1.variableNoEstatica++;
		variableStatic_2.variableNoEstatica++;

		//Mostramos resultados
		
		System.out.println(VariableStatic.variableEstatica);
		System.out.println(variableStatic_1.variableNoEstatica);
		System.out.println(variableStatic_2.variableNoEstatica);
		
	}
}

Arrays

Un array es una colección de datos ordenados del mismo tipo y de longitud fija. Una vez que adjudicamos un tamaño al array, no será posible modificarlo. Hay otro tipo de datos llamado "colecciones" cuya longitud si podré modificar.

public class H_Arrays {
	public static void main(String[] args) {
		String [] dias1 = {"lunes", "martes", "miercoles", "jueves", "viernes", "sabado", "domingo"};
		String [] dias2 = new String[7];
		dias2[0]="lunes";
		dias2[1]="martes";
		dias2[2]="miercoles";
		dias2[3]="jueves";
		dias2[4]="viernes";
		dias2[5]="sábado";
		dias2[6]="domingo";

		System.out.println(dias1[5]);
		System.out.println(dias2[3]);		
	}
}

Al instanciar un array debe quedar definida la longitud del mismo.

Ejercicios arrays

1. Crea un array con cinco nombres de persona y recórrelo con un bucle for mostrando el texto "Conozco a alguien llamado ". Tener en cuenta que la propiedad .length de un array me devuelve el número de elmentos que contiene.
2. Recorrer la siguiente lista con un bucle imprimiendo el doble de cada número:
   myList = {1,9,3,8,5,7}
3. El usuario debe introducir un número correspondiente a cierto mes (un valor entre 1 y 12) y la aplicación debe mostrar el nombre del mes correspondiente a dicho número.
   Para resolver el ejercicio utilizaremos un array de strings dónde cada una de las posiciones del array será cada uno de los meses del año.

Ejercicio – juego del ahorcado

Realizar el juego del ahorcado.

• Al iniciar el programa, este deberá escoger una palabra al azar entre 3. Esta será la palabra secreta que el usuario deberá adivinar.
• el programa contará la cantidad de letras de la palabra escogida y creará ese número de letras (inicialmente con guiones bajos).
• El usuario deberá ir introduciendo letra a letra hasta adivinar la palabra secreta.
• Si el usuario acierta alguna de las letras de la palabra, su correspondiente guión bajo será sustituido por la letra correspondiente.

Será útil tener un array de char en el que iremos guardando cada una de las letras que el usuario vaya acertando.

Ejercicio -tictactoe

Hacer el juego del tres en raya para dos jugadores.

• El tablero será un array de 9 posiciones.
• El método showTablero(String [] tablero); imprimirá el tablero, con las fichas “X” y “O” dónde correspondan.
• El juego tendrá un método juegaPlayer(String ficha, String [] tablero) que recibirá como parámetro de entrada el identificador del jugador ("X" o "O") y dónde se le solicitará al jugador el número correspondiente a la posición dónde quiere mover su ficha ("X" o "O").
• Después de cada tirada, se comprobará si alguien ha ganado, llamando al método evaluateWin(String [] tablero);
• El método evaluateWin(String [] tablero) mediante sucesivos if todas las posibilidades de que un jugador gane.
• Utilizaremos la consola de java para ver el tablero.

Ejercicio – tictactoe solo jugador

El método juegaPlayer1() quedará así:

function juegaPlayer1(){
	board[getComputerMove()] = "X";
}

Por tanto, debemos crear un método getComputerMove() que creará una copia del tablero, moverá la ficha sobre esta copia y en función del resultado decidirá dónde mover en el tablero real. Para realizar el movimiento:

1. Comprobamos si la máquina puede hacer un movimiento y ganar la partida. (utilizaremos el método evaluateWin, creado en el ejercicio anterior).
2. Comprobamos si tras mover, el humano puede hacer un movimiento y ganar la partida.
3. Comprueba si hay alguna esquina libre. Si lo está, la máquina mueve a la esquina.
4. Comprueba si el centro está libre. Si lo está, la máquina mueve al centro
5. Mueve a cualquiera de las casillas restantes.

Modificadores de acceso

Determinan la accesibilidad de una clase, sus variables miembro y métodos.

Pueden ser:

• private

  Las clases no pueden ser private.

  Un elemento private sólo es accesible dentro de la propia clase en que es declarada.

• default (package, o friendly)

  Es el modo de acceso cuando no hay modifier.
  Se puede aplicar a una clase o a sus datos y metodos. Un elemento default sólo es accesible desde clases pertenecientes al mismo package.

• Protected (proteje a los hijos)
  Es menos restrictivo que default
  Un elemento protected sólo es accesible desde clases pertenecientes al mismo package y desde todas las subclases de la clase que la contiene.

  com.pablomonteserin.a.A.javapublic class A{
  	protected void metodoDeA() {
  		System.out.println("hola");
  	}
  }

  com.pablomonteserin.b.B.javapublic class B extends A{
  	void metodoDeB() {
  		B b = new B();
  		b.metodoDeA();
  	}
  }

• public
  Es el modifier "mas generoso"
  Un elemento public puede accederse sin restricciones.

Constructores

Constructor vacío

Generar constructor automáticamente:
Btn dch → Source → Generate Constructor using Fields

public class Main {
	public static void main(String[] args) {
		new MiClase();
	}
}
class MiClase{
	public MiClase(){
		System.out.println("Hola!!!");
	}
}

Output:
Hola!!!

Constructor con parámetros

public class Main {
	public static void main(String[] args) {
		new Persona("Pepe");
		//La siguiente línea genera un error en tiempo de compilación
		//	new Persona();
	}
}

class Persona{
	public Persona(String nombre){
		System.out.println("Hola" + nombre);
	}
}

¿Para qué sirve un constructor?

public class Main {
	public static void main(String[] args) {
		new Persona("Pepe");
	}
}

class Persona{
	String nombre;
	public Persona(String nombre){
		this.nombre = nombre
	}
}

Si no sé cuales son los parámetros que tengo que poner, puedo ponerme sobre el paréntesis de los parámetros y pulsar ctrl + space

Herencia

public class Main{
	public static void main(String[] args) {
		Hijo h = new Hijo();
		h.saludar();
	}
}

class Padre{
	public void saludar(){
		System.out.println("Hola");
	}
}

class Hijo extends Padre{
	
}

Es el mecanismo mediante el cual una clase deriva de otra, de manera que extiende su funcionalidad.

Constructores y herencia

public class Main{
	public static void main(String[] args) {
		new Hijo();
	}
}

class Hijo extends Padre{
	public Hijo() {
		System.out.println("Se ejecuta el hijo");
	}
}

class Padre{
	public Padre(){
		System.out.println("Se ejecuta el padre");
	}	
}

Output:
Se ejecuta el padre
Se ejecuta el hijo

¿Qué se verá por pantalla al ejecutar el siguiente código?

public class Main{
	public static void main(String[] args) {
		Hijo a = new Hijo("hola");
		a.mostrarMensaje();
	}
}

class Hijo extends Padre{
	Hijo(String mensaje){
		super(mensaje);
	}
}

class Padre{
	String mensaje;
	public Padre(String mensaje){

	}	

	void mostrarMensaje(){
		System.out.println(mensaje);
	}
}

Todas las clases que heredan, tienen un constructor que comienza por el método super();. Si yo no escribo este método, el compilador de java lo escribe automáticamente llamando al constructor vacío del padre. Esto puede dar problemas de compilación si el padre no tiene un constructor vacío.

public class MainConError{
	public static void main(String[] args) {
		new Hijo();
	}
}

class Hijo() extends Padre{
	public Hijo(){
		System.out.println("Se ejecuta el hijo");
	}
}

class Padre{
	public Padre(String parametro){
		System.out.println("Se ejecuta el padre");
	}	
}

Ejercicio

Desarrolle una aplicación que contenga las siguientes clases:

El constructor de la clase Persona debe incrementar en una unidad la variable numInstancias.

Desarrolle una clase con el nombre Main, que contenga un método public static void main(String args[]), que al ejecutarse cree dos instancias de empleado y dos de cliente e imprima el total de instancias de persona creadas.

Ejercicio - animales

Implemente las clases del siguiente diagrama.

El método compararSonido() comprueba si el sonido que fue pasado en el constructor es más largo que el sonido almacenado en la variable static "sonidoMasLargo". Si es así, sobrescribe el valor de la variable con el nuevo valor.

Desarrolle una clase con el nombre Main, que contenga un método public static void main(String args[]), que al ejecutarse genere una instancia de Vaca, Perro y Gato pasándoles en el constructor el sonido que deben emitir ("muuuuuu", "guauguau", "miau", por ejemplo). El método "compararSonido" debe ser llamado desde dentro del constructor de la clase Animal.

Luego, imprimir el valor de la variable estática sonidoMasLargo.

Polimorfismo

Es la capacidad de un objeto de adoptar diferentes formas.

Una variable referencia es polimórfica cuando su tipo de declaración no coincide con el tipo del objeto al que referencia.

En Java, esto se consigue gracias a la herencia y las interfaces.

Figura f1 = new Figura("Estandar", "Rojo");

Figura f2 = new Circulo("Verde", 5.0);

2 mecanismos polimórficos: sobrescritura y sobrecarga

public class Main{
	public static void main(String[] args) {
		Hijo.sobreEscritura("Se bienvenido ", "Pablo");
		Hijo.sobreCarga( 3 );
	}
}
class Papa{
	public static void sobreEscritura(String txtBienvenida, String nombre){
		System.out.println(txtBienvenida + nombre);
	}
	public static void sobreCarga(String txtDespedida, String nombre){
		System.out.println(txtDespedida + nombre);
	}
}
class Hijo extends Papa {
	//El tipo devuelto no debe cambiar.
	//los parámetros de entrada no deben cambiar
	//La accesibilidad no será más restrictiva que la del método original.
	//Si el método original es static, el método que hace el override, tambień debe serlo.
	public static void sobreEscritura(String txtBienvenida, String nombre){
		System.out.println(txtBienvenida + "......" + nombre);
	}
	//El tipo de dato devuelto puede cambiar.
	//Los parámetros de entrada deben cambiar.
	//La accesibilidad puede ser más restrictiva que la del método original.
	//El número de checked expections arrojadas debe ser el mismo.
	protected static int sobreCarga(int codigoDespedida){
		System.out.println(codigoDespedida);
		return 4;
	}
	
}

Abstracción

Métodos abstractos

Tenemos una clase "Cosa" que tiene un método "botar". Las clases "Ladrillo" y "Pelota" heredan de "Cosa".

La clase Cosa tiene un método abstracto llamado "botar". Es abstracto porque dependiendo de si instanciamos un ladrillo o una pelota habrá que sobrescribir el código para que bote de una forma determinada.

Un método abstracto es aquel que sólo tiene una declaración y no dispone de cuerpo. Está pensado para ser sobrescrito, luego no es posible utilizar el modificador private con un método abstracto.

Se declaran de la siguiente forma (quitando las llaves del cuerpo de la función y poneindo un ; en su lugar):

public void botar();

Clases abstractas

• Si una clase tiene al menos un método abstracto, dicha clase debe ser abstracta.
• Una clase que herede de una clase abstracta debe implementar todos sus métodos abstractos (no es necesario sobrescribir los métodos no abstractos,)
• Abstracto viene a significar "sin definir".

Ejercicio – animales con clase abstracta

Implemente las clases del siguiente diagrama.

El constructor de la clase Animal llamará a los métodos "establecerSonido()" y "compararSonido()"

El método compararSonido() comprueba si la variable "sonido" es más larga que el sonido almacenado en la variable static "sonidoMasLargo". Si es así, sobrescribe el valor de la variable con el nuevo valor.

El método establecerSonido() debe ser sobreescrito para asignar el valor del sonido que toque a la variable sonido.

Desarrolle una clase con el nombre Main, que contenga un método public static void main(String args[]), que al ejecutarse genere una instancia de cada clase de animal.

Luego, imprimir el valor de la variable estática sonidoMasLargo.

Interface

Una interface es una clase abstracta en la que todos los métodos serán métodos abstractos.

Una clase que implemente una interface también deberá implementar todos sus métodos. Si no deseamos que esto ocurra, podemos añadir a la interface el modificador abstract.

Una variable estática definida dentro de una interfaz será implícitamente definida como constante.

Una interfaz está pensada para ser sobrescrita, luego no tiene sentido utilizar modificadores privados dentro de una interfaz y no están permitidos.

interface Instrument{
	void play();//automáticamente público
}

public class Clase implements Instrument{
	public static void main(String[] args) {
		Clase c = new Clase();
		c.play();
	}
	public void play() {
		System.out.println("Jugar al baloncesto");
	}
}

Ejercicio – animales con interfaz

Implemente las clases del siguiente diagrama.

El método compararSonido() comprueba si el sonido que fue pasado en el constructor es más largo que el sonido almacenado en la variable static "sonidoMasLargo". Si es así, sobrescribe el valor de la variable con el nuevo valor.

Desarrolle una clase con el nombre Main, que contenga un método public static void main(String args[]), que al ejecutarse genere una instancia de cada clase de animal e invoque a sus métodos “compararSonido”.

Luego, deberé imprimir en pantalla el sonido más largo realizado, almacenado en la variable estática sonidoMasLargo.

Clases internas (inner class)

Son aquellas cuya definición está dentro de otra. Una clase interna puede sobrescribir métodos de la clase que la contiene.

public class ClaseExterna {
	private String nombreExt = "Juan";
	class ClaseInterna{
		private String nombreInt = "Pepe";
		public void mostrarNombre(){
			System.out.println(nombreInt);
			System.out.println(nombreExt);
		}
	}
	public void mostrarNombre(){
		System.out.println("Juan");
	}
	public static void main(String[] args) {
		//Puedo acceder a los variables miembro privadas de la clase interna, pero no de la externa
		ClaseExterna claseExterna = new ClaseExterna();
		ClaseInterna claseInterna = claseExterna.new ClaseInterna();
		//Puedo acceder a los metodos de la clase externa
		claseInterna.mostrarNombre();
	}
}

Output:
Pepe
Juan

Clase interna anónima (anonimous inner class)

Se sobrescribe uno o varios métodos de la clase que se está instanciando en una sola operación.

public class C_claseInternaAnonima {
	public static void main(String args[]){
		Comida2 comida = new Comida2() {
			public void comer() {
				System.out.println("Método \"comer\" de la clase Comida2 sobrescrito");
			}
		};
		comida.comer();
	}
}
class Comida2 {
	public void comer() {
		System.out.println("Comiendo");
	}
}

Garbage Collector

Se encarga de liberar memoria asignada a objetos que ya no se utilizan.

El método finalize() define que va a ocurrir cuando un objeto sea recogido por el garbage collector. No suele utilizarse, ya que no podemos determinar cuando se va a ejecutar.

System.gc() sugiere al Garbage Collector que se ejecute, sin embargo esto no asegura que se libere la memoria ocupada por los objetos creados.

public class J_finalize  {
	protected void finalize() {
		System.out.println("Removed");
	}
	public static void main(String[] args) {
		J_finalize finalizeObject = new J_finalize();
		finalizeObject = null;
		System.gc();
	   }
 }

Cuando se que voy a dejar de utilizar un objeto lo igualo a null para que sea elegible por el recolector de basura.

String Performance

Los Strings no se pueden modificar, luego cualquier operación que se haga sobre un String creará uno nuevo.

Por tanto, trabajar con Strings tiene un costo considerable de Performance. Para modificar cadenas de texto usaremos StringBuffer, o a partir de la versión 4.0 de java: StringBuilder.

No se deben concatenar Strings dentro de un bucle. Esto tendría un gran gasto de Performance.

Diferencia performance entre String, StringBuffer y StringBuilder

public class StringPerformance {

	public static void main(String[] args) {
		String s1 = "hola";
		StringBuffer s2 = new StringBuffer("hola");
		StringBuilder s3 = new StringBuilder("hola");
		
		long empieza = System.currentTimeMillis();
		for(int i = 0; i<10000; i++){
			s1 += "hola";
		}
		long final1 = System.currentTimeMillis()-empieza;
		empieza = System.currentTimeMillis();
		for(int i = 0; i < 10000; i++){
			s2.append("hola");
		}
		long final2 = System.currentTimeMillis()-empieza;
		empieza = System.currentTimeMillis();
		for(int i = 0; i <10000; i++){
			s3.append("hola");
		}
		
		long final3 = System.currentTimeMillis() - empieza;
		
		System.out.println("Usando la clase String: " + final1); output: 220
		System.out.println("Usando la clase StringBuffer: " + final2); output: 1
		System.out.println("Usando la clase StringBuilder: " + final3); output: 0
	}
}

Encapsulación

La encapsulación impide la manipulación externa de algunas partes de los objetos.

• Fuerza al usuario a utilizar un método para acceder a los datos.
• Hace que el código sea más fácil de mantener

Esto mejora la estabilidad de la aplicación, ya que el cambio directo de una variable puede afectar al correcto funcionamiento de la misma.

Esto permite un código más reutilizable, ya que este se encuentra encapsulado en módulos independientes.

Para ello declararé los métodos como public y las variables como private.

Ejemplo
Al hacer un pedido, no pueden venir más de 10 paquetes. Por tanto si vienen menos de 10 paquetes el número de paquetes en el almacén se modifica, pero pero si vienen más de 10 saltaría un mensaje de error.

public class E_encapsulamiento {
	public static void main(String[] args){
		Almacen almacen = new Almacen();
		almacen.setNumCajasAlmacen(12);
		System.out.println(almacen.getNumCajasAlmacen());
	}	
}
class Almacen{	
	private int numCajasAlmacen;

	public int getNumCajasAlmacen() {
		return numCajasAlmacen;
	}
	public void setNumCajasAlmacen(int numCajasAlmacen) {
		if(numCajasAlmacen>10){
			System.out.println("No se admiten entregas de más de 10 unidades");
		}else{
			this.numCajasAlmacen = numCajasAlmacen;
		}
	}
}

Generar automáticamente los get y set:
Btn dch → source → Generate Getters and Setters
Ctrl + shift + s → Generate Getters and Setters

POJO (Plain Old Java Object)

• Debe tener al menos un constructor sin argumentos
• Los atributos de la clase deben ser privados
• Dichos atributos deben ser accesibles mediante métodos get y set
• Debe ser serializable

Bean

Es un POJO que además implementa la interfaz serializable.

public class Alumno implements Serializable {
	private String nombre;
	private int edad;

	public String getNombre() {
		return nombre;
	}

	public void setNombre(String nombre) {
		this.nombre = nombre;
	}

	public int getEdad() {
		return edad;
	}

	public void setEdad(int edad) {
		this.edad = edad;
	}

}

Contenedores

Recorrer una colección - Iterator

ArrayList arrayList = new ArrayList();
arrayList.add("vaca");
arrayList.add("perro");
arrayList.add("elefante");

Iterator it = arrayList.iterator();
while(it.hasNext()){
	String cadena =(String) it.next();
	System.out.println(cadena);
}

Genéricos

Fueron introducidos en Java 5.0.

Los tipos genéricos se encuentran incluidos dentro de los caracteres <>. Especifican el tipo de datos que va a almacenar, utilizar o devolver una clase o método.

Genéricos en colecciones

ArrayList <String>arrayList = new ArrayList<String>();
arrayList.add("vaca");
arrayList.add("perro");
arrayList.add("elefante");
Iterator<String> it = arrayList.iterator();
while(it.hasNext()){
	String cadena =it.next();
	System.out.println(cadena);
}

Genéricos en clases

public class Generics {
	public static void main(String[] args) {
		Calculadora<Integer> calculadora = new Calculadora<Integer>();
		calculadora.sumar(4, 5);
	}
}
class Calculadora<E> {
	public void sumar(E e, E e2) {
	}
	public static void sumar2(E e, E e2) {}
}

Un método estático no puede acceder a un tipo de dato genérico. Cuando declaro un objeto de la clase calculadora defino el tipo de dato que va a sustituir al genérico. Sin embargo un método estático es cargado en memoria antes de declarar la clase que lo contiene y por tanto no sabemos que tipo de dato va a sustituir al genérico, ya que este tipo de dato es definido al hacer la declaración

El tipo de dato genérico E (valdría cualquier nombre de clase inexistente) podrá ser sustituido dentro de la clase por una clase de cualquier tipo, que será definido al declarar e instanciar la clase

Caso concreto

Si para usar genéricos en una clase usamos una palabra reservada, los objetos declarados con esa palabra reservada no serán lo que corresponda, sino que serán de tipo Object

class Generics<String> {
	String valor=(String) "elefante";
}

Ejercicio alta, baja, modificación y consulta en un ArrayList

La aplicación consta de 3 clases: Main, Alumno y Servicio.

La clase Alumno tendrá dos propiedades: nombre (String) y edad (int).

Al arrancar la aplicación desde el Main se nos preguntará por la operación que deseamos hacer:

• Insertar un nuevo alumno. Esta opción nos solicita el nombre y la edad del alumno que queremos insertar.
• Eliminar un alumno. Esta opción nos solicita el nombre del alumno que deseamos eliminar.
• Modificar los datos de un alumno. Esta opción nos solicita primero el nombre de alumno para poder identificarlo y luego su nuevo nombre y edad.
• Mostrar todos los alumnos almacenados. Esta opción recorre el ArrayList de alumnos e imprime los nombres de cada uno.

La clase servicio tendrá los métodos nuevoAlumno, eliminarAlumno, modificarAlumno y getAlumnos que realizarán las 4 operaciones antes citadas. Utilizar un ArrayList declarado en la clase Servicio para almacenar la información.

Ejercicio – juego de la oca

Hacer el juego de la oca. El juego constará de una clase Main desde la que se ejecuta el juego y un bean ''Jugador'' con los atributos nombre(String), casilla(int), turnosRestantes(int).

Al comenzar la aplicación se nos solicitará indicar el número de jugadores. Crearemos las instancias de los jugadores pertinentes y los introduciremos en un ArrayList de jugadores. Los jugadores irán tirando el dado y avanzando casillas hasta que alguno llegue a la casilla 63.
Tener en cuenta que:

• las posiciones 5, 9, 14, 18, 23, 27, 32, 36, 41, 45, 50, 54 y 59 corresponde a las ocas. Si el jugador cae en ellas se imprimirá el texto ''De oca a oca y tiro porque me toca'', el jugador avanzará hasta la siguiente casilla de la oca y volverá a tirar.
• si el jugador cae en la casilla 19, caerá en la pensión y no podrá tirar el dado en los dos siguientes turnos.
• si el jugador cae en la casilla 3, caerá en el pozo y no podrá tirar el dado en el siguiente turno.
• si el jugador cae en la casilla 52, caerá en la cárcel y no podrá tirar el dado en los tres siguientes turnos.
• las casillas 6 y 12 son puentes. Si el jugador cae en ellas se imprimirá el texto ''De puente a puente y tiro porque me lleva la corriente''. En este caso, si cayó en la casilla 6 irá a la 12 y si cayó en la 12 irá a la 6. En ambos casos, volverá a tirar.
• las casillas 26 y 53 son dados. Si el jugador cae en ellas se imprimirá el texto ''De dado a dado y tiro porque me ha tocado''. En este caso, si cayó en la casilla 26 irá a la 53 y si cayó en la 53 irá a la 26. En ambos casos se volverá a tirar.
• la casilla 58 es la muerte, el jugador que cae en ella pierde.(aunque en el juego original lo que ocurría era que el jugador debía regresar a la casilla 1).

Recorrer un Map

Transformar un Map en una Collection

Persona persona1 = new Persona("75367834E", "Nombre1");
Persona persona2 = new Persona("68274736E", "Nombre2");
Persona persona3 = new Persona("90497589E", "Nombre3");
		
Map map = new HashMap();
map.put(persona1.getDni(), persona1);
map.put(persona2.getDni(), persona2);
map.put(persona3.getDni(), persona3);
		
Collection collection = map.values();
Iterator it = collection.iterator();
while(it.hasNext()){
	System.out.println(((Persona)it.next()).getNombre());
}

Recuperar un map de forma ordenada

Si el orden me importa; recupero los valores un un Set usando el método keySet();. Luego, recuperaré los valores del map utilizando las claves que acabo de almacenar en el Set.

Persona2 persona1 = new Persona2("75367834E", "Nombre1");
Persona2 persona2 = new Persona2("68274736E", "Nombre2");
Persona2 persona3 = new Persona2("90497589E", "Nombre3");
		
Map map = new HashMap();
map.put(persona1.getDni(), persona1);
map.put(persona2.getDni(), persona2);
map.put(persona3.getDni(), persona3);
		
Set set = map.keySet();
		
Iterator it = set.iterator();
Persona2 persona = null;
while(it.hasNext()){
	String clave = (String) it.next();
	persona = (Persona2) map.get(clave);
	System.out.println(persona.getNombre());
}

Recorrer un Map (2 formas)

//Para cada elemento key del conjunto map.keySet()
for (String key : map.keySet()){
	System.out.println(key + "=> " + map.get(key).getNombre());
}

//1 Entry es un key-value pair
for(Map.Entry<String, Persona3>entry:map.entrySet()){
	String key = entry.getKey();
	Persona3 value = entry.getValue();
	System.out.println(key + "=> " + value.getNombre());
	}
}