1. public interface Interface1 {
2. void foo();
3. }
1. public interface Interface2 {
2. void foo(int i);
3. }
1. public interface Interface3 {
2. int foo();
3. }
1. public class InterfaceImpl implements Interface1, Interface2, Interface3 {
2. public int foo() {
3. return 0;
4. }
5. public void foo(int i) {
6. }
7. public static void main(String[] args) {
8. System.out.println ("Result: " + new InterfaceImpl().foo());
9. }
10. }
a resposta correta seria
[quote]
Compilation fails, the compiler reports that the return type is incompatible with Interface1.[/quote]
mas o certo não seria :
[quote]
Compilation fails, the method void foo() from interface Interface1 is not implemented.[/quote]
reparem que ele fala que o tipo de retorno e incompativvel… com o da Interface1 , so que na interface 3 que ele tbm implementa…possui um metodo com implementação correta na subclasse…
logo o metodo , void foo(); não foi implementada na subclasse…
Overload ocorre quando os tipos dos parametros do metodo sao diferentes ou em numero diferentes. Nao eh considerado overload quando somente o valor de retorno muda.
Note que a Interface1 tem o metodo void foo(), e a Interface3 tem o int foo() … como a tua classe implementa essas duas interfaces, ha um conflito de nomes.
falando em overload Rafael…me lembrou algo a respeito de overrinding em metodos staticos…
Eu tenho lido…tanto na especificação…quando em outros lugares…( um doc que o Marcus Green escreveu…) falando sobre…
dizendo que pessoas escreveram para ele…diznedo que ele tinha dito…que não existe overrinding de metodos staticos…e que muitas pessoas mandaram emails para ele provando que existia…(achavam, que existia…)
a especificação é bem clara diznedo que não existe overriding para metodos staticos…
mas então porque conseguimos redeclarar um metodo…(claro…que com o modificador static junto…)…em uam subclasse??
Isso ja esta sendo discutido em um outro topico no forum.
O compilador nao vai acusar erro caso voce tenha, na classe filha, uma redeclaracao do mesmo metodo, estatico, na classe pai, so que o funcionamento eh um tanto diferente do usual… Por exemplo, faca o teste
class Pai {
public static void a() {
System.out.println("Pai::a()");
}
}
class Filho extends Pai {
public static void a() {
System.out.println("Filho::a()");
}
}
public class Teste {
public static void main(String[] args) {
Pai.a();
Filho.a();
Filho f = new Filho();
f.a();
Pai p = new Filho();
p.a();
}
Note que no ultimo caso, vc tem um objeto do tipo Pai que aponta para uma referencia do tipo Filho, mas com o teu objeto em si eh um Pai, o metodo estatico dele sera chamado, ao contrario do que aconteceria em overriding de metodos nao estaticos.
