Curso de Java

Descargar el JDK

http://www.oracle.com/technetwork/java/javase/downloads/index.html

El JDK se compone de:

• Compilador java
• Máquina virtual

Por otra parte, tenemos:

• JRE: es sólo la máquina virtual

Hola Mundo

		
public class A_holaMundo {
	public static void main(String[] args) {
		String saludo = new String("Hola Mundo!");
		System.out.println(saludo);
		System.out.println(saludolength());
	}
}
		
	

Clases

• Son generadoras de objetos.
• String cadenaDeTexto = new String();
• Por convenio, los nombres de clase comienzan siempre con mayúscula.

Objetos

• Un objeto tiene propiedades y métodos.
• Una persona tiene nombre, edad, altura, etc y puede correr, saltar, agacharse, etc.
• Por convenio, los nombres de los objetos comienzan por minúscula y si tienen un nombre compuesto, utilizan mayúsculas para separar las letras del mismo.

public static void main(String [] args)
Este es el método que contiene el inicio de la aplicación.

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.

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:

• testking.com
• test-king.com

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.

		
public class C_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
		
	

Ejercicio Saludo

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

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.

		
public class F_conversionDeTipos {
	public static void main(String[] args) {
		int x = 32767;
		int y = 32768;
		int z = 32769;
		//El rango de un dato de tipo short llega hasta 32767
		
		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);
		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();

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.

public class G_constantes {
	public static void main(String[] args) {
		final double pi = 3.14;
		System.out.println(pi);
		//pi=5;
	}
}

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.

Estructura de control If

public class A_if {
	public static void main(String[] args) {
		int dato1 = 3;
		int dato2 = 5;
		if(dato2 > dato1){
			System.out.println("dato2 es mayor que dato1");
		}
	}
}

Output:
dato2 es mayor que dato1

	

If - else

If – else if

	
public class C_ifIV {
	public static void main(String[] args) {
		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");
		}
	}
}

Output:
éxito
	

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

Ejercicio if

Dada una variable que contiene cierto valor, evaluar si dicho valor es mayor, igual o menor que cinco. Si es mayor, mostrar el texto "El número es mayor que cinco". Si es igual, mostrar el texto ''El número es igual que cinco''. En caso contrario, mostrar el texto “Es menor que 5”.

