Mas vamos a prática e alguem me ajuda dizendo se entendi ou não.
public interface Sons {
public void Som();
}
Public abstract class Mamifero{
public mamifero (String S){
setSom(s);
}
Public class Cachorro extends Mamifero implements Sons{
public Cachorro(String S){
super (S);
}
Public void Som(){
latir();
}
Já sou quase um biologo de tanto que entendi de Taxonomia mas ainda nao entendi nad ade java.
alguem pode me ajudar dizendo se entendi errado algum conceito e tals?
Vamo lá me da mais uma chance…auehauehaea
acho que entendi a parada agora.
Só que cai num beco sem saida uma hora, veja que coloquei os 3 tipos de som no mesmo arquivo, ai eu percebi que quando fui chamar apenas latir no cachorro e apenas miar no gato disse q eu precisava q os 2 fossem abstratos, pois nao implementao todos os metodos descritos na interface. ai soh pra dar certo eu coloquei os metodos no mamifero.
Mas entao me diga uma coisa, quando tenho coisas especificas tipo GATO e CACHORRO o correto seria fazer uma interface pra cada?
ou criar algo mais generico? tipo SONS, e dai em gato dizer q eh miau e em cachorro dizer auau, soh que usando apenas 1 tipo de metodo…
Arquivo Interface Sons.java
public interface Sons{
public String latir();
public String miar();
public String generico();
}
Mamifero.java
public abstract class Mamifero implements Sons{
protected String var1;
public String Mamifero(){
return var1 = "Mamifero";
}
public String Mamifero(String Par){
return var1 = Par;
}
public String setMamifero(){
return var1 = "Mamifero";
}
public String getMamifero(){
return var1;
}
public String Andar(){
return var1 = "10";
}
public String SomAnimal1(){
return var1 = "Grr";
}
public String generico(){
return SomAnimal1();
}
public String miar(){
return "erro";
}
public String latir(){
return "erro";
}
}
Cachorro.java
class Cachorro extends Mamifero implements Sons{
public Cachorro(){
super();
}
public String SomAnimal(){
return var1 = "au au";
}
public String latir(){
return SomAnimal();
}
}
Gato.java
class Gato extends Mamifero implements Sons{
private String var1;
public Gato(){
super();
}
public String SomAnimal(){
return var1 = "miau";
}
public String miar(){
return SomAnimal();
}
}
usando tudo isso de algum modo uaheauehaea
import java.util.*;
public class Main{
public static void main(String args[]){
Sons G = new Gato();
System.out.println(G.miar());
Sons C = new Cachorro();
System.out.println(C.latir());
Sons QQ = new Gato();
System.out.println(QQ.generico());
Sons AA = new Cachorro();
System.out.println(AA.generico());
}
}
Oi.
Cara, primeiramente, um cachorro é um Som? Um gato também? Você precisa rever seus conceitos de orientação a objetos.
Essa interface que você tá tentando entender é a interface do Java né? Porque existem mais 2 tipos de interface: um contrato e a GUI.
A interface serve, principalmente, quando você tem um objeto que tanto é uma coisa quanto outra. Como o Java não quer que você caia em coisas casca grossa como o losango mortal (óóó!, http://www.gotw.ca/gotw/037.htm), eles colocaram a interface.
Se uma classe “implements” uma interface, você vai ser obrigado a implementar nessa classe que “implements” todos os método que temos na interface. Ou seja, se um cachorro é um som, ele vai ter que implementar tanto latir() quanto miar() e generico(). Isso é errado, certo? É nesse ponto que você chega e deve se perguntar se o seu design está correto ou não. Você pode ver que ele está errado, porque um cachorro nunca vai poder miar nem um genérico da vida, né?
Além disso, miar(), generico() e latir() não deveriam estar na classe Mamifero. Nessa classe, deveriam estar somente os atributos e métodos que interessam ao mamífero, que não precisa necessariamente ser um gato ou um cachorro. Se você fosse fazer isso pra um zoológico inteiro, você teria sérios problemas, porque cada vez que um animal fosse adicionado, você teria que mexer no código da classe Mamífero (o que nós não queremos, porque a OO prega que um código, depois de pronto, deve ser pouco modificado. E ainda, quando for, não acarretar muitas outras modificações. Se isso ocorre, reveja o projeto).
Veja conceitos sobre Composição também. E estude mais a orientação a objetos.
Então é o seguinte, eu realmente sozinho percebi que não tava dando muito certo essa interface SOM, pois acabei vendo que ao não colocar todas as implementacoes da interface eu teria que deixar ela como abstrata e não era isso que eu queria no cachorro nem no gato.
Então a interface é tão especifico quanto a classe, tipo INTERFACE CACHORRO, CLASSE CACHORRO.
e nao INTERFACE SOM PARA cachorro,gato e generico.
Mas blz cara…to achando que entendi o conceito de interface.
public class Cao extends Comunicavel {
public Cao() {
super(new Latir());
}
public void latir() {
super.comunicar();
}
}
Acho que é isso, o exemplo não é muito bom, mas você tem sempre que tentar seu modelo fazer sentido… Não vejo muito sentido em um cão ser uma comunicação… mas no final o problema é o exemplo.
public interface Comunicacao {
void comunicar();
}
Pessoal, não poderia ser feito isso? (1º exemplo)
public class Cao implements Comunicacao {
public void comunicar(){
System.out.println("Au Au");
}
}
Ao invez disso:
public class Gato {
public void miar() {
new Miar().comunicar();
}
}
Alguém pode me dar uma dica, pois eu achei que o primeiro exemplo, seria suficiente.[/quote]
Desculpa, não tinha prestado muita atenção, mas tava pensando aqui…
public interface Comunicavel {
void comunicar();
}
public class Cao implements Comunicavel {
public void comunicar() {
system.out.println("au au");
}
}
