Java JSE ☕️☕️☕️
Diseño Web

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.

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.

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

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
• Jbuilder

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

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>){
		... 
	}
}

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

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

		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.

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

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.

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.

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

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 del int 32767: " + short_x);
System.out.println("2 - Conversión a short del int 32768: " + short_y);
System.out.println("2 - Conversión a short del int 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 del int 32767: " + byte_x);
System.out.println("4 - Conversión a byte del int 32768: " + byte_y);
System.out.println("5 - Conversión a byte del int 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

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;

System.out.println("amor " + "Juan");
System.out.println("amor " + nombre);

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

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

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

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

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

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

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

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

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

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

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

0
1
2
3
4
5
6
7
8
9

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

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

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

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

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

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

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

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

No precisan de una instancia para ser invocados.

public class MetodosStatic {
	public static void main(String[] args) {
		ClaseConMetodoStatic.saludar("Pepe");
	}
}

class ClaseConMetodoStatic{
	public static void saludar(String nombre){
		System.out.println("Hola " + nombre);
	}
}

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

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

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.

Obtener una letra aleatoria de tu nombre.

Tendrás que usar los siguientes códigos:

Math.floor(Math.random() * (MAX - MIN + 1)) + MIN;
nombre.chatAt(int posicion);
nombre.length();

Pasos para resolver el ejercicio:

1. Calculamos un número aleatorio en un rango comprendido entre 0 y el número de letras de tu nombre.
2. Utilizamos ese número aleatorio para obtener la letra de tu nombre que ocupa esa posición.
3. Mostramos la letra en la consola.

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.

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

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

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

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.

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

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

Desarrolle una aplicación que contenga las siguientes clases:

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.

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

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

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

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

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.

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

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.

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

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

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.

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

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

}

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.

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

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

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

El método keySet() devuelve un set de claves. Luego, recuperaré los valores del map utilizando las claves que acabo de almacenar en el Set.

Persona p1 = new Persona("11111111E", "Nombre1");
Persona p2 = new Persona("22222222E", "Nombre2");
Persona p3 = new Persona("33333333E", "Nombre3");
		
Map<String, Persona&gr; map = new HashMap();
map.put(p1.getDni(), persona1);
map.put(p2.getDni(), persona2);
map.put(p3.getDni(), persona3);
		
Set <String&gr;claves = map.keySet();
		
Iterator <String&gr; it = claves.iterator();
while(it.hasNext()){
	String clave =  it.next();
	Persona persona = map.get(clave);
	System.out.println(persona.getNombre());
}

//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, Persona>entry:map.entrySet()){
	String key = entry.getKey();
	Persona3 value = entry.getValue();
	System.out.println(key + "=> " + value.getNombre());
	}
}

Sobreescritura del equalsclass Punto2D{
	private int x;
	private int y;
	private String nombre;
		
	public Punto2D(int x, int y, String nombre) {
		super();
		this.x = x;
		this.y = y;
		this.nombre=nombre;
	}
	@Override
	public boolean equals(Object o) {	
		if (!(o instanceof Punto2D)) return false;
		Punto2D punto = (Punto2D) o;
		return (x == punto.x) && (y == punto.y);
	}
}

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

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

Este método sirve para comparar objetos dentro de una estructura de tipo Hash (HashMap, HashSet, etc.). Su reescritura no es indispensable, pero sí recomendable.

El método hashCode() devuelve un dato de tipo int que identifica 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.

Es más rápido que el método equals. Cuando comparamos dos objetos...

1. Si no tienen el mismo hashcode, son diferentes.
2. Si tienen el mismo hashcode, se llamará al método equals.

Sobreescritura del hashcode (JDK 7)public int hashCode() {
        return Objects.hash(x, y);
}

El método compareTo determina si un objeto es mayor, menor o igual a otro. 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); //Para que esto funcione es necesario implementar la interfaz comparable

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

1. Hacer una clase llamada Deposito que tiene un nombre, un largo, un ancho y un alto.
2. Dentro de la clase Depósito, definir un método equals (y su correspondiente método hashcode) que devolverá true cuando dos depósitos tengan el mismo volumen (largo*ancho*alto).
3. Crear 5 depósitos.
4. Añadirlos a una lista.
5. Ordenar la lista.
6. Recorrerla con un iterator.
7. Comprobar que los depósitos están ordenados por su volumen. Para ello tendremos que haber sobreescrito el método compareTo

• En tiempo de compilación (checked exceptions): Heredan de java.lang.Exception. El compilador nos obligará a controlarlas mediante un bloque Try/Catch o un throws.
• En tiempo de ejecución (unchecked exceptions): Heredan de java.lang.RuntimeException. Es la única Exception que no es comprobada por el compilador. Un error también se produce en tiempo de ejecución, aunque un error no es una excepción.