Comparar dos cadenas de texto

	
public class E_compararDosCadenas {
	public static void main(String[] args) {
		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 y viceversa

public static void main(String[] args) {
	String cadena = "3";
	Integer numero = new Integer(Integer.parseInt(cadena));
	System.out.println(numero.toString());
}

	

Lectura de datos

Ejercicio – copiar y ejecutar el siguiente código

Leer el contenido de un fichero de texto. Podemos utilizar la clase Scanner o la clase BufferedReader. Cada una tiene sus propios métodos que podrán adecuarse en mayor o menor medida a nuestras necesidades

	
class A_leerFichero{
	public static void main(String [] args) throws IOException{
		Scanner lector1 = new Scanner(new FileReader("src/com/pablomonteserin/otros/archivo.txt"));
		String variable1 = lector1.next();
		System.out.println("Lectura utilizando la clase Scanner: " + variable1);

		BufferedReader lector2;
		lector2 = new BufferedReader(new FileReader("src/com/pablomonteserin/otros/archivo.txt"));
		String variable2 = lector2.readLine();
		System.out.println("Lectura utilizando la clase BufferedReader: " + variable2);
	}
}
	

Ejercicio – copiar y ejecutar el siguiente código

Lectura del texto introducido por teclado.

		
class B_leerTextoIntroducidoPorTeclado{
	public static void main(String [] args) throws IOException{
		System.out.println("Introduzca un texto, por favor: ");
		Scanner lector1 = new Scanner(System.in);
		String variable1 = lector1.next();
		System.out.println("Lectura utilizando la clase Scanner: " + variable1);

		BufferedReader lector2 = new BufferedReader(new InputStreamReader(System.in));
		String variable2 = lector2.readLine();
		System.out.println("Lectura utilizando la clase BufferedReader: " + variable2);
	}
}
		
	

Ejercicio – Hacer una 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

Switch (a partir del JDK 7 puede recibir como parámetro un String, antes, no)

		
public class H_switch {
	public static void main(String[] args) {
		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.

Salida:
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

	
public class K_bucleFor {
	public static void main(String[] args) {
		int i;
		for(i=0; i<10;i++){
			System.out.println(i);
		}
	}
}

0
1
2
3
4
5
6
7
8
9
	

Ejercicio

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

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

Ejercicio

Imprimir los números pares que hay dentro de los 1000 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

Estructura de control: bucle while

		
public class N_bucleWhile {
	public static void main(String[] args) {
		int i = 0;
		while(i<10){
			System.out.println(i);
			i++;
		}
	}
}

0
1
2
3
4
5
6
7
8
9
		
	

Ejercicio bucle while - Calcular el factorial de 5

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

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

		
public class A_metodosCadenas {

	public static void main(String[] args) {
		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
		
	

Método que no devuelve nada (void)

		
public class B_metodoNoDevuelveNada {

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

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

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

		
public class B_metodoNoDevuelveNada_conParametros {

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

Método que devuelve algo

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

Ejercicio

Repetir el ejercicio de la calculadora utilizando funciones para las operaciones aritméticas.

Juego para programar en Java

https://www.codehunt.com/

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

Salida:
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étod 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 J_variablesSegunPosicion {
	/*
	 * VARIABLES MIEMBRO
	 * 
	 * Se crean al hacer una instancia de la clase.
         * S 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 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;
		//La siguiente línea daría error porque la variableAutomatica no se ha inicializado
		//variableAutomatica.charAt(3);
	}
}
		
	

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 Q_variableStatic {
	static int variableEstatica = 0;
	int variableNoEstatica = 0;
	public static void main(String [] args){
		Q_variableStatic  q_variableStatic_1 = new Q_variableStatic();
		Q_variableStatic  q_variableStatic_2 = new Q_variableStatic();
		
		Q_variableStatic.variableEstatica++;
		Q_variableStatic.variableEstatica++;

		q_variableStatic_1.variableNoEstatica++;
		q_variableStatic_2.variableNoEstatica++;
		
		System.out.println(Q_variableStatic.variableEstatica);
		System.out.println(q_variableStatic_1.variableNoEstatica);
		System.out.println(q_variableStatic_2.variableNoEstatica);
		
	}
}
	

Ejercicio – juego del ahorcado

Realizar el juego del ahorcado.

• Al iniciar el programa, este deberá escoger una palabra al azar entre 10. 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 – 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), marcador(int), turnosRestantes(int).

Al comenzar la aplicación se nos solicitará indicar el número de jugadores. Los jugadores irán tirando el dado y avanzando casillas hasta que alguno llegue a la casilla 60.
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 62, 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).

Ejercicio -tictactoe

Hacer el juego del tres en raya para dos jugadores.

• El tablero será un array de 9 posiciones.
• El juego tendrá sendos métodos juegaPlayer1() y juegaPlayer2() dónde se le solicitará al jugador el número correspondiente a la posición dónde quiere mover su ficha (“X” o “O”).
• El juego tendrá un método play() que contendrá el bucle del juego en el que se llamará a los métodos juegaPlayer1() y juegaPlayer2() y se comprobará si han ganado después de su movimiento, llamando al método evaluateWin(param);
• El método evaluateWin(param) mediante sucesivos if todas las posibilidades de que un jugador gane.
• El método printBoard(); imprimirá el tablero, con las fichas “X” y “O” dónde correspondan.
• Utilizaremos la consola de javascript para ver el tablero (ctrl + shift + k);

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.

Constructores

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

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

Salida:
Hola!!!

Ejercicio – juego del ahorcado II

Ahora separaremos el juego del ahorcado en dos clases que tendrán toda la lógica de la aplicación.:

Una clase Main que tendrá un bucle en el que se nos preguntará si queremos seguir jugando. Si respondemos que sí, crearemos una instancia de la otra clase, llamada Ahorcado.

Cada vez que creamos una nueva instancia de la clase ahorcado, jugaremos una nueva partida. Por tanto el código del juego será ejecutado desde el constructor de la clase Ahorcado.

Constructor con parámetros

		
public class E_constructorConParametros {
	public E_constructorConParametros(String nombre){
		System.out.println("Hola" + nombre);
	}
	public static void main(String[] args) {
		new E_constructorConParametros("Pepe");
		//La siguiente línea genera un error en tiempo de compilación
		//	new E_constructorConParametros();
	}
}
		
	

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

		
class Padre{
	private String nombre = "Pepe";		
	public void saludar(){
		System.out.println(this.nombre);
	}
}

public class A_herencia extends Padre{
	public static void main(String[] args) {
		A_herencia a_herencia = new A_herencia();
		a_herencia.saludar();
	}
}
		
	

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

Constructores y herencia

		
public class F_constructorYHerencia_sinError extends Padre5{
	public F_constructorYHerencia_sinError(){
		System.out.println("Se ejecuta el hijo");
	}
	
	public static void main(String[] args) {
		new F_constructorYHerencia_sinError();
	}
}

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

Salida:
Se ejecuta el padre
Se ejecuta el hijo

Todas las clases tienen un constructor. Si no lo escribo, el compilador de java lo pone automáticamente.

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 G_constructorYHerencia_conError extends Padre2{
	public G_constructorYHerencia_conError(){
		System.out.println("Se ejecuta el hijo");
	}
	
	public static void main(String[] args) {
		new G_constructorYHerencia_conError();
	}
}

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

Ejercicio

Desarrolle una aplicación que contenga las siguientes clases:

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 cada clase de animal e invoque a sus métodos "compararSonido".

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

Polimorfismo

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

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

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

2 mecanismos polimórficos: sobrecarga y sobrescritura

		
class Padre{
	public static void metodoPadre(String txt){
		System.out.println(txt);
	}
}
public class D_sobrecarga_sobrescritura extends Padre{
	//SOBRECARGA
	//El tipo de dato devuelto debe 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 exceptions arrojadas debe ser el mismo
	public int metodoPadre(int codigoDespedida){
		System.out.println(codigoDespedida);
		return 4;
	}
	//SOBRESCRITURA
	//El tipo de dato 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 también debe serlo
	public static void metodoPadre(String txt){
		System.out.println("Tras la sobrecarga la funcionalidad cambia " + txt);
	}
	public static void main(String[] args){
		D_sobrecarga_sobrescritura sobrecarga_sobrescritura = new D_sobrecarga_sobrescritura();
		sobrecarga_sobrescritura.metodoPadre("Valor");
		sobrecarga_sobrescritura.metodoPadre(3);
	}	
}	
		
	

Abstracción

Métodos abstractos

Tenemos una clase "Cosa" que tiene un método "botar". Hay varias clases que heredan de "Cosa", la clase "Ladrillo", la clase "Pelota".

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.

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

El método getDescription() devuelve una descrición del animal correspondiente, que será diferente en cada caso.

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” y “getDescription()“.

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 Instrument2{
	void play();//automaticamente publico
}
public class B_interface implements Instrument2{
	public static void main(String[] args) {
		B_interface objetoDeLaClaseQueImplementaLaInterface = new B_interface();
		objetoDeLaClaseQueImplementaLaInterface.play();
	}
	public void play() {
		System.out.println("Jugar al baloncesto");
	}
}
		
	

Ejercicio – animales con interfaz

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, pero no puede acceder a sus propiedades privadas.

	
public class A_claseInterna {
	private String nombreExt;
	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) {
		A_claseInterna claseExterna = new A_claseInterna();
		ClaseInterna a_claseInterna = claseExterna.new ClaseInterna();
		a_claseInterna.mostrarNombre();
	}
}
	

Output:
Pepe
Null

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(final1);
		System.out.println(final2);
		System.out.println(final3);
	}
}
		
	

Contenedores

Recorrer una colección - Iterator

		
public static void main(String[] args) {
	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.

		
public static void main(String[] args) {
	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);
	}
}
		
	

Este código no compilaría, dado que hemos indicado que nuestra colección contendrá objetos de tipo String, y no Integer

Modificar un elemento de una colección

En vez de cojer la posición del alumno que quiero modificar, podemos crear una instancia que apunte a donde quiero modificar y la modifico.

	
public class B_coleccionesII {
	public static void main(String []args){
		Cosa cosa = new Cosa();
		cosa.setValor("cosa");	
		ArrayList<Cosa> cosas = new ArrayList<Cosa>();
		cosas.add(cosa);	
		Iterator<Cosa> it = cosas.iterator();
		while(it.hasNext()){
			cosa = it.next();
			cosa.setValor("hola");
		}	
		System.out.println(cosas.get(0).getValor());
	}
}
class Cosa{
	String valor;
	public String getValor() {
		return valor;
	}
	public void setValor(String valor) {
		this.valor = valor;
	}
}
	

Encapsulamiento

Consiste en no dejar modificar las variables de un objeto directamente si no es a través de un método.

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.

Ejermplo
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 br Ctrl + shift + s → Generate Getters and Setters

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

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

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 recorrerAlumnos que realizarán las 4 operaciones antes citadas. Utilizar un ArrayList declarado en la clase Servicio para almacenar la información.

Recorrer un Map

Recorrer un Map transformándolo en una Collection

		
public class C_colocarYRecuperarElementosDesordenadosMap {
	public static void main(String[] args) {
		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());
		}
	}
}
		
	

Recorrer un Map transformando las claves en un Set y respetando el orden de las claves

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.

		
public class D_colocarYRecuperarElementosOrdenadosDeUnMap {
	public static void main(String[] args) {
		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

		
Map <String,Persona3>map = new HashMap<String,Persona3>();
...

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

Hashcode y comparaciones

Hashcode

Es un identificador del objeto.

El método hashCode() devuelve un dato de tipo int.

El contrato de un hashCode:
'Si dos objetos son iguales usando equals(), el método hashCode de ambos objetos debe retornar el mismo valor'. Aunque dos objetos diferentes pueden coincidir en el hashcode.

El hashcode debe ser diferente para cada objeto, por tanto, el método que lo devuelve no debe retornar un valor constante.

Del contrato se deduce que si sobrescribimos el equals, habrá que sobrescribir el hashCode.

Incumplir este contrato puede producir repercusiones inesperadas al usar la clase en hash-collections

Comparando Objetos sin sobrescribir el hashCode

		
public class HashCode_a extends Exception{
    public static void main(String[] args) {
    	Persona p1 = new Persona("Juan", 16);
    	Persona p2 = new Persona("Juan", 16);

    	System.out.println(p1.hashCode());
    	System.out.println(p2.hashCode());	
    	
    	System.out.println(p1.equals(p2));
    	System.out.println(p1 == p2);
    	System.out.println(p1.hashCode()==p2.hashCode());
    }
}
		
	

Salida:
336360050
1026401446
false
false
false

Comparando objetos tras sobrescribir el equals y el hashCode

	
class Persona2{
	private String nombre;
	private int edad;
	public Persona2(String nombre, int edad) {
		super();
		this.nombre = nombre;
		this.edad = edad;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + edad;
		result = prime * result + ((nombre == null) ? 0 : nombre.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (!(obj instanceof Persona2))
			return false;
		Persona2 other = (Persona2) obj;
		if (edad != other.edad)
			return false;
		if (nombre == null) {
			if (other.nombre != null)
				return false;
		} else if (!nombre.equals(other.nombre))
			return false;
		return true;
	}
	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;}
}

	

	
public class HashCode_b extends Exception{
    public static void main(String[] args) {
    	Persona2 p1 = new Persona2("Juan", 16);
    	Persona2 p2 = new Persona2("Juan", 16);

    	System.out.println(p1.hashCode());
    	System.out.println(p2.hashCode());	
    	
    	System.out.println(p1.equals(p2));
    	System.out.println(p1 == p2);			
	System.out.println(p1.hashCode()==p2.hashCode());
    }
}
	

Salida:
2321545
2321545
true
false
true

Sobrescribir equals para que atienda a mi criterio

El método equals determina si un objeto es igual o distinto de otro. Para ello compara el hashcode de ambos objetos. Por tanto, dos objetos iguales de acuerdo al método equals(object), tendrán el mismo hashcode.

Imaginemos que tenemos dos fincas y que queremos evaluar si son iguales, dónde ser igual significa tener la misma cantidad de metros cuadrados.

Para hacer la evaluación deberemos sobrescribir el equals. Alt + shift + s -> Generate HashCode and Equals

Finca.java 
public boolean equals(Object obj) {
	if (this == obj)
		return true;
	if (obj == null)
		return false;
	if (getClass() != obj.getClass())
		return false;
	Finca other = (Finca) obj;
	if (Double.doubleToLongBits(largo*ancho) != Double
			.doubleToLongBits(other.largo*other.ancho))
		return false;
	return true;
}
	

El hashcode es un entero q representa al objeto. Dicho entero debería estar en función de valores que determinen cuando un objeto es igual o distinto de otro. en el caso de una finca largo y ancho.

Sobrescribir el hashcode en caso de q hayamos sobrescrito el equals no es estrictamente necesario pero sí altamente recomendable. Mantendremos el código que nos sugiere eclipse.

		
public int hashCode() {
	final int prime = 31;
	int result = 1;
	long temp;
	//¿Qué pasa si en vez de poner alto pongo ancho*alto?
	temp = Double.doubleToLongBits(largo);
	result = prime * result + (int) (temp ^ (temp >>> 32));
	temp = Double.doubleToLongBits(ancho);
	result = prime * result + (int) (temp ^ (temp >>> 32));
	return result;
}	
		
	

Sobrescribir compareTo

El método compareTo determina si un objeto es mayor, menor o igual a otro.

compareTo devuelve 0 si son iguales, 1 (o un entero positivo cualquiera) si el primero es mayor q el segundo y -1 (o un número negativo cualquiera) si el segundo es mayor que el primero

Finca.java
public class Finca implements Comparable<Finca>{
	...
	public int compareTo(Finca otherFinca){
		double productoThis = this.getAncho()*this.getLargo();
		double productoOther = otherFinca.getAncho()*otherFinca.getLargo();
		
		int valorDevuelto = 0;
		if(productoThis > productoOther)valorDevuelto=1;
		if(productoThis < productoOther)valorDevuelto=-1;
		if(productoThis == productoOther)valorDevuelto=0;
		return valorDevuelto;	
	}		
	

Main.java
Collections.sort(lista);

Iterator it = lista.iterator();
while(it.hasNext()){
	Finca c = (Finca) it.next();
	System.out.println(c.getNombre());
}
		
	

Ejercicio – equals y compareTo

Hacer una clase llamada Deposito que tiene un nombre, un largo, un ancho y un alto.

Hacer un método equals (y su correspondiente método hashcode) que devolverá true cuando dos depósitos tengan el mismo volumen (largo*ancho*alto).

Añadir 5 depósitos creados a una Lista y comprobar que cuando la recorro con un iterator los depósitos quedan ordenados en función de su volumen. Para ello habrá que sobreescribir el método compareTo.

Excepciones

Checked Exceptions

1. Checked Exceptions: Son Excepciones que son heredadas de java.lang.Exception. Este tipo de exception es obligada a ser controlada dentro de un bloque Try/Catch o bien declarar la excepción en el throws, para obligar al método que invoca a controlar la excepción
2. Unchecked Exceptions: Son Excepciones que son heredadas de java.lang.RuntimeException. Este tipo de exception no es obligatoria su control, se manifiesta normalmente por error del programador.

Excepción con un catch

Excepción con varios catch

El único catch que se aplica es el que recoge la excepción. Después de este, el programa continua ejecutándose a partir del último Catch.

Para que el código compile, los tipos de Error más generales(Throwable) deben estar por debajo de los más particulares(ArithmeticException)

Throw

		
public class D_throw {
	public static void main(String[] args) {
		D_throw d_throw = new D_throw();
		try {
			d_throw.lanzarExcepcion();
		} catch (Exception e) {
			System.out.println("excepción lanzada y procesada");
		}
		d_throw.procesarExceptionInSitu();
	}
	public void lanzarExcepcion() throws Exception{
		throw new Exception();
	}
	public void procesarExceptionInSitu(){
		try {
			throw new Exception();
		} catch (Exception e) {
			System.out.println("excepción procesada");
		}
	}
}
		
	

Consola:
excepción lanzada y procesada
excepción procesada

Finally

El finally se ejecuta siempre, se trate la excepción o no se trate la excepción. La única forma de evitar que se ejecute el finally es ejecutando un System.exit(), que mata la máquina virtual.

Se utiliza siempre en conjunción con un try-catch. No puede haber nada después del catch y antes del finally.

Crear una excepción

Implementar Serializable

Serializar es el proceso de convertir el objeto a bytes, para poder enviarlo a través de red, y después reconstruirlo al otra lado de la red, leerlo del fichero...

Para que un objeto sea serializable basta con que implemente la interfaz Serializable.

serialVersionUID

Es posible que cuando envío un objeto serializado a un lado y a otro de la red tenga diferentes versiones del mismo. Si sucede esto, la reconstrucción de la clase en el lado que recibe es imposible.

Para comparar las versiones de las clases utilizamos el atributoprivate static final long serialVersionUID.
Este nos indica el número de versión de la clase. Debemos ir actualizándolo con las modificaciones de la clase que vayamos haciendo.

Si las versiones de dos clases que implementan Serializable no coinciden, obtendremos una InvalidClassException al deserializar.

Ejercicio excepciones

Implementar una clase Servicios con un método llamado getPrecioConIva() que recibirá un número y devolverá dicho número multiplicado por 1.16. Si el precio es mayor que 100 arrojará una PrecioDemasiadoAltoException que será capturada en el Main.

Implementar una clase PrecioDemasiadoAltoException y sobreescribir su método printStackTrace() para que imprima el texto „El precio es demasiado alto“.

Implementar una clase Main que llame al método getPrecioConIva() de la clase Servicios e imprima el valor que devuelve.

Ejercicio

Implementar una clase Persona, con los siguientes campos:
String dni
String nombre
Date fechaNacimiento

Se considerará que dos instancias de Persona son iguales si tienen el mismo dni.

Implementar una clase Servicios con los siguientes métodos:

• getPersonaMayor: Recibe un mapa de personas personas y devuelve la persona mayor. Arroja una SinDatosException si el mapa está vacío (isEmpty()).
  Para comparar las fechas de los objetos de la clase Date:
• El método getTime() me devuelve los milisegundos de la fecha.
• Los métodos after() y before() me devuelven true o false dependiendo de que fecha fue anterior.
• getPrimerNombre: Recibe un mapa igual al anterior y devuelve la persona con el primer nombre en orden alfabético. Arroja una SinDatosException si el mapa está vacío. Desde este método llamaremos al método compareTo().

Implementar una clase Main con un método public static void main que crea dos objetos y realiza entre ellos las comparaciones antes indicadas. También debe indicarnos si dichas personas son iguales.

Para convertir una fecha en un objeto de tipo Date: 
SimpleDateFormat formatter = new SimpleDateFormat(''dd-MM-yyyy''); 

Date fecha = formatter.parse(stringFecha)	

Esto es MM mayúscula, las minúsculas son para minuto

Modificadores de acceso

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

Pueden ser:

• private

  Las clases top-level 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.

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

Generics

		
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

Generics II

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

	
public class Generics<String> {
	String valor;

	Generics() {
		// La siguiente línea daría error
		// valor.charAt(2);
	}
}
	

Enumeraciones

Los tipos enumerados sirven para restringir la selección de valores a algunos previamente definidos

		
enum instrumentos{
   GUITARRA, TROMPETA, BATERIA, BAJO
};
public class Enumerations {
   public static void main (String... args){
      instrumentos in = instrumentos.BATERIA;
      System.out.println(in);
   }
}
		
	

Declarar constructores, métodos y variables dentro de un tipo enumerado:

	

enum TamanoCafe{
	   CHICO(5), MEDIANO(8), GRANDE(10);
	   private int onzas;
	   //No se puede invocar al constructor directamente, 
	   //este se invoca una vez que se crea el tipo enumerado 
	   //y es definido por los argumentos utilizados para crearlo.
	   TamanoCafe(int onzas){
	      this.onzas = onzas;
	   }
	   public int getOnzas(){
	      return this.onzas;
	   }
	}
	public class Cafe {
	   public static void main(String... args){
		   TamanoCafe tc;
	      tc = TamanoCafe.CHICO;
	      System.out.println("Tamaño de café: "+TamanoCafe.CHICO);
	      System.out.println("Onzas 1(c1): "+TamanoCafe.CHICO.getOnzas());
	   }
	}

Hilos

Para usarlos puedo extender thread o implementar Runnable

Ejemplo de aplicación sin usar hilos

		
Main.java
public class Main {
	public static void main(String args[]){
		HiloFalso hilo1 = new HiloFalso();
		HiloFalso hilo2 = new HiloFalso();
		HiloFalso hilo3 = new HiloFalso();
		hilo1.run();
		hilo2.run();
		hilo3.run();	
	}
}

Hilo.java
class HiloFalso{
	static double variable1 = 100;
	static double variable2;
	public void run() {
			variable1-=10;					
			variable2 =variable1 - 10; 				
			System.out.println("Variable1:" + variable1 + " Variable2: "+ variable2);
	}
}
		
	

Extender Thread

Cuando en una instancia que herede de thread llamo al método start estoy invocando el método run de la clase en un nuevo hilo.

Si llamase el método run directamente, estaría ejecutando su código pero sin crear un nuevo hilo.

		
Método Main de las siguientes implementaciones de hilos:
public static void main(String args[]){
	Hilo hilo1 = new Hilo();
	Hilo hilo2 = new Hilo();
	Hilo hilo3 = new Hilo();
		
	hilo1.start();
	hilo2.start();
	hilo3.start();
		
}

		
	

Puedo asignar prioridad a los hilos usando:
Hilo1.setPriority((Thread.MAX_PRIORITY - Thread.NORM_PRIORITY) / 2);

Sin sincronización

	
class Hilo extends Thread{
	
	static double variable1 = 100;
	static double variable2;
	public void run() {
		try {
			Thread.sleep(500);
			variable1-=10;				//90			80			70
			Thread.sleep(500);
			variable2 = variable1 - 10; 		//60
			
			System.out.println("Variable1:" + variable1 + " Variable2: "+ variable2);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}
	

Ponemos los hilos a dormir para asegurarnos de que en algún momento todos los hilos están ejecutando simultáneamente el método run().

Cuando todos los hilos han ejecutado la línea roja, variable1 valdrá 70.
El primero de los hilos llega a la línea azul y variable2 irá tomando el mismo valor (60) por cada vez que pase un hilo.

Salida:
Variable1:70.0 Variable2: 60.0
Variable1:70.0 Variable2: 60.0
Variable1:70.0 Variable2: 60.0

Modificador synchronized

Sólo permite que un hilo pase por cierto código de cada vez.

Cuando un objeto está sincronizado, se dice que dicho objeto es un monitor y tiene una variable lock.

El lock tiene el id de un hilo.

Con sincronización

	
class Hilo extends Thread{
	static Object mutex = new Object();
	static double variable = 100;
	static double variable2 = 90;
	public void run() {
		//El parámetro del siguiente método es un objeto (un Object, un String, un 
		Integer...) no nulo sobre el cual se va a sincronizar.EL objeto mutex sería una 
		especie de guardia de tráfico que decide quien pasa y quien no
		synchronized(mutex){ 
			try {
				Thread.sleep(500);
				Variable-=10;			//90			80		70
				Thread.sleep(500);
				variable2 =variable-10; 	//80			70		60
				
				System.out.println("Variable1:" + variable + " Variable2: "+ variable2);
				
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
	

Salida:
Variable1:90.0 Variable2: 80.0
Variable1:80.0 Variable2: 70.0
Variable1:70.0 Variable2: 60.0

Implementar Runnable

Me creo una instancia de la clase Thread, pasándole como parámetro un objeto de una clase que implementa la interfaz Runnable.

		
Método Main de las siguientes implementaciones de hilos:
public class Main {

	public static void main(String args[]){
		Thread hilo1 = new Thread(new Hilo());
		Thread hilo2 = new Thread(new Hilo());
		Thread hilo3 = new Thread(new Hilo());
		
		hilo1.start();
		hilo2.start();
		hilo3.start();		
	}
}
		
	

Sin sincronización

		
class Hilo implements Runnable{
	static double variable = 100;
	static double variable2 = 90;
	public void run() {
			try {
				Thread.sleep(500);
				variable-=10;				//90			80			70
				Thread.sleep(500);
				variable2 =variable-10; 	//60
	
				System.out.println("Variable1:" + variable + " Variable2: "+ variable2);
				
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
}
		
	

Con sincronización

	
class Hilo implements Runnable{
	
	static Object mutex = new Object();
	static double variable = 100;
	static double variable2 = 90;
	public void run() {
		synchronized(mutex){ //Aquí viene un objeto (un Object, un String, un Integer...) no nulo 	sobre el cual se va a sincronizar. Es posible usar cualquier objeto porque los métodos que hacen de semáforo pertenecen a la clase Object.
	//EL objeto mutex sería una especie de guardia de tráfico que decide quien pasa y quien no
			try {
				Thread.sleep(500);
				Variable-=10;				//90			80			70
				Thread.sleep(500);
				variable2 =variable-10; 		//80			70			60
				
				System.out.println("Variable1:" + variable + " Variable2: "+ variable2);
				
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
	

Aviso Legal

Los derechos de propiedad intelectual sobre el presente documento son titularidad de D. Pablo Monteserín Fernández Administrador, propietario y responsable de pablomonteserin.com. El ejercicio exclusivo de los derechos de reproducción, distribución, comunicación pública y transformación pertenecen a la citada persona.

Queda totalmente prohibida la reproducción total o parcial de las presentes diapositivas fuera del ámbito privado (impresora doméstica, uso individual, sin ánimo de lucro).

La ley que ampara los derechos de autor establece que: “La introducción de una obra en una base de datos o en una página web accesible a través de Internet constituye un acto de comunicación pública y precisa la autorización expresa del autor”.

El contenido de esta obra está protegido por la Ley, que establece penas de prisión y/o multa, además de las correspondientes indemnizaciones por daños y perjuicios, para quienes reprodujesen, plagiaren, distribuyeren o comunicaren públicamente, en todo o en parte, o su transformación, interpretación o ejecución fijada en cualquier tipo de soporte o comunicada a través de cualquier medio.

El usuario que acceda a este documento no puede copiar, modificar, distribuir, transmitir, reproducir, publicar, ceder, vender los elementos anteriormente mencionados o un extracto de los mismos o crear nuevos productos o servicios derivados de la información que contiene.

Cualquier reproducción, transmisión, adaptación, traducción, modificación, comunicación al público, o cualquier otra explotación de todo o parte del contenido de este documento, efectuada de cualquier forma o por cualquier medio, electrónico, mecánico u otro, están estrictamente prohibidos salvo autorización previa por escrito de Pablo Monteserín.

El autor de la presente obra podría autorizar a que se reproduzcan sus contenidos en otro sitio web u otro soporte (libro, revista, e-book, etc.) siempre y cuando se produzcan dos condiciones:

1. Se solicite previamente por escrito mediante email al correo pablomonteserin@pablomonteserin.com.
2. En caso de aceptación, no se modifiquen los textos y se cite la fuente con absoluta claridad.

Una parte de las imágenes utilizadas en este documento no son propiedad de Pablo Monteserín, por lo que, si alguna de estas imágenes estuviera sujeta a derechos de autor, o a algún otro tipo de derecho que impida su publicación en este documento, una vez que el autor, Pablo Monteserín, tenga conocimiento del hecho, procederá a la retirada inmediata de la imagen protegida por los derechos pertinentes.