Newsgroup: it.comp.java
Titolo: parere

 un grosso limite di java e' che non permette
la derivazione multipla!!!
--------------------------------
Inviato via 
http://usenet.libero.it

 la derivazione multipla!!!
A che servono le interfaccie allora?
Davide

 la derivazione multipla!!!
limite??? e dire che c'e' un sacco di roba scritta sul
paradigma OO che sconsiglia l'uso dell'eredita' multipla...
e poi come ti hanno detto puo' essere simulata ricorrendo
alle interfacce ^_^

 la derivazione multipla!!!
Ciao,
secondo me, prima di esprimere un parere su qualsiasi argomento,
bisognerebbe essere a conoscenza non dico totale ma almeno parziale
dell'argomento di cui si vuole esprimere tale parere, piuttosto che sferzare
imperativi addirittura con 3 punti esclamativi :-)
In Java puoi estendere un'unica classe ma puoi implementare quante
interfacce vuoi, ottenendo cosi' lo stesso obiettivo
dell'ereditarietą multipla ad esempio del C++.
Un consiglio:
http://java.sun.com/docs/books/tutorial/java/concepts/interface.html
Ciao
euterpex

 dell'ereditarietą multipla ad esempio del C++.
Sicuri che si la stessa cosa?
io non credo, le interfacce lasciano all'implementatore il compito
di scriverne il corpo, non altrettanto vale per l'ereditarietą.
Con questo non voglio lamentarmi di nulla ma non č la stessa cosa.
edoardo

 di scriverne il corpo, non altrettanto vale per l'ereditarietą.
Il mio era un riferimento in senso lato non in senso stretto.
Dico solamente che con le interfacce posso simulare l'ereditarietą multipla,
tutto qui.
Ciao
euterpex

 di scriverne il corpo, non altrettanto vale per l'ereditarietà.
Il "corpo" della classe composta contiene, per ogni interfaccia 
implementata, l'invocazione del metodo di uguale signature dell'oggetto 
componente.
Ad esempio se hai
    	interface I1 { void m1(); }
    	interface I2 { void m2(); }
   	class Base1 implements I1 { void m1(); }
    	class Base2 implements I2 { void m2(); }
la classe composita e'
    	class Derivata implements I1, I2 {
    	    	private Base1 b1;
    	    	private Base2 b2;
    	    	void m1() { b1.m1(); }
    	    	void m2() { b2.m2(); }
    	}
Il codice in piu' c'e', ma e' banale e si puo' anche generare 
automaticamente.
-- 
Life's something u don't get out alive..
ObjectZone - 
http://space.tin.it/computer/csadun

 soprattutto se riguardano una parte così importante di un linguaggio.
Se ti riferisci alla soluzione data da Java all'ereditarieta' multipla
non credo che si trati di una pezza.
La soluzione adottata da Java ovvero quella di lasciare
all'implementatore della classe che estende piu' intefacce
di specificare la realizzazione delle implementazioni di 
ognuna di esse e' molto elegante secondo la mia 
modestissima opinione ^_^
E' vero che non permette il riuso del codice delle classi
che estende (poiche' in un certo senso stiamo derivando dei
metodi astratti dalle interfacce e ci tocchera' realizzarli),
pero' previene tutte quelle ambiguita' che possono manifestarsi 
nell'ereditarieta' multipla e nello stesso tempo permette 
comunque di riusare tutto quel codice che lavorava sulle 
singole classi che vengono estese.
Di contro non ci permette di riusare il codice delle superclassi
che estende, pero' di una cosa dobbiamo accontentarci ^_^

 automaticamente.
Si ma stiamo sempre simulando l'eredita' multipla...
Teoricamente una classe che ha eredita' multipla non dovrebbe
aggregare le classi che estende, anche perche' non sarebbe
bello da vedersi vero? ^_^

 bello da vedersi vero? ^_^
In Java non c'e' l'eredita' multipla, ma appunto si ottiene lo stesso 
risultato funzionale via interfacce e composizione.


 
Se ti dico che lo sapevo ti stupisci?
Comunque "generare automaticamente" non è la stessa cosa di
"ereditare"
edoardo

 Se ti dico che lo sapevo ti stupisci?
(Quasi) nulla mi stupisce piu' a questo mondo. :) 
Noto semplicemente come la tua risposta 
<quote>
Sicuri che si la stessa cosa?
io non credo, le interfacce lasciano all'implementatore il compito
di scriverne il corpo, non altrettanto vale per l'ereditarietą.
</quote>
a 
<quote>
In Java puoi estendere un'unica classe ma puoi implementare quante
interfacce vuoi, ottenendo cosi' lo stesso obiettivo
dell'ereditarietą multipla ad esempio del C++.
</quote> 
il tuo "io non credo" sia opinabile, dato che si basa - a quanto dici - su 
un aspetto sostanzialmente irrilevante del processo di "ottenere lo stesso 
obiettivo dell'ereditarieta' multipla ad esempio del C++" (che non 
signfica, ovviamente, averne la stessa implementazione).
