Newsgroup: it.comp.programmare
Titolo: oop interfacce ...a che servono?

ciao
sto studiando oop e sono arrivato alle interfacce.
Ho capito sintatticamente come crearle ed utilizzarle tramite le 
classi....ma nel pratico a che servono?
Dal mio punto di vista (newbie che vuole programmare per divertimento)
e quindi non inserito in un contesto professionale, se proprio devo 
creare una classe la creo e la riempio di metodi....quindi ecco che mi 
perdo ancora una volta l'utilità e il senso di quando e perche' usare 
un'interfaccia....
Sono in crisi mistica
aiutatemi
grazie

 un'interfaccia....
Se devi creare _una_ sola classe, scrivere un'interfaccia non ti serve a 
granché (magari implementarne una fornita dal particolare framework con 
cui ti trovi a lavorare sì, ma quello è un altro discorso).
Difficilmente, inoltre, ti servirà scrivere un'interfaccia, se non ti 
trovi nella condizione di scrivere un programma abbastanza complesso.
Comunque sia, puoi vedere un'interfaccia come una sorta di "contratto" 
che una classe firma (tecnicamente il verbo giusto è 'implementa').
Una classe che desidera implementare una particolare interfaccia deve 
obbligatoriamente fornire una sua implementazione dei metodi previsti 
dall'interfaccia (a meno che la classe non sia dichiarata come astratta).
Se questo non succede otterrai un errore di compilazione.
Il fatto che due classi implementino la stessa interfaccia garantisce di 
poter effettuare determinate operazioni sulle loro istanze.
Esempio: un determinato metodo (chiamiamolo X) di una certa classe 
potrebbe richiedere che gli venga passato un riferimento ad un oggetto 
di una classe che implementi l'interfaccia IDrawable, che prevede, tra 
l'altro, un metodo Draw, che consente di disegnare un oggetto sullo schermo.
Supponiamo che tu abbia scritto 3 classi, Libro, Bicicletta e Sedia, 
ognuna delle quali implementa l'interfaccia IDrawable.
Ne consegue che un ipotetico oggetto di ciascuna di queste tre classi ha 
le carte in regola per essere passato al metodo X di cui si parlava 
prima: molto probabilmente tale metodo sfrutterà il metodo Draw() 
implementato da ciascuna delle tue classi.
In questo caso, il vantaggio offerto dall'interfaccia IDrawable è quello 
di rendere possibile la rappresentazione di oggetti che possono anche 
non aver niente a che fare l'uno con l'altro, laddove se il metodo X 
avesse richiesto esplicitamente una classe derivata di una classe C, la 
tua scelta sarebbe stata decisamente più limitata.
In altre parole, scrivere una certa classe che implementi una 
determinata interfaccia equivale a dire "ok, questa classe è capace di 
essere disegnata, chiamate pure il metodo Draw".
Altro aspetto degno di nota è che, se implementi un'interfaccia, le 
firme dei metodi che andrai ad implementare devono corrispondere 
esattamente a quelle dei metodi previsti dall'interfaccia, pena la 
segnalazione di un errore di compilazione.
Non so se sono stato sufficientemente chiaro.
S.

Stevie ha scritto:

ohhhh grazie a DIO!
hehehe
sei stato molto gentile e chiaro!
grazie!

trovi nella condizione di scrivere un programma abbastanza complesso.
Be', questo non č vero. Non serve necessariamente un programma
"abbastanza complesso". Allontandosi almeno un po' da cose
banalissime, non sono rari i casi in cui serva scrivere interfacce.

 un'interfaccia....
Servono a disaccoppiare i componenti.
Se tu hai una classe Client che utilizza una classe DatabaseMySQL il 
giorno che vuoi riutilizzare il codice di Client per DatabasePostgres 
dovrai rimodificare il codice sorgente di Client.
Se invece fai in modo che Client si riferisca all'interfaccia Database e 
poi crei due classi DatabaseMySQL, e DatabasePostgres che implementano 
Database allora puoi cambiare tipo di database senza dover modificare 
Client.
Tieni conto che in alcuni casi al momento in cui scrivi il codice di 
Client potresti non sapere quale database andrai effettivamente ad 
utilizzare.
In questo modo anche quando uscirà il nuovo database Pippo2009 la classe 
Client non bisognerà modificarla, sarà sufficiente solo creare la classe 
DatabasePippo2009 e passare il riferimento a Client.
In più l'uso delle interfaccie è molto comodo nello unit testing.
Supponi di voler testare il comportamento di Client senza pero' doverti 
installare, creare un account di test, e connetterti ad un database vero 
e proprio. In questo caso puoi creare una classe fantoccio DatabaseMock 
che non fa niente se non verificare che le chiamate di Client sono fatte 
correttamente.
Questa tecnica si chiama uso dei Mock Objects ed è supportata da 
librerie che ti creano gli oggetti Mock automaticamente.
-- 
Andrea Francia
http://www.andreafrancia.it/