Estou com um problema…
preciso que criar uma classe que execute um métodos padrões, já implementados, ou seja… preciso dar um jeitinho de fazer uma herança multipla!
Tentei criar uma classe abstrata, mas descobri que uma interface não pode extendê-la… :oops:
Alguém por ai sabe como posso resolver isso: segue abaixo o que eu estou querendo fazer, apesar de não ter funcionado dá pra ter uma idéia!
Valeu galera,
:arrow: Qualquer dica é bem vinda!
falow!
[code]// Primeira clase. Todas as outras classes terão exatamente
// os métodos abaixo
public abstract class AmazenaErro {
// Tentei criar uma interface extendendo a classe acima
// Isso não funcionou, decobri que interface só extende
// outra inteface
public interface RetornaErro extends AmazenaErro {};
//Outras classes que terão os métodos acima
public class carro extends Thread implements RetornaErro {
// outros métodos da classe
};
public class Login extends ActionSuport implements RetornaErro{
// outros métodos da classe
};[/code]
Acho que você tem que se decidir:
Ou as classes herdam os métodos prontos da superclasse (use somente a classe Armazenazero);
Ou as classes implementam os métodos da interface (use somente a interface RetornaErro)
As duas coisas fica difícil.
[quote=“dsiviotti”]Acho que você tem que se decidir:
Ou as classes herdam os métodos prontos da superclasse (use somente a classe Armazenazero);
Ou as classes implementam os métodos da interface (use somente a interface RetornaErro)
As duas coisas fica difícil.[/quote]
Na verdade o problema é o seguinte:
Suponhamos que eu queira adicionar esses métodos em todas as minhas classes, veja que no caso da classe carro, ela já está extendendo a classe Thread, então eu não poderia extender minha classe abstrata.
Mas se eu usar uma interface, vou ser obrigado a copiar e colar esses métodos em todas as minha classes e ainda corro o risco de precisar fazer uma alteração. imagine se eu tiver umas 40 classes implementando esses métodos. Um simples correção faria com que eu precisasse altera toda as classes…
Preciso fazer a herança de foma que eu possa extender essa classe com as outras que as classes já extendem!!!
Mesmo assim valeu pela atenção!!
Um abraço galera!!
Eitcha … o normal e que atende 100% dos casos (já que é o unico jeito :? ) é a Interface definir o seu objeto (metodos), a classe abstrata implementar todos os comuns e deixar os demais como abstratos pras subclasses implementarem.
No caso especifico de precisar herdar de mais de uma classe vc precisa ir fazendo mais classes pra irem herdando de cima pra baixo … (especificamente com threads vc nao precisa, use a interface Runnable pra ter a mesma funcionalidade).
Lembrando que se vc precisa que a classe abstrata apenas dÊ pras outras classes alguns metodos de apoio que nao tem nada a ver com o negocio dessas classes o seu projeto está errado. Repense pra usar esses metodos como servicos de um outro objeto e nao um incorporado nas suas classes.
Vê só cara. Acho que estamos diante de tópico muito comun em livros de orientação à objetos: “Herança X Composição, quando usar o quê?”.
Na minha opinião, acho que tu não deveria usar herança só herdar código, e sim quando tu queres herdar código e herdar o tipo. E utilizando o teu exemplo, códigos, dependendo do ponto de vista, dúbios poderiam aparecer. Por exemplo:
ArmazenaErro erro = new Carro();
O que usar então??? Composicção! Ou seja, em todas as tuas classes que tu quiser ter essa caracteristica, tu pode só ter um atributo ArmazenaErro mais um método get para ele.
Mas se você estiver também interessado na herança de tipos, o que tu pode fazer é definir uma simples interface (por exemplo, Erravel) contendo o método get, ficando muito simples para qualquer classe implementa-la. Exemplo:
interface Erravel {
public ArmazenaErro getErro();
}
public class carro extends Thread implements Erravel {
//...
private ArmazenaErro erro;
//...
public ArmazenaErro getErro() {
return this.erro;
}
//...
}
public class Login extends ActionSuport implements RetornaErro{
//...
private ArmazenaErro erro;
//...
public ArmazenaErro getErro() {
return this.erro;
}
//...
};
E uma vez com o get, tu tem teu erro armazenavel na hora que tu quiser, e da maneira como ele tiver sido implementado e/ou alterado, sem precisar reescrever o código!!
No fim da contas tu usa dois grandes conceitos de orientação à objetos, Herança + Composição. Complicado? Talvez? mas acho uma excelente solução para um problema não tão trivial.
).