int i = 2;
int j = 0;
System.out.println("antes");
try{
	System.out.println(i/j);
}catch (ArithmeticException e){
	System.out.println("en catch");
	e.printStackTrace();
}
System.out.println("despues");

Output:
antes
en el try
en el catch
java.lang.ArithmeticException
despues

int i = 2;
int j = 0;
System.out.println("antes");
try{
	System.out.println("en el try");
	System.out.println(i/j);
}catch (ArithmeticException e){
	System.out.println("en catch1");
	e.printStackTrace();
}catch(Exception e){
	System.out.println("en catch2");
	e.printStackTrace();
}catch(Throwable t){
	System.out.println("en catch3");
	t.printStackTrace();
}
System.out.println("despues");

Output
antes
en el try
en catch1
java.lang.ArithmeticException
despues

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)

public class ArrojarExcepcion {
	public static void main(String[] args) {
		ArrojarExcepcion arrojarExcepcion = new ArrojarExcepcion();
			try {
			arrojarExcepcion.lanzarExcepcion();
		} catch (Exception e) {
			System.out.println("excepción lanzada y procesada");
		}
		arrojarExcepcion.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

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.

public static void main(String[] args) {
	int i = 2;
	int j = 0;
	System.out.println("antes");
	try{
		System.out.println(i/j);
	}catch (ArithmeticException e){
		System.out.println("en catch1");
		e.printStackTrace();
	}catch(Exception e){
		System.out.println("en catch2");
	}catch(Throwable t){
		System.out.println("en catch3");
	}finally{
		System.out.println("en finally");
	}
	System.out.println("despues");
}

Output:
antes
en catch1
java.lang.ArithmeticException
en finally
despues

Implementar una clase Main que llame un método getPrecioConIva() e imprima el valor que devuelve.

Este método 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 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.

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

Output:
BATERIA

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

Para usarlos puedo extender thread o implementar Runnable

Dos ejemplos de hilos en la vida real

Cuando se venden las entradas del concierto de Madonna. En poco segundos todas las entradas quedan agotadas debido a la gran demanda. El proceso que materializa la compra de la entrada no debe ser realizado por varios usuarios a la vez, ya que se corre el riesgo de que se vendan más entradas de las que realmente hay disponibles. Esa parte del código habrá que sincronizarla.

Varias personas entran en un supermercado en el que sólo hay un dependiente. Aunque cada cliente deambula por el supermercado a su aire, mirando productos, escogiendo los que tienen menos conservantes, etc. a la hora de pagar los clientes deben ponerse en cola e ir siendo atendidos por el vendedor de uno a uno. Esta sería la parte sincronizada de un algoritmo que representase lo que ocurre en el supermercado.

Main.javapublic 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.javaclass HiloFalso{
	static double variable1 = 100;
	public void run() {
		variable1-=10;	
		Thread.sleep(500);		
		System.out.println("Variable1:" + variable1);
	}
}

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

class Hilo extends Thread{
	static double variable1 = 100;
	public void run() {
		try {
			variable1-=10;
			Thread.sleep(500);
			System.out.println("Variable1:" + variable1 );
		} 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().

Output:
Variable1:70.0
Variable1:70.0
Variable1:70.0

class Hilo extends Thread{
	static Object mutex = new Object();
	static double variable = 100;
	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 {
				variable-=10;			//90 80 70
				Thread.sleep(500);
				System.out.println("Variable1:" + variable);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

Output:
Variable1:90.0
Variable1:80.0
Variable1:70.0

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

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

Output:
Variable1:70.0
Variable1:70.0
Variable1:70.0

class Hilo implements Runnable{
	
	static Object mutex = new Object();
	static double variable = 100;
	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 {
				variable-=10;		//90 80	70
				Thread.sleep(500);
				System.out.println("Variable1:" + variable);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

Output:
Variable1:90.0
Variable1:80.0
Variable1:70.0

Tenemos una aplicación a la que se conectan de manera concurrente 2 personas (2 hilos). Cada una de estas personas debe realizar 3 operaciones. Suponemos que cada una de estas operaciones tardará 10 milisegundos en realizarse. Representaremos las 10 tareas que realizará cada una de estas personas con el siguiente código:

for (int i = 0; i < 3; i++) {
System.out.println("operacion " + i);
	Thread.sleep(10);
}

Si no sincronizamos este código veremos el código de cada una de estas dos personas se entremezclará, dando lugar a unas trazas como estas:

operacion 0
operacion 0
operacion 1
operacion 1
operacion 2
operacion 2

Queremos sincronizar el código para que las operaciones de cada persona no se entremezclen