Re:Interfaces e herança, dúvida básica

Programação Java
#1

Quando você implementa uma interface, é obrigado a implementar todos os métodos dela. Portanto, você pode continuar tendo o seu método B m(B) se quiser, mas precisa de C m© obrigatoriamente, pois a interface A o obriga a implementá-lo.
Se você continuar com os dois métodos, estará usando a sobreposição, ou seja, dois métodos com o mesmo nome e parâmetros com tipos diferentes e, no caso, tipo de retorno diferente.
É isso.
Abraço.

#2 
class C {
}
interface A {
    public C m(C arg);
}
public class B extends C implements A {
    // Note que isto não implementa C m(C arg) porque é "mais específico".
    public B m(B arg) {
        return null;
    }
    // Da mesma forma, public Object m (Object arg) também não implementa C m(C arg), porque é "menos específico".
    public Object m(Object arg) {
        return null;
    }
    // Para implementar corretamente A, a declaração correta poderia ser:
//    public B m(C arg) { // usando "covariant return" do Java 5.0
//        return null;
//    }
    // ou então, o que é mais óbvio,
//    public C m(C arg) {
//        return null;
//    }
}
#3

Na verdade no java 5 vc pode fazer isso sim. Baixe o novo jdk e teste.

#4

Cara, de uma olhada en Generics http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html.

#5

[quote=Leandro Diniz]Tá legal… eu entendi, e já agradeço a ajuda…
Mas… (sempre tem um “mas”)
Eu gostaria de que as classes que implementassem A tivessem um método (obrigatoriamente) que recebesse “alguns tipos de classes” e não uma classe específica…
O que acontece na prática, hoje, é que eu implemento este método recebendo Object, e adivinha o que eu sou obrigado a fazer em seguida? Cast! Eu uso Java 5, não gostei muito da idéia de fazer um cast… hehehe…

[/quote]

Ah, então o que você quer fazer é mais ou menos o seguinte:

(Testado com Java 5.0)

class C {
}
interface A<T> {
    public T m(T arg);
}
public class B extends C implements A<B> {
    public B m(B arg) {
        return null;
    }
}
class D extends C implements A<D> {
    public D m(D arg) {
        return null;
    }
}
class E implements A<E> {
    public E m(E arg) {
        return null;
    }
}
// Note que a seguinte herança não funciona
// (vai dar o erro "A cannot be inherited with different arguments: <F> and <D>")
//class F extends D implements A<F> {
//    public F m(F arg) {
//        return null;
//    }
//}

// mas esta funciona:
class F extends D {
    public D m(D arg) {
        return null;
    }
}
#6

[quote=Leandro Diniz] class C { } interface A<T> { public T m(T arg); } public class B extends C implements A<B> { public B m(B arg) { return null; } }
Sim! Isso resolveu! Obrigado… mas… (denovo)
Por quê? Como isso funciona? O que ele está fazendo na verdade?

Manjo muito pouco de Java5… :frowning:
[/quote]

Agora é com você.

O tutorial oficial:
http://java.sun.com/docs/books/tutorial/extra/generics/index.html

O FAQ “quase-oficial”:
http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html

#7

Porque eu não posso fazer isso?

public class B extends C implements A {
	public B m(B arg) {
		return null;
	}
}
interface A {
	public C m(C arg);
}
class C{}

E sou obrigado a receber “C” no método “m”!

Valeu!

#8

Tá legal… eu entendi, e já agradeço a ajuda…
Mas… (sempre tem um “mas”)
Eu gostaria de que as classes que implementassem A tivessem um método (obrigatoriamente) que recebesse “alguns tipos de classes” e não uma classe específica…
O que acontece na prática, hoje, é que eu implemento este método recebendo Object, e adivinha o que eu sou obrigado a fazer em seguida? Cast! Eu uso Java 5, não gostei muito da idéia de fazer um cast… hehehe…

Eu aposto que meu problema é concentual e muito básico, mas eu não sei o que fazer… :confused:

Valeu denovo!

AHÁ! Alguém que pensa como eu, adivinha só bbviana?? Eu estou usando Java 5!!!

#9 
class C {
 }
 interface A<T> {
     public T m(T arg);
 }
 public class B extends C implements A<B> {
     public B m(B arg) {
         return null;
     }
 }

Sim! Isso resolveu! Obrigado… mas… (denovo)
Por quê? Como isso funciona? O que ele está fazendo na verdade?

Manjo muito pouco de Java5… :frowning:

#10