package prueba;

interface Interfaz1 {
	int VARIABLE = 10;

	void test1();

	default void test2() {
		System.out.println("Método por defecto de Interfaz1");
	}
}

interface Interfaz2 {
	static public final int VARIABLE = 20;

	abstract public void test1();

	public default void test2() {
		System.out.println("Método por defecto de Interfaz2");
	}
}

abstract class Clase1 implements Interfaz1, Interfaz2 {

	int variable;

	public void test1() {
		System.out.println("Método test1 de Clase1");
		return;
	}

	public void test2() {
		System.out.println("Método por defecto de Clase1");
	}

}

class Clase2 extends Clase1 {

	public static void main(String args[]) {

		Clase1 clase2 = new Clase2();
		System.out.println(clase2.variable);
		clase2.test1();
		clase2.test2();

		((Interfaz1) clase2).test1();
		((Interfaz2) clase2).test2();

	}

}

package pruebas.ocp;

import java.io.FileNotFoundException;
import java.io.IOException;

public class Padre {
	protected void hola() throws IOException {
		System.out.println("Hola, soy el Padre");
	};
}

class Hijo extends Padre {

	public void hola() throws FileNotFoundException {
		System.out.println("Hola, soy el Hijo");
	};

	public static void main(String args[]) {
		Padre padre = new Padre();
		try {
			padre.hola();
		} catch (IOException e) {
			System.out.println("Exception " + e.getMessage());
		}

		Hijo hijo = new Hijo();

		try {
			hijo.hola();
		} catch (FileNotFoundException e) {
			System.out.println("Exception " + e.getMessage());
		}

		Padre mixto = new Hijo();

		try {
			mixto.hola();
		} catch (IOException e) {
			System.out.println("Exception " + e.getMessage());
		}

	}
}

package pruebasExcepciones;

public class Pruebas {

	public static void pruebasExcepciones() {

		try {

			System.out.println(" 1) try ");
			lanzaExcepcion();

		} catch (Exception e) {

			System.out.println(" 2) catch ");
			throw e;

		} finally {
			System.out.println(" 3) finnaly ");
		}

	}

	public static void main(String[] args) {

		try {
			pruebasExcepciones();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		System.out.println(" 4) main ");

	}

	public static void lanzaExcepcion() {
		throw new ArrayIndexOutOfBoundsException();
	}

}

package constructores1;


public class Pruebas {

	private String s = "publico";
	
	protected Pruebas() {
		this.s = "protected";  
    }

	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "Pruebas [s=" + s + "]";
	}
	

}

package constructores2;


public class Pruebas {

	private String s = "publico";
	
	protected Pruebas() {
		this.s = "protected";  
    }

	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "Pruebas4 [s=" + s + "]";
	}
	

}

package constructores;

public class Principal {

	public static void main(String args[]){
		constructores1.Pruebas pruebas1 = new constructores1.Pruebas();
		System.out.println(pruebas1.toString());
		
		constructores1.Pruebas pruebas2 = new constructores2.Pruebas();
		System.out.println(pruebas2.toString());
		
	}
}

package constructores;

public class Pruebas1 {

	public Pruebas1(){
		
	};
	
	private Pruebas1(){
		
	};
	
	
}

package constructores;

public class Pruebas2 {

	private Pruebas2(){
		
	};
	
	
}

El código de ejemplo es el siguiente (son diferentes clases):

package test.interfacesEImplementaciones;

public interface InterfazDePrueba {
	void holaMundo();
}

package test.interfacesEImplementaciones;

public class ImplementacionDePrueba1 implements InterfazDePrueba{

	@Override
	public void holaMundo() {
		// TODO Auto-generated method stub
		
	}

}

package test.interfacesEImplementaciones;

public class ImplementacionDePrueba2 implements InterfazDePrueba{

	@Override
	public void holaMundo() {
		// TODO Auto-generated method stub
		
	}

}

package test.interfacesEImplementaciones;

public class Main {

	public static void main(String[] args) {
		InterfazDePrueba itfcs = new ImplementacionDePrueba1();
		itfcs.holaMundo();

	}

}

La prueba que hice es buscar referencias del método "holaMundo" de la clase ImplementacionDePrueba2.... y Eclipse me dijo que desde el método main (de la clase Main), era invocado...

¿Sois capaces de determinar por qué Eclipse indica eso?

Yo tengo mi teoría al respecto (de hecho, tengo dos), pero creo que sería positivo para todos dar más puntos de vista.

Saludos cordiales.

package lambda;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.swing.JButton;

/**
 * Clase que utilizaremos en la parte de métodos de comparación con Lambda
 *
 * @author jaimecl
 *
 */
public class Persona {

	private String surName;

	public Persona(String surName) {
		super();
		this.surName = surName;
	}

	public String getSurName() {
		return surName;
	}

	public void setSurName(String surName) {
		this.surName = surName;
	}

	/* Método de impresión de valores */
	public void printName() {
		System.out.println("surName=" + surName + "]");
	}

	/* Método que creará una lista corta de Personas, a modo de datos de ejemplo */
	private static List createShortList() {
		ArrayList lista = new ArrayList();
		lista.add(new Persona("Carmona"));
		lista.add(new Persona("Pérez"));
		return lista;

	}

