Así que estoy familiarizado con las interfaces funcionales en java, y su uso con las expresiones lambda. Una interfaz funcional sólo puede contener un método abstracto. Al utilizar este método solo de una expresión lambda, que no es necesario especificar su nombre - ya que sólo hay un método abstracto en la interfaz, el compilador sabe que es el método que se está haciendo referencia.
Ejemplo:
// Functional Interface:
@FunctionalInterface
public interface Ball
{
void hit();
}
// Lambda to define, then run the hit method:
Ball b = () -> System.out.println("You hit it!");
b.hit();
Aunque es obvio por qué una interfaz funcional sólo puede contener un método abstracto, que no entiendo por qué no es posible sobrecargar ese método.
Por ejemplo, lo siguiente no se compilará:
// (NOT) Functional Interface:
@FunctionalInterface
public interface Ball
{
void hit();
void hit(boolean miss);
}
// Lambda to define, then run the hit method:
Ball b = () -> System.out.println("You hit it!");
Ball ba = (boolean miss) -> System.out.println(miss);
b.hit();
ba.hit(false);
Los estados del compilador que la Ballinterfaz no es funcional, ya que contiene más de un método, pero en este caso no entiendo por qué esto sería un problema - Mientras los dos métodos tienen diferentes parámetros, debería ser posible inferir qué método estoy referencia en el lambda en base a qué parámetros defino.
¿Puede alguien explicar por qué no es posible sobrecargar un método abstracto dentro de una interfaz funcional?
En idiomas sin la sobrecarga de métodos, procedimientos se identifican por su nombre en esa clase (ignorando anulando por el momento).
En Java cosas son un poco aunque diferentes. Citando a partir de los documentos de Oracle :
Métodos sobrecarga
Los soportes lenguaje de programación Java sobrecarga de métodos, y Java pueden distinguir entre métodos con diferentes firmas de métodos. Esto significa que los métodos dentro de una clase pueden tener el mismo nombre si tienen diferentes listas de parámetros (hay algunas salvedades a esta que serán discutidos en la lección titulada "Interfaces y Herencia").
Así que sabemos que los métodos también se identifican por su firma. Si dos métodos comparten un nombre, pero no tienen la misma firma, son métodos diferentes . No deje que su nombre compartido que engañe a pensar que están relacionados de alguna manera.
Teniendo en cuenta este hecho, podemos crear fácilmente un ejemplo en el cual se produciría un comportamiento indefinido si los métodos se comportaron de la manera que lo descrito:
Ball ba = (boolean miss) -> System.out.println(miss);
someFunction(ba)
public void someFunction(Ball ball) {
ball.hit();
}
¿Qué comportamiento se puede esperar en este caso? Se indefinido!
Usted puede - sin embargo - hacer uso de métodos predeterminados . No sé su situación lo suficientemente bien como para juzgar si esto es un enfoque adecuado, pero se puede hacer esto:
@FunctionalInterface
public interface Ball
{
default void hit() {
hit(true);
}
void hit(boolean miss);
}
¿Por qué funciona este se explica en la documentación deFunctionalInterface :
Conceptualmente, una interfaz funcional tiene exactamente un método abstracto. Dado que los métodos por defecto tienen una implementación, que no son abstractas