anular la ambigüedad con múltiples interfaces

En el reino de la programación orientada a objetos, las clases pueden implementar múltiples interfaces. Sin embargo, cuando estas interfaces poseen métodos con firmas idénticas, surge una pregunta: ¿cómo se resuelve el compilador qué método de interfaz se anula?

en Java, una clase que implementa múltiples interfaces con tales métodos superpuestos tendrá solo una implementación efectiva. El compilador no distingue entre los métodos basados ​​en el origen de su interfaz.

para comprender este concepto, consideremos el siguiente ejemplo:

interface A {
  int f();
}

interface B {
  int f();
}

class Test implements A, B {   
  @Override
  public int f() {  
    return 0;
  }
}   

En este escenario, probar implementa tanto A como B, y ambas interfaces definen un método llamado F () con la misma firma. Al anular este método en la prueba, la clase anula efectivamente el método F () de ambas interfaces, a pesar de que solo una anotación @Override está presente.

Esto se debe a que las reglas de herencia de Java dictan que los métodos con firmas idénticas se consideran "anulaciones-equivalentes". Como resultado, el compilador elige el primer método primordial que encuentra, independientemente del origen de su interfaz.

. En tales casos, el compilador informará un error, ya que no es posible tener dos métodos con la misma firma pero diferentes tipos de retorno en la misma clase.

Para ilustrar este punto, modificemos el ejemplo de la siguiente manera:

interface Gift {
  void present();
}

interface Guest {
  boolean present();
}

class Presentable implements Gift, Guest {
  @Override
  public void present() {
    System.out.println("Present as a gift!");
  }
}

aquí, regalo.present () y invitados.present () tienen tipos de retorno incompatibles (nulo vs. boolean). Como resultado, presentable no puede implementar ambas interfaces ya que violan las reglas de primo.

en conclusión, cuando una clase implementa múltiples interfaces con métodos de anulación equivalentes, el compilador reconoce que solo hay un método para implementar, y la anotación @Override en el método primordial aplica a todas las interfaces. Sin embargo, las incompatibilidades entre las firmas del método conducirán a errores de compilación.