-----------------------------------------------------------------------------------------------------------------------
// Author: Tanino Rulez
// E-mail: tanino_rul3z[at]hotmail.com
// Website: www.taninorulez.wordpress.com
// Forum: www.taninorulez.altervista.org
// Argomento: Introduzione alla programmazione OOP e aspetti basilari di Java.
// Categoria: Programmazione OOP - Java
// Data pubblicazione: 06/08/08
// Versione scaricabile [.txt] : http://www.divshare.com/download/5112131-98c
// Versione online:
-----------------------------------------------------------------------------------------------------------------------
*** PREFAZIONE E NOTE DELL'AUTORE ***
Il seguente documento può essere rielaborato,modificato,stampato e pubblicato a patto che sia citato l'autore e i relativi crediti.
Nella seguente guida parlerò delle caratteristiche fondamentali della programmazione OOP e come linguaggio di riferimento userò Java,illustrandone alcune caratteristiche.
*** OOP & JAVA : CARATTERISTICHE ***
La programmazione ad oggetti ( identificata anche con la sigla OOP,Object-Oriented Programming ) è oggigiorno uno degli aspetti e approcci dominanti della programmazione a discapito della "vecchia" e cara programmazione "strutturata",basata cioè su procedure e funzioni,che ebbe un notevole successo soprattutto nei primi anni '70.
Nella programmazione OOP,il concetto fondamentale è l'oggetto. Ogni programma è composto da oggetti,ognuno dei quali ha determinate caratteristiche e funzioni specifiche che gli oggetti possono svolgere. Facciamo un esempio pratico ed aziendale per rendere meglio l'idea:
Per le aziende,o meglio i loro programmatori,costruire un oggetto oppure acquistarlo da altri dipende solo dal budget e dal tempo disponibile. Importa poco distinguere il modo in cui una certa funzione è stata implementata,almeno fino a quando soddisfano le specifiche richieste.
Nella OOP è importante stabilire cosa un oggetto deve esporre.
Ad una azienda produttrice di computer ad esempio non importa sapere quali sono i componenti interni di un alimentatore e allo stesso modo ad un programmatore Java non interessa sapere come è stato implementato un oggetto,fintanto che l'oggetto continua a soddisfare ciò che si vuole.
La programmazione strutturata invece è un insieme di procedure e/o algoritmi in grado di risolvere un problema. Inizialmente si stabiliscono le procedure da utilizzare o l'algoritmo da usare,successivamente si passa alla memorizzazione dei dati. Ecco uno dei motivi del titolo del famoso libro di N. Wirth sul linguaggio Pascal: " Algorithms + Data Structures = Programs " ( penso non ci sia bisogno di traduzione Very Happy ).
La OOP rovescia questa soluzione di approccio ai problemi catalogando al primo posto i dati,seguiti dagli algoritmi che implementano i dati.
Se un oggetto fa riferimento ad un'attivitàche non rientra tra le sue possibilità,bisogna accedere ad un altro oggetto che includa l'attivitàdesiderata. Questo procedimento in Java prende il nome di " chiamata di metodo ".
Bisogna ricordare che un oggetto non deve MAI elaborare direttamente i dati interni di un altro oggetto ne tantomeno esporre i dati in modo da renderli accessibili ad altri oggetti.
Il concetto di incapsulamento dei dati di un oggett ci permette infatti di ottimizzare la riusabilità,ridurre la dipendenza dai dati e minimizzare il tempo di debug.
Proprio come per le procedure,è buona norma di programmazione evitare che un singolo oggetto svolga troppe attività.
*** CLASSI & OGGETTI ***
Altro concetto fondamentale della programmazione OOP è quello di " classe ". Una classe è un modello rispetto al quale vengono definiti gli oggetti utilizzati nei programmi. Possiamo pensare alla classe come una formina per i biscotti e agli oggetti come i biscotti stessi ( mamma mia che metafora Very Happy ).
Quando viene creato un oggetto di una classe,noi creiamo una instanza della classe.
L'incapsulamento ( che giàho accennato prima ) non è altro che un " occulamento dei dati " ed è il concetto fondamentale per lavorare con gli oggetti. Formalmente quindi,l'incapsulamento è la combinazione dei dati e del loro comportamento,racchiusi in un pacchetto,che occulta all'utente esterno l'implementazione effettiva.
I dati nell'oggetto sono chiamati campi istanza dell'oggetto e le procedure che elaborano i dati sono i metodi dell'oggetto. L'insieme dei valori definisce invece lo stato dell'oggetto.
Regola fondamentale è che i metodi non devono mai accedere direttamente ai campi istanza di una classe diversa da quella in cui sono definiti. I programmi interagiscono con gli oggetti solo mediante i metodi dell'oggetto.
Un altro concetto fondamentale dell'OOP e di Java è la possibilitàdi scrivere delle classi come estensioni di altre classi. Quando una classe esistente viene estesa,la nuova classe ha tutte le proprietàe i metodi della classe che estende ed è possibile aggiungere nuovi metodi e campi dati da applicare solo alla nuova classe. Questo concetto è chiamato ereditarietàma verràspiegato meglio in seguito.
Per quanto riguarda gli oggetti invece,le tre caratteristiche fondamentali sono:
1 - comporamento : cosa si può fare con l'oggetto e i metodi che si possono applicare
2 - stato: la reazione dell'oggetto quando si applicano i metodi
3 - identità: le differenze tra oggetti che possono avere lo stesso comportamento o stato.
Quando si progetta un sistema orientato agli oggetti,un utente alle prime armi potrebbe chiedersi da dove iniziare. La risposta è che bisogna prima trovare le classi e poi aggiungere i relativi metodi. Una regola pratica è quella di analizzare il problema ed associare i metodi ai verbi mentre le classi sono identificate dai nomi utilizzati.
*** RELAZIONI TRA CLASSI ***
Le relazioni più comuni tra le classi sono tre:
1 - dipendenza ("use-a")
2 - aggregazione ("has-a")
3 - ereditarietà("is-a")
La dipendenza è la relazione più ovvia ed anche più generica,ad esempio abbiamo una classe A che utilizza (use-a) una classe B. Una classe dipende da un'altra classe se i suoi metodi elaborano gli oggetti dell'altra classe.
L'aggregazione è la più facile da comprendere; ciò significa che oggetti della classe A contengono oggetti della classe B.
L'ereditarietàinvece esprime una relazione tra una classe generica e una più specializzata; per esempio una classe A che eredita una classe B.
*** CONCLUSIONE ***
Penso che come introduzione all'OOP possa andare più che bene,naturalmente l'argomento va approfondito essendo vasto ma non molto complesso.
Spero di esservi stato utile,alla prossima Wink
T4n|n0 Ru|3z
// Author: Tanino Rulez
// E-mail: tanino_rul3z[at]hotmail.com
// Website: www.taninorulez.wordpress.com
// Forum: www.taninorulez.altervista.org
// Argomento: Introduzione alla programmazione OOP e aspetti basilari di Java.
// Categoria: Programmazione OOP - Java
// Data pubblicazione: 06/08/08
// Versione scaricabile [.txt] : http://www.divshare.com/download/5112131-98c
// Versione online:
-----------------------------------------------------------------------------------------------------------------------
*** PREFAZIONE E NOTE DELL'AUTORE ***
Il seguente documento può essere rielaborato,modificato,stampato e pubblicato a patto che sia citato l'autore e i relativi crediti.
Nella seguente guida parlerò delle caratteristiche fondamentali della programmazione OOP e come linguaggio di riferimento userò Java,illustrandone alcune caratteristiche.
*** OOP & JAVA : CARATTERISTICHE ***
La programmazione ad oggetti ( identificata anche con la sigla OOP,Object-Oriented Programming ) è oggigiorno uno degli aspetti e approcci dominanti della programmazione a discapito della "vecchia" e cara programmazione "strutturata",basata cioè su procedure e funzioni,che ebbe un notevole successo soprattutto nei primi anni '70.
Nella programmazione OOP,il concetto fondamentale è l'oggetto. Ogni programma è composto da oggetti,ognuno dei quali ha determinate caratteristiche e funzioni specifiche che gli oggetti possono svolgere. Facciamo un esempio pratico ed aziendale per rendere meglio l'idea:
Per le aziende,o meglio i loro programmatori,costruire un oggetto oppure acquistarlo da altri dipende solo dal budget e dal tempo disponibile. Importa poco distinguere il modo in cui una certa funzione è stata implementata,almeno fino a quando soddisfano le specifiche richieste.
Nella OOP è importante stabilire cosa un oggetto deve esporre.
Ad una azienda produttrice di computer ad esempio non importa sapere quali sono i componenti interni di un alimentatore e allo stesso modo ad un programmatore Java non interessa sapere come è stato implementato un oggetto,fintanto che l'oggetto continua a soddisfare ciò che si vuole.
La programmazione strutturata invece è un insieme di procedure e/o algoritmi in grado di risolvere un problema. Inizialmente si stabiliscono le procedure da utilizzare o l'algoritmo da usare,successivamente si passa alla memorizzazione dei dati. Ecco uno dei motivi del titolo del famoso libro di N. Wirth sul linguaggio Pascal: " Algorithms + Data Structures = Programs " ( penso non ci sia bisogno di traduzione Very Happy ).
La OOP rovescia questa soluzione di approccio ai problemi catalogando al primo posto i dati,seguiti dagli algoritmi che implementano i dati.
Se un oggetto fa riferimento ad un'attivitàche non rientra tra le sue possibilità,bisogna accedere ad un altro oggetto che includa l'attivitàdesiderata. Questo procedimento in Java prende il nome di " chiamata di metodo ".
Bisogna ricordare che un oggetto non deve MAI elaborare direttamente i dati interni di un altro oggetto ne tantomeno esporre i dati in modo da renderli accessibili ad altri oggetti.
Il concetto di incapsulamento dei dati di un oggett ci permette infatti di ottimizzare la riusabilità,ridurre la dipendenza dai dati e minimizzare il tempo di debug.
Proprio come per le procedure,è buona norma di programmazione evitare che un singolo oggetto svolga troppe attività.
*** CLASSI & OGGETTI ***
Altro concetto fondamentale della programmazione OOP è quello di " classe ". Una classe è un modello rispetto al quale vengono definiti gli oggetti utilizzati nei programmi. Possiamo pensare alla classe come una formina per i biscotti e agli oggetti come i biscotti stessi ( mamma mia che metafora Very Happy ).
Quando viene creato un oggetto di una classe,noi creiamo una instanza della classe.
L'incapsulamento ( che giàho accennato prima ) non è altro che un " occulamento dei dati " ed è il concetto fondamentale per lavorare con gli oggetti. Formalmente quindi,l'incapsulamento è la combinazione dei dati e del loro comportamento,racchiusi in un pacchetto,che occulta all'utente esterno l'implementazione effettiva.
I dati nell'oggetto sono chiamati campi istanza dell'oggetto e le procedure che elaborano i dati sono i metodi dell'oggetto. L'insieme dei valori definisce invece lo stato dell'oggetto.
Regola fondamentale è che i metodi non devono mai accedere direttamente ai campi istanza di una classe diversa da quella in cui sono definiti. I programmi interagiscono con gli oggetti solo mediante i metodi dell'oggetto.
Un altro concetto fondamentale dell'OOP e di Java è la possibilitàdi scrivere delle classi come estensioni di altre classi. Quando una classe esistente viene estesa,la nuova classe ha tutte le proprietàe i metodi della classe che estende ed è possibile aggiungere nuovi metodi e campi dati da applicare solo alla nuova classe. Questo concetto è chiamato ereditarietàma verràspiegato meglio in seguito.
Per quanto riguarda gli oggetti invece,le tre caratteristiche fondamentali sono:
1 - comporamento : cosa si può fare con l'oggetto e i metodi che si possono applicare
2 - stato: la reazione dell'oggetto quando si applicano i metodi
3 - identità: le differenze tra oggetti che possono avere lo stesso comportamento o stato.
Quando si progetta un sistema orientato agli oggetti,un utente alle prime armi potrebbe chiedersi da dove iniziare. La risposta è che bisogna prima trovare le classi e poi aggiungere i relativi metodi. Una regola pratica è quella di analizzare il problema ed associare i metodi ai verbi mentre le classi sono identificate dai nomi utilizzati.
*** RELAZIONI TRA CLASSI ***
Le relazioni più comuni tra le classi sono tre:
1 - dipendenza ("use-a")
2 - aggregazione ("has-a")
3 - ereditarietà("is-a")
La dipendenza è la relazione più ovvia ed anche più generica,ad esempio abbiamo una classe A che utilizza (use-a) una classe B. Una classe dipende da un'altra classe se i suoi metodi elaborano gli oggetti dell'altra classe.
L'aggregazione è la più facile da comprendere; ciò significa che oggetti della classe A contengono oggetti della classe B.
L'ereditarietàinvece esprime una relazione tra una classe generica e una più specializzata; per esempio una classe A che eredita una classe B.
*** CONCLUSIONE ***
Penso che come introduzione all'OOP possa andare più che bene,naturalmente l'argomento va approfondito essendo vasto ma non molto complesso.
Spero di esservi stato utile,alla prossima Wink
T4n|n0 Ru|3z