I linguaggi .NET sono orientati agli oggetti
e così lo è anche VB.NET. Questo approccio alla programmazione ha avuto
molto successo negli ultimi anni e si basa fondamentalmente sui
concetti di astrazione, oggetto e interazione fra oggetti. A loro
volta, questi ultimi costituiscono un potente strumento per la
modellizzazione e un nuovo modo di avvicinarsi alla risoluzione dei
problemi. La particolare mentalità che questa linea di sviluppo adotta
è favorevole alla rappresentazione dei dati in modo gerarchico, e per
questo motivo il suo paradigma di programmazione - ossia l'insieme degli strumenti concettuali messi a disposizione
dal linguaggio e il modo in cui il programmatore concepisce l'applicativo - è definito da tre concetti cardine: l'ereditarietà,
il polimorfismo e l'incapsulamento.
Molto presto arriveremo ad osservare nel particolare le caratteristiche
di ognuno di essi, ma prima vediamo di iniziare con l'introdurre
l'entità fondamentale che si pone alla base di tutti questi strumenti:
la classe.
Come dicevo, una caratteristica particolare di questa categoria di
linguaggi è che essi sono basati su un unico importantissimo concetto
fondamentale: gli oggetti, i quali vengono rappresentati da classi. Una classe non è altro che la rappresentazione - ovviamente astratta - di qualcosa di
concreto,
mentre l'oggetto sarà una concretizzazione di questa rappresentazione
(per una discussione più approfondita sulla differenza tra classe e
oggetto, vedere capitolo A7). Ad esempio, in un programma che deve
gestire una videoteca, ogni videocassetta o DVD è rappresentato da una
classe; in un programma per la fatturazione dei clienti, ogni cliente e
ogni fattura vengono rappresentati da una classe. Insomma, ogni cosa,
ogni entità, ogni relazione - perfino ogni errore - trova la sua
rappresentazione in una classe.
Detto questo, viene spontaneo pensare che, se ogni cosa è astratta da
una classe, questa classe dovrà anche contenere dei dati su quella
cosa. Ad esempio, la classe Utente dovrà contenere informazioni sul
nome dell'utente, sulla sua password, sulla sua data di nascita e su
molto altro su cui si può sorvolare. Si dice che tutte queste
informazioni sono esposte dalla classe:
ognuna di esse, inoltre, è rappresentata quello che viene chiamato membro. I membri di una classe sono tutti quei dati e
quelle funzionalità che essa espone.
Per essere usabile, però, una classe deve venire prima dichiarata,
mediante un preciso codice. L'atto di dichiarare una qualsiasi entità
le permette di iniziare ad "esistere": il programmatore deve infatti
servirsi di qualcosa che è già stato definito da qualche parte, e senza
di quello non può costruire niente. Con la parola "entità" mi riferisco
a qualsiasi cosa si possa usare in programmazione: dato che le vostre
conoscenze sono limitate, non posso che usare dei termini generici e
piuttosto vaghi, ma in breve il mio lessico si farà più preciso. Nella
pratica, una classe si dichiara così:
Class [NomeClasse] '... End Class
dove [NomeClasse] è un qualsiasi nome che potete decidere arbitrariamente, a seconda di cosa debba essere rappresentato. Tutto il codice compreso tra le parole sopra citate è interno alla classe e si chiama corpo; tutte le entità esistenti nel corpo sono dei membri. Ad esempio, se si volesse idealizzare a livello di codice un triangolo, si scriverebbe questo:
Class Triangolo '... End Class
Nel corpo di
Triangolo si potranno poi definire tutte le informazioni che gli si
possono attribuire, come la lunghezza dei lati, la tipologia,
l'ampiezza degli angoli, eccetera...
Nonostante il nome, i moduli non sono niente altro che dei tipi
speciali di classi. La differenza sostanziale tra i due termini verrà
chiarita molto più avanti nella guida, poiché le vostre attuali
competenze non sono sufficienti a un completo apprendimento. Tuttavia,
i moduli saranno la tipologia di classe più usata in tutta la sezione A.
Possiamo definire classi e moduli come unità funzionali: essi rappresentano qualcosa, possono essere usate, manipolate, istanziate, dichiarate, eccetera... Sono quindi strumenti attivi di programmazione, che servono a realizzare concretamente azioni e a produrre risultati. I namespace, invece, appartengono a tutt'altro genere di categoria: essi sono solo dei raggruppamenti "passivi" di classi o di moduli. Possiamo pensare a un namespace come ad una cartella, entro la quale possono stare files, ma anche altre cartelle, ognuna delle quali raggruppa un particolare tipo di informazione. Ad esempio, volendo scrivere un programma che aiuti nel calcolo geometrico di alcune figure, si potrebbe usare un codice strutturate come segue:
Namespace Triangoli Class Scaleno '... End Class Class Isoscele '... End Class Class Equilatero '... End Class End Namespace Namespace Quadrilateri Namespace Parallelogrammi Class Parallelogramma '... End Class Namespace Rombi Class Rombo '... End Class Class Quadrato '... End Class End Namespace End Namespace End Namespace
Come si vede, tutte le classi che rappresentano tipologie di triangoli
(Scaleno, Isoscele, Equilatero) sono all'interno del namespace
Triangoli; allo stesso modo esiste anche il namespace Quadrilateri, che
contiene al suo interno un altro namespace Parallelogrammi, poiché
tutti i parallelogrammi sono quadrilateri, per definizione. In
quest'ultimo esiste la classe Parallelogramma che rappresenta una
generica figura di questo tipo, ma esiste ancora un altro namespace
Rombi: come noto, infatti, tutti i rombi sono anche parallelogrammi.
Dall'esempio si osserva che i namespace categorizzano le unità
funzionali, dividendole in insiemi di pertinenza. Quando un namespace
si trova all'interno di un altro namespace, lo si definisce nidificato:
in questo caso, Paralleloogrammi e Rombi sono namespace nidificati.
Altra cosa: al contrario della classi, gli spazi di nomi
(italianizzazione dell'inglese name-space) non possiedono un "corpo",
poiché questo termine si può usare solo quando si parla di qualcosa di
attivo; per lo stesso motivo, non si può neanche parlare di membri di
un namespace.