substituindo ambiguidade com várias interfaces

No reino da programação orientada a objetos, as classes podem implementar várias interfaces. No entanto, quando essas interfaces possuem métodos com assinaturas idênticas, surge uma pergunta: como o compilador resolve qual método de interface é substituído?

em Java, uma classe que implementa várias interfaces com esses métodos sobrepostos terá apenas uma implementação eficaz. O compilador não distingue entre os métodos baseados em sua origem da interface. int f (); } Interface B { int f (); } classe de teste implementa a, b { @Override public int f () { retornar 0; } }

Neste cenário, o teste implementa A e B, e ambas as interfaces definem um método chamado f () com a mesma assinatura. Ao substituir esse método no teste, a classe substitui efetivamente o método f () de ambas as interfaces, embora apenas uma anotação @Override esteja presente. Como resultado, o compilador escolhe o primeiro método de substituição que encontra, independentemente de sua origem da interface. Nesses casos, o compilador relatará um erro, pois não é possível ter dois métodos com a mesma assinatura, mas diferentes tipos de retorno na mesma classe. vazio presente (); } Convidado da interface { presente booleano (); } classe Apresentável implementa presente, convidado { @Override public void presente () { System.out.println ("Presente como um presente!"); } }

interface A {
  int f();
}

interface B {
  int f();
}

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