In relazione al paradigma della programmazione orientata agli oggetti, in un precedente articolo abbiamo parlato della ereditarietà dicendo:
Con la tecnica della ereditarietà costruiamo una nuova classe derivata a partire da una classe base da cui verranno ereditate le proprietà e i metodi. La particolarità di questa tecnica è che, se ne dovessimo avere la necessità, potremmo modificare uno o più dei suoi metodi a nostro piacimento specializzando così gli oggetti che creeremo del tipo della nostra classe derivata.
La tecnica di riscrittura dei metodi ereditati prende il nome di override. I metodi, così riscritti, vengono definiti metodi polimorfi.
Il metodo che si intende riscrivere nella classe derivata, deve avere lo stesso nome e la stessa firma del metodo presente nella classe base.
Facciamo ora un esempio per capire un po’ meglio come stanno le cose.
Esempio di un metodo polimorfo
Supponiamo di avere la classe base “pianta” e di creare, a partire da questa, due classi derivate che ne ereditino sia le proprietà che i metodi. Chiameremo queste due classi derivate “albero” e “rampicante”.
Supponiamo ora che nella classe base sia stato dicharato il metodo “sviluppo_radice” che fungerà, come vedremo più avanti, da interfaccia.
A questo punto riscriveremo ad hoc nelle classi derivate il metodo “sviluppo_radice” in modo tale che la chiamata di questo metodo fatta su un oggetto del tipo “albero” si comporti diversamente dalla stessa chiamata fatta su un oggetto del tipo “rampicante”.
Il metodo “sviluppo_radice” sarà quindi un metodo polimorfo, e la sua riscrittura operata nelle due classi derivate sarà stata una operazione di override.
Vantaggi del polimorfismo
Come abbiamo avuto modo di vedere, il polimorfismo ci permette di avere una interfaccia unica verso tutti i possibili altri programmi (definiti programmi client) che useranno le nostre classi derivate.
In questo modo avremo due vantaggi:
- Sarà sempre possibile estendere le modalità di risposta ad una stessa chiamata al metodo interfaccia, includendo tutte le possibili dichiarazioni dei metodi polimorfi in una nostra specifica classe contenitore a cui dovranno fare riferimento i programmi client.
- Sarà sempre possibile migliorare le modalità di risposta modificando il solo codice contenuto nei metodi polimorfi senza che i programmi client debbano essere modificati.
Esempio di polimorfismo in FreeBASIC
Vediamo ora un piccolo esempio della applicazione del polimorfismo in FreeBASIC.
''Classe base "pianta"
type pianta
public:
dim as string nome
declare constructor(byref _nome as string)
declare function sviluppo_radice() as string
protected:
''impedisce l'uso del costruttore di default
declare constructor()
end type
constructor pianta(byref _nome as string)
this.nome = _nome
end constructor
function pianta.sviluppo_radice() as string
return "sono una generica radice di una pianta"
end function
''Classe derivata "albero"
type albero extends pianta
public:
declare constructor(byref _nome as string)
declare function sviluppo_radice() as string
end type
constructor albero(byref _nome as string)
base(_nome)
end constructor
function albero.sviluppo_radice() as string
return "sono la radice di un albero di"
end function
''Classe derivata "rampicante"
type rampicante extends pianta
public:
declare constructor(byref _nome as string)
declare function sviluppo_radice() as string
end type
constructor rampicante(byref _nome as string)
base(_nome)
end constructor
function rampicante.sviluppo_radice() as string
return "sono la radice del rampicante"
end function
''Creazione di un oggetto di tipo "albero"
dim as albero mio_albero = albero("pioppo")
''Creazione di un oggetto di tipo "rampicante"
dim as rampicante mio_rampicante = rampicante("edera")
''Invoca il metodo polimorfo
print mio_albero.sviluppo_radice() & " " & mio_albero.nome
print mio_rampicante.sviluppo_radice() & " " & mio_rampicante.nome
sleep
Bene. Con questo articolo finiamo la sintetica panoramica sulla programmazione ad oggetti in FreeBASIC.
Ora non resta che sperimentare. 😉
ciuco informatico 