Bem venho estudando orientação a objetos há algum tempo e vejo muito gente falar que interfaces
pode ter mesmo efeito que herança multipla mas como…? eu gostaria de saber como é isso na teoria,
não consigo pensar em uma interface com o papel de outra classe uma vez que uma interface é apenas
uma idéia abstrata de como uma classe deve aguir implementado seus métodos, estou errado em meus
conceitos…?
Conceito herança e interfaces
8 Respostas
Uma forma simples de se pensar é pegar o exemplo da interface Comparable
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Comparable.html
Vc precisa ter apenas um método: compareTo(object o)
Imagine que vc tem um array de objetos quaisquer. Vc quer ordena-los da forma como vc acha melhor. O metodo estático sort da classe Arrays pode ordenar o seu vetor de objetos através do compareTo. Então o seu objeto que tem características que vc designou vai se comportar, nessa etapa de ordenação, como um objeto Comparable.
T
Uma classe implementar várias interfaces tem o efeito de herança múltipla, mas não é herança múltipla.
Exemplo de herança múltipla (em C++):
#include <iostream>
#include <string>
using namespace std;
/** Note que não há uma classe Object em C++, vamos simulá-la */
class Objeto {
public:
virtual string toString() { return "objeto"; }
virtual int hashCode() { return (int) this; }
}
class Navio : public Objeto {
public:
virtual void navegar() { cout << "navegando" << endl; };
virtual string toString() { return "navio"; }
}
class Aviao : public Objeto {
public:
virtual void voar() { cout << "voando" << endl; };
virtual string toString() { return "aviao"; }
}
class Hidroaviao : public Navio, public Aviao {
virtual string toString() { return "hidroaviao"; }
}
int main (int argc, char*argv[]) {
Aviao *a = new Hidroaviao();
Navio *n = new Hidroaviao();
a->voar();
n->navegar();
cout << a->toString() << endl; // imprime "hidroaviao"
cout << n->toString() << endl; // imprime "hidroaviao"
Hidroaviao *ha = new Hidroaviao();
ha->voar();
ha->navegar();
cout << ha->toString() << endl; // imprime "hidroaviao"
delete a; delete n; delete ha;
}
O programa equivalente em Java seria:
interface Navio {
void navegar();
}
class NavioImpl implements Navio {
public void navegar () { System.out.println ("navegando"); }
public String toString () { return "navio"; }
}
interface Aviao {
void voar();
}
class AviaoImpl implements Aviao {
public void voar () { System.out.println ("voando"); }
public String toString () { return "aviao"; }
}
class Hidroaviao implements Navio, Aviao {
private Navio navioImpl = new NavioImpl();
private Aviao aviaoImpl = new AviaoImpl();
public void navegar () { navioImpl.navegar(); }
public void voar () { aviaoImpl.voar(); }
public String toString () { return "hidroaviao"; }
}
class Main {
public static void main(String[] args) {
Aviao a = new Hidroaviao();
Navio n = new Hidroaviao();
a.voar();
n.navegar();
System.out.println (a.toString()); // imprime "hidroaviao"
System.out.println (n.toString()); // imprime "hidroaviao"
Hidroaviao ha = new Hidroaviao();
ha.voar();
ha.navegar();
System.out.println (ha.toString()); // imprime "hidroaviao"
}
valew thingol
tava olhando aqui no guj esse tutorial http://www.guj.com.br/java.tutorial.artigo.123.1.guj
também é excelente agora vou a pratica qualquer dúvida eu coloco ai até mais.
D
Tipo assim…Na Herança, vc tem que as classes filhas tem todas as características da classe mãe e ainda suas características próprias…em c++ uma classe pode herdar de mais de uma, portanto terá as caractrísticas de todas, métodos e atributos e ainda as dela, se preciso…
no java, vc pode estender apenas de uma classe, e implementar qnts interfaces quizer ou for necessário…como uma interface não trás código algum a não ser declarações, vc deve implementar os métodos na classe filha…onde isso é útil???
Digamos que vc precisa fazer a interação entre algumas classes, como quando tá trabalhando com um JFrame que chama vários JPanel’s internamente…Os JPanel’s não sabem da existência do JFrame, mas se vc implemetar uma interface e fazer com que os JPanel’s implementem a mesma, o JFrame terá um conjunto de métodos comum a todos os JPanels que ele poderá chamar, assim é possível fazer uma interação mto interessante entre todas essas classes. Note que os JPanels já estendem a classe javax.swing.JPanel.
Bom, eu gosto de usar as interfaces, são uma mão na roda quando vc têm uns problemas cabulosos pra resolver…
é isso ae…
Flws!!!
Cara olha o exemplo que eu criei:
package com.polimorfismo;
public interface Pacientes
{
public String getHistorico();
}
package com.polimorfismo;
public class Cachorro implements Pacientes
{
private String nome;
private String raca;
private String idade;
private String doenca;
private int consultas;
public Cachorro(String nome,String raca,String idade,String doenca,int consultas)
{
this.nome=nome;
this.raca=raca;
this.idade=idade;
this.doenca=doenca;
}
public Cachorro(String nome,String raca,String idade,int consultas)
{
this.nome=nome;
this.raca=raca;
this.idade=idade;
this.consultas=consultas;
}
public String getNome()
{
return this.nome;
}
public String getRaca()
{
return this.raca;
}
public int getConsulta()
{
return this.consultas;
}
public String getIdade()
{
return this.idade;
}
public String getDoenca()
{
return this.doenca;
}
public String getHistorico()
{
return ((this.doenca==null)?"O paciente "+this.getNome()+" consultou "+this.getConsulta()+" a raça é "+this.getRaca()+
" a idade é "+this.getIdade():"O paciente "+this.getNome()+" consultou "+this.getConsulta()+" a raça é "+this.getRaca()+
" a doença é "+this.getDoenca()+" a idade é "+this.getIdade());
}
}
package com.polimorfismo;
public class Pessoa implements Pacientes
{
private String nome;
private String nacionalidade;
private String idade;
private String doenca;
private int consultas;
public Pessoa(String nome,String nacionalidade,String idade,String doenca,int consultas)
{
this.nome=nome;
this.nacionalidade=nacionalidade;
this.idade=idade;
this.doenca=doenca;
}
public Pessoa(String nome,String nacionalidade,String idade,int consulta)
{
this.nome=nome;
this.nacionalidade=nacionalidade;
this.idade=idade;
this.consultas=consulta;
}
public String getNome()
{
return this.nome;
}
public String getRaca()
{
return this.doenca;
}
public int getConsulta()
{
return this.consultas;
}
public String getIdade()
{
return this.idade;
}
public String getDoenca()
{
return this.doenca;
}
public String getHistorico()
{
return ((this.doenca==null)?"O paciente "+this.getNome()+" consultou "+this.getConsulta()+" a nacionalidade é "+this.getRaca()+
"a idade é "+this.getIdade():"O paciente "+this.getNome()+" consultou "+this.getConsulta()+" a nacionalidade é "+this.getRaca()+
"a doença é "+this.getDoenca()+" a idade é "+this.getIdade());
}
}
package com.polimorfismo;
public class TestaPacientes
{
public static void main(String args[])
{
Pacientes vet[] = new Pacientes[4];
vet[0] = new Cachorro("Bommer","Fox terrier","5 anos","Perabas na coxa",5);
vet[1] = new Cachorro("Bommer","Fox terrier","5 anos",5);
vet[2]= new Pessoa("Wagner","Brasileiro","41 anos","Aids",15);
vet[3]= new Pessoa("Luciano","Boliviano","40 anos","Clilique depressivo",25);
for(Pacientes paciante : vet)
{
System.out.println(paciante.getHistorico());
}
}
}
O que eu entendi apliquei ai e isso mesmo galera…?
R
Vc n ta simulando herança múltipla aí… pra fazer isso uma classe precisa implementar mais de uma interface (ou herdar de uma classe e implementar pelo menos uma interface).
Certo cara neste código quiz apenas mostrar o conceita de interface mesmo.
L
Um exemplo (classico) do Cachorro e Gato :lol:
Tenho as seguintes classes e interfaces
interface Animal {
void comer();
}
interface Cachorro extends Animal {
void latir();
}
interface Gato extends Animal {
void miar();
}
class GatoAmericano implements Gato {
public void miar() {
System.out.println("miando como um gato americano");
}
public void comer() {
System.out.println("comendo feito um gato americano");
}
}
class CachorroEuropeu implements Cachorro {
public void latir() {
System.out.println("latindo como um cachorro europeu");
}
public void comer() {
System.out.println("comendo feito um cachorro europeu");
}
}
Ou seja, defini uma interface de Animal, que diz que eles devem comer, uma para Cachorro e outra para Gato. Depois criei um gato americano e um cachorro europeu, ateh ai beleza, coisa simples.
Agora um gato Americano deu uma pimbada em uma cadelinha europeia, e gerou um filhote, meu deus, como representar essa criatura, ela herdou coisas dos dois, que fazer?! bem, partindo do principio que a cadelinha que deu a luz, eu imagino que a criatura se parece mais com um cachorro (genetica naum eh meu forte), entao o treco vai ser um cachorro (comer como um cachorro, latir, etc, coisas de cachorro)… mas tera os comportamentos de gato, hmm, entao eu acho que representaria assim esse animal:
class CachorroBizarro extends CachorroEuropeu implements Gato {
Gato gato = new GatoAmericano();
public void miar() {
gato.miar();
}
}
Ou seja, ele eh um cachorro que mia feito um gato americano, mas naum come feito um gato americano.
Ai o cachorrao vendo isso disse, pqp!! vou dar uma pimbada numa gata europeia agora, e la foi ele, ocorreu a mesma coisa, a gata ficou grafida e pariu outro animal bizarro, sendo que veio da gata (e partindo da nossa logica de criacao, onde as femeas que ditam com que vai parecer), imaginemos que o animal se parece mais com um gato e vai agir como um gato, mas ele da suas latidas de vez em quando (as pessoas olham para ele e dizem: “olha que gatinho”, mas ele late). Como ele se parece com gato, naum podemos dizer que ele eh um CachorroBizarro, afinal o cachorro bizarro se parece com um cachorro, entao criaremos outra classe para ele:
class GatoBizarro extends GatoAmericano implements Cachorro {
Cachorro cachorro = new CachorroEuropeu();
public void latir() {
cachorro.latir();
}
}
Pronto, fizemos heranca multipla usando interface e agregacao… qual a vantagem, justamente essa de vc ser na realidade somente uma coisa, mas poder adquitir o comportamento de outra. Nao ha essa indessisao de: “o que fazer” em metodos como comer. Se eu tivesse algo como
class FilhoteBizarro extends GatoAmericano, CachorroEuropeu {
}
ou seja, uma geranca multipla mesmo, o filhote iria latir (ok), miar (show de bola), mas como ele iria comer?! como um gato ou como um cachorro?! ai que entra os problemas que eu vejo em heranca multipla, ele naum eh mais Cachorro ou mais Gato, ele simplesmente herda dos dois, ai na hora de comer ele naum sabe se prefere whiskas ou pedigree champ. Esse FilhoteBizarro podia ter vindo tanto da gata quando da cadela que deu cria, entao existe essa indecisao quanto a como ele vai comer, quando veio da gata eh feito gato e quando veio da cadela eh feito cachorro?! como representar isso num objeto daqueles assim?
executa depois esse teste e vc vai ver que esse problema naum ocorre com java, o cachorrinho bizarro da suas miadas, mas ele sabe que eh na real um cachorro, e vai comer feito cachorro.
public class Main {
public static void main(String[] args) {
GatoBizarro gb = new GatoBizarro();
gb.miar();
gb.latir();
gb.comer();
CachorroBizarro cb = new CachorroBizarro();
cb.miar();
cb.latir();
cb.comer();
}
}
Eu podia ainda ter o filho do cachorro bizarro com o gato bizarro que simplesmente ficou diferente de tudo, as pessoas olham ele e naum sabem se eh gato ou cachorro, ele naum herda caracteristicas proprias de um tipo de gato ou cachorro, ele soh tem comportamentos, mas nada que pudesse dizer: ah, eh um GatoAmericano!
class Mosntro implements Cachorro, Gato {
GatoBizarro gb = new GatoBizarro();
CachorroBizarro cb = new CachorroBizarro();
public void latir() {
gb.latir();
}
public void comer() {
cb.comer();
}
public void miar() {
System.out.println("miando de forma unica");
}
}
Ele lati feito um gato bizarro, come feito um cachorro bizarro e mia de forma unica hehehe mas perceba que mesmo assim eu tem que definir cada metodo, naum existe indecizao sobre como ele vai agir.
Espero que tenha ajudado
valeu!
Criado 5 de outubro de 2007
Ultima resposta 6 de out. de 2007
Respostas 8
Participantes 6