Newsgroup: it.comp.java
Titolo: Interfacce e classi Astratte

 
Una domanda trita e ritrita:
la differenza tra classe astratta ed interfacce....ma rispondetemi, per
favore, moltoooooo
semplicemente
Grazie
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 ha scritto nel messaggio 
news:80Z104Z248Z176Y...@usenet.libero.it...


 semplicemente
La classe astratta intanto č una classe, quindi puň essere estesa e non 
implementata (ricordo che puoi estendere una sola classe ma implementare 
piů interfacce). Essa č semplicemente una classe di cui non si desidera 
venga usata per creare istanze concrete, ma solo per creare subclassi. 
Puň contenere implementazioni, field e metodi statici e non, protetti o 
privati, metodi astratti o final, e quant'altro puň essere usato in una 
classe.
L'interfaccia invece č una dichiarazione di quali sono i metodi pubblici 
che una classe implementa (contratto). Non contiene implementazioni, 
tutti i metodi sono implicitamente astratti e i field sono 
implicitamente final.

 favore, moltoooooo semplicemente
Oltre a quello che ti è stato detto, tieni presente che ci può anche 
essere il caso in cui una classe astratta implementa un'interfaccia.
È questo caso abbastanza frequente anche nella libreria standard di 
Java. Sono definite delle interfacce, ma per evitare ai programmatori di 
dovere reimplementare *tutti* i metodi, vengono fornite anche classi 
astratte che implementano l'interfaccia scelta. I metodi sono spesso 
definiti che fanno la cosa di default oppure non fanno nulla e il 
programmatore può poi estendere questa classe ridefinendo i metodi che 
gli interessano.
D'altra parte questo approccio ha lo svantaggio che in mancaza di 
ereditarietà multipla sulle classi ereditare da una classe è un rapporto 
*abbastanza* forte (o forse si dovrebbe dire che il rapporto di 
ereditarietà è un rapporto *abbastanza* forte e che quindi 
l'ereditarietà multipla è da evitare[0]). Spesso è più comodo limitarsi 
a dire che un oggetto implementa una data interfaccia.
Questo ci permette di usarlo in tutti i posti dove sarebbe richiesta 
(appunto) quell'interfaccia, senza necessariamente vincolarci con 
l'ereditarietà.
Avere lunghe catene di ereditarietà è generalmente pesante da gestire. 
Complessivamente è "meglio"[1] che oggetti in se slegati semplicemente 
si limitino a garantire di avere un certo numero di metodi uguali.
------
[0] dopo di che anche in linguaggi con ereditarietà multipla di classe, 
spesso si consiglia che gli oggetti non dovrebbero ereditare da più di 
un padre con variabili membro, e fondamentalmente si consiglia 
ereditarietà singola da un "tipo vero" e per il resto usare classi che 
si comportano un po' come delle interfacce, o eventualmente come delle 
interfacce "estese".
[1] o per lo meno, senza entrare in discussione infinite su ereditarietà 
multipla vs. ereditarietà singola questa è la strada di Java e di altri 
linguaggi OO.
-enrico
-- 
Never argue with a logician.


ma quando si usa una classe astratta oppure un'interfaccia???


 ma quando si usa una classe astratta oppure un'interfaccia???
Rileggi qual'è lo scopo dell'interfaccia e qual'è lo scopo delle classe 
astratta. Evidentemente si usano ciascuna nel suo scopo.
Se hai bisogno di esempi, ne trovi una infinità fra le classi di 
libreria di java (API).
Se hai bisogno di sapere il perchè si fa così, devi consultare un buon 
testo di java. Perchè per risponderti dovrei consultarlo io.

uh bella domanda... alle volte non è mica chiaro..
puoi fare un interfaccia per dire :
"tutte le classi che implentano l'interfaccia devono assicurami che facciano 
queste cose: il come non mi interessa". Nel senso che se un interfaccia ha 
un metodo XXX getXXX(), quell'XXX se lo puo' andare a leggere su DB via RMI, 
da file o che so io...
una classe astratta è un po' piu' limitata e puoi usarla per dire: "queste 
cose la faccio io cosi' e cosà, ma questo particolare metodo varia per ogni 
classe che mi estende e deve essere ridefinito dalle sottoclassi"
-- 


 favore, moltoooooo
Al di là delle questioni tecniche tipo l'inesistenza di ereditarità multipla
tra classi che invece è permessa alle interfacce, vedila così:
L'interfaccia è un "contratto" tra chi la implementa e chi la usa. Chi la
implementa garantisce di avere un certo comportamento consistente con la
specifica dell'interfaccia.
Una classe astratta è cmq un'implementazione, non una specifica, ma magari
non un'implementazione completa che quindi si lascia completare dalle sua
sottoclassi. Ci sono una serie di ottime ragioni per cui una serie di
classi possano avere una superclasse in comune.
Ciao
-- 
chi sono e soprattutto chi non sono:
http://www.softeaware.it

 writes:
M> ma quando si usa una classe astratta oppure un'interfaccia???
Java è un linguaggio che non prevede l'ereditarietà multipla.
Ora,  utilizzare  una  classe  astratta  pura  ,  ovver  senza  metodi
implementati  e  che  chiamiamo  PuraUno, per  definire  il  contratto
Contratto implica che ogni  altra classe che deve rispettare Contratto
deve discendere da PuraUno. Ma ci sono casi in cui questo non va bene.
Provo  a fare  un esempio,  supponiamo  di avere  le classi  Quadrato,
ImmagineVettoriale e  ImmagineRaster, che  sono usate da  un programma
che ad un certo punto chiama il metodo disegnati(AreaAVideo dove).
Ora  se  partiamo tutti  da  una  classe  astratta ImmagineAVideo,  ci
troveremo  a dover  scrivere completamente  i metodi  per  acquisire i
dati, in particolare tutto quello  che sta dietro al caricamento ed al
ridimensionamento  di  ImmagineRaster  (quadrato  ce la  caveremo  col
codice di ImmagineVettoriale.
Ma a questo punto arriva uno che ci offre due splendide classi pronte,
org.gnu.VectorGraphic e org.bsd.RasterGraphic, tutte e due derivate da
Object.
Da org.gnu.VectorGraphic potrei  tranquillamente ottenere sia Quadrato
che ImmagineVettoriale. da org.bsd.RasterGraphic ImmagineRaster.
Come me lo risolvo col  programma che deve chiamare disegna() sui vari
oggetti ? 
Puoi fare  del codice che verifica  il tipo a runtime  e chiama condi-
zionalmente il  metodo disegna()  sul tipo giusto.   Ottima soluzione.
Solo che quando aggiungi un nuovo tipo di immagine devi cambiare anche
il programma chiamante.
Oppure usi le interfaccie.   Definisci il tipo interfaccia Disegnabile
che prevede  esiste il metodo disegna(AreaAVideo dove),  poi dirai che
ImmagineVettoriale  implementa  Disegnabile,  probabilmente la  stessa
cosa  la farai  per Quadrato  (salvo che  non sia  una  sottoclasse di
ImmagineVettoriale) e per ImmagineRaster.
A questo punto  il programma maneggerà oggetti di  tipo Disegnabile ai
quali chiederà indistintamente e senza problemi disegna(dove).
Spero sia stato abbastanza chiaro. Oppure vatti a vedere Comparable ed
il suo uso.
-- 
 /\            ___
/___/\__|_|\_|__|___Gian Uberto Lauri_____________________
  //--\ | | \|  |   Integralista GNUslamico  
\/		    e allevatore di bug da competizione