	/**
	 * Método principal
	 *
	 * @param args
	 */
	public static void main(String args) {

		/*
		 * Empezamos con clases anónimas: utilizadas en un sólo punto del código
		 * No hay necesidad de tener que definir una clase única que sea
		 * referenciada sólo una vez
		 */
		JButton testButton = new JButton("Test Button");
		testButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent ae) {
				System.out.println("Click Detected by Anon Class");
			}
		});

		/*
		 * Java8 define como interfaz funcional aquella clase que define un sólo
		 * método. Las expresiones Lambda pueden ser aplicadas sobre dichas
		 * interfaces La sintaxis es la siguiente argumento -> cuerpo. (int x,
		 * int y) -> x + y
		 * 
		 * () -> 42
		 * 
		 * (String s) -> { System.out.println(s); }
		 */

		/* A continuación, vemos cómo definir Lambda Runnable */

		/* Manera antigua, con una clase anónima */
		new Runnable() {
			@Override
			public void run() {
				System.out.println("JavaHispaneros, ¡manera anónima!");
			}
		}.run();

		// Con Lambda, la interfaz runnable tiene un sólo método, por lo tanto,
		// podemos redefinirlo de la siguiente manera.
		Runnable r2 = () -> System.out
				.println("JavaHispaneros, ¡esto es Lambda!");

		/* A continuación, vemos un ejemplo de ordenación de listas */
		List personList = Persona.createShortList();

		/*
		 * Ordenación con clases anónimas. Dentro del método sort, que espera
		 * una interfaz de tipo Comparator, hacemos una redefinición
		 */

		Collections.sort(personList, new Comparator() {
			public int compare(Persona p1, Persona p2) {
				return p1.getSurName().compareTo(p2.getSurName());
			}
		});

		// Ordenación ascendente, en este caso, haciendo uso de expresiones
		// lambda

		/*
		 * El método sort de Collections espera un único método, con dos
		 * parámetros. Por lo tanto, utilizamos la sintaxis lambda para definir
		 * el método de comparación
		 */
		Collections.sort(personList, (Persona p1, Persona p2) -> p1
				.getSurName().compareTo(p2.getSurName()));

		// Mismo caso, ejerciendo la ordenación descendente.
		Collections.sort(personList,
				(p1, p2) -> p2.getSurName().compareTo(p1.getSurName()));

		/* Otro caso para listeners */
		JButton botonMetodoAnonimo = new JButton("Botón con método anónimo");
		botonMetodoAnonimo.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent ae) {
				System.out.println("Click detectado por clase anónima");
			}
		});

		/*
		 * De nuevo, vemos que addActionListener acepta una clase que implemente
		 * la interfaz listener, que define un método único, por lo tanto,
		 * acepta expresiones lambda Recordamos la sintaxis: nombre de variable
		 * en parámetro -> acción a realizar Choca ver que en la parte de
		 * parámetros no existe el tipo de parámetro que es
		 */

		JButton botonMetodoLambda = new JButton("Botón con método lambda");
		botonMetodoLambda.addActionListener(e -> System.out
				.println("Click Detected by Lambda Listner"));

	}
}

package scjp;

public class DefinicionDeMetodos {

	private void sayHello() {
		
	}
	
	private void sayHello(int a) {
		
	}
	
	public void sayHello() {
		
	}

	public void sayHello(int a) {
		
	}
	
	private void sayHello() throws Exception{
		
	}
	
	private void sayHello(int a) throws Exception{
		
	}

}

Buenos dís. Pensaba que tanto Vector como ArrayList se diferenciaban en que sus métodos eran (o no eran) thread-safe. Salió el debate en mi trabajo, y quise comprobarlo por mi mismo. Desarrollé el siguiente código. ¿Alguien puede indicarme la salida del mismo e intentar explicar la diferencia real, en un ejemplo práctico, entre Vector y ArrayList? Muchas gracias

import java.util.ArrayList;
import java.util.List;

public class Principal implements Runnable {

	private List lista = new ArrayList();
	private static List hilos = new ArrayList();

	private int i = 0;

	private final int MAX_VAL = 1000;
	private final static int MAX_VAL_STATIC = 1000;
	private final static int MAX_HILOS = 1000;
	private final static int TIEMPO_ESPERA_MS = 1000;

	public Principal(List lista) {
		this.lista = lista;

	}

	public static void main(String[] args) throws InterruptedException {

		Long inicio = System.currentTimeMillis();
		
		List lista = new ArrayList();

		System.out.println("Iniciando hilos....");
		for (int i = 0; i < MAX_HILOS; i++) {
			Principal p = new Principal(lista);
			hilos.add(p);
		}

		System.out.println("OK");

		System.out.println("Ejecutando hilos....");
		for (Principal hilo : hilos) {
			hilo.run();
		}
		System.out.println("OK");

		System.out.println("Esperando finalización");

		boolean finalizado = true;
		do {
			Thread.sleep(TIEMPO_ESPERA_MS);

			for (Principal hilo : hilos) {
				if (hilo.i < MAX_VAL_STATIC) {
					finalizado = false;
				}
			}

		} while (!finalizado);

		System.out.println("OK");

		System.out.println("EL TAMAÑO DE LA LISTA ES: " + lista.size());
		Long total = System.currentTimeMillis() - inicio;
	}

	public int getI() {
		return i;
	}

	public void setI(int i) {
		this.i = i;
	}

	@Override
	public void run() {
		while (i < MAX_VAL) {
			lista.add("" + i);
			i++;
		}
	}

}

DATE-TIME API

PREGUNTAS

1) ¿Qué clase utilizarías para almacenar tu cumpleaños en años, meses, días, segundos y nanosegundos?

2) Dada una fecha aleatoria, ¿cómo obtendrías el jueves pasado?

3) ¿Qué diferencia existe entre ZoneId y ZoneOffset?

4) ¿Cómo convertirías Instant a ZonedDateTime? ¿Cómo convertirías ZonedDateTime a Instant?

EJERCICIOS

1) Escribe un programa que, para un año dado, reporta el nº de días de cada mes dentro del año.

2) Escribe un programa que, para un mes del año actual, lista todos los lunes del mes.

3) Escribe un ejemplo que chequea si una fecha se corresponde a viernes 13.