Parametri di tipo

[linux_r]

interface Animale<C extends Cibo>{
        void mangia(C cibo);
} 

public class Erbivoro<E extends Erba> implements Cibo,Animale<E>{
               public void mangia(E erba){
               
               }
}

Che differenza c'è nel definire la classe erbivoro in questo modo

public class Erbivoro implements Cibo,Animale<Erba>{

                public void mangia(Erba erba){
               
               }
}

[Alex'87]

Secondo me è errato (in entrambi i casi) far implementare Cibo ad Erbivoro.

Erbivoro non è-un Cibo mentre è corretto che Erbivoro è-un Animale.(poi dipende da cosa intendi con Cibo, ma non è chiaro ora). Non è l'interfaccia in sé a turbarmi, ma il fatto che sia chiami Cibo ^^'Dato inoltre che la caratteristica di Erbivoro è di mangiare Erba, io non lo specificherei dall'esterno. Quindi:

public class Erbivoro implements Animale<Erba> { ... }

Nell'altro caso potresti poter fare una cosa del genere: new Erbivoro<Carne>()... che ha poco senso.

[linux_r]

un Erbivoro è il cibo di un carnivoro!! quindi erbivoro è anche un cibo. cosi come per noi ogni animale oltre a essere un animale è anche un cibo

[linux_r]

Non è l'interfaccia in sé a turbarmi, ma il fatto che sia chiami Cibo ^^'Dato inoltre che la caratteristica di Erbivoro è di mangiare Erba, io non lo specificherei dall'esterno.

Potresti riscrivere meglio, proprio in italiano non mi è chiaro ciò che hai scritto . grazie

Nell'altro caso potresti poter fare una cosa del genere: new Erbivoro<Carne>()... che ha poco senso.

Purchè carne estenda erba però !!

[Alex'87]

Potresti riscrivere meglio, proprio in italiano non mi è chiaro ciò che hai scritto . grazie

Purchè carne estenda erba però !!

Scusami, ho fatto un po' di confusione io e ho detto qualche minchiata (ho letto di fretta durante un deploy)

A:

public class Erbivoro<E extends Erba> implements Cibo, Animale<E> { 
    public void mangia(E e) { }
}

B:

 
public class Erbivoro implements Cibo,Animale<Erba> { 
    public void mangia(Erba erba) { }
}

La differenza tra A e B è che

in A tu costruisci un erbivoro dicendogli cosa mangerà. E mangerà solo quello

Quindi

Erbivoro<Mele> e = new Erbivoro<Mele>();
e.mangia(new Mele()); // OK

e.mangia(new Pere()); // NO!

In B invece l'oggetto da mangiare lo passi direttamente a mangia() quindi puoi fare:

e.mangia(new Mele()); // OK
e.mangia(new Pere()); // OK!

(sempre restando su sottoclassi di Erba)


Spero di non aver scritto minchiate, sono fuso oggi .-.

[linux_r]

Scusami, ho fatto un po' di confusione io e ho detto qualche minchiata (ho letto di fretta durante un deploy)

A:

public class Erbivoro<E extends Erba> implements Cibo, Animale<E> { 
    public void mangia(E e) { }
}

B:

 
public class Erbivoro implements Cibo,Animale<Erba> { 
    public void mangia(Erba erba) { }
}

La differenza tra A e B è che

in A tu costruisci un erbivoro dicendogli cosa mangerà. E mangerà solo quello

Quindi

Erbivoro<Mele> e = new Erbivoro<Mele>();
e.mangia(new Mele()); // OK

e.mangia(new Pere()); // NO!

In B invece l'oggetto da mangiare lo passi direttamente a mangia() quindi puoi fare:

e.mangia(new Mele()); // OK
e.mangia(new Pere()); // OK!

(sempre restando su sottoclassi di Erba)


Spero di non aver scritto minchiate, sono fuso oggi .-.

supponendo pero anche nel caso A che mele sia sottoclasse di erba

[schumy2000]

Spero di non aver scritto minchiate, sono fuso oggi .-.

E ci credo...con tutta questa erba...