| Vediamo come definire le classi in C# |
Definizione di una classe
Una classe si definisce usando la parola "class" seguita dal nome della classe. Il nome della classe deve essere univoco all'interno del suo namespace. Le vriabili che vengono al suo interno, se non specificato sono considerate come private.
Esempio:
public class Alunno{
public string Nome
}
public class Prova{
public static void Main(){
Alunno unAlunno = new Alunno();
unAlunno.Nome = "Marco";
}
}
Nell'esempio abbimo definito una classe Alunno, che contiene una variabile (un campo) pubblico e quindi accessibile dall'esterno. Nella seconda parte abbimo definito la classe Prova con il metodo Main (il compilatore come metodo di ingresso cerca sempre il metodo Main) dove inizia l'esecuzione del nostro programma. Quindi per prima cosa viene creata un istanza (unAlunno) della classe Alunno con l'assegnazione "new" poi viene assegnato al suo campo pubblico (Nome) il valore "Marco".
Metodi
Arricchiamo la nostra classe Alunno di un metodo che ci stampi a video il nome dell'alunno che contiene:
public class Alunno{
public string Nome
public void Visualizza(){
System.Console.WriteLine(Nome);
}
}
In questo modo abbiamo aggiunto il metodo Visualizza che non rstituisce nessun parametro (void) e che se richiamato stampa a video il contenuto della variabile Nome, per utilizzarlo procediamo come segue:
public class Prova{
public static void Main(){
Alunno uno = new Alunno();
uno.Nome = "Marco";
Alunno due = new Alunno();
due.Nome = "Monica";
uno.Visualizza();
due.Visualizza();
}
}
Il risultato a video sarà il seguente:
Marco
Monica
Membri statici e di istanza
I membri che abbimo visto nei nostri esempi sono detti "di istanza" in quanto fanno riferimento all'istanza della classe che abbiamo creato con l'assegnazione. Quindi, se creiamo 10 istanze della classe Alunno avremo la possibilità di fare riferimento a 10 nomi diversi. Al contrario esistono dei membri detti "statici" ovvero comuni a tutte le istanze della classe, in questo caso se Nome fosse stato dichiarato come "static" avremo a disposizione un solo nome per tutte e 10 le nostre istanze, vediamo l'esempio:
public class Alunno{
static public string Nome
public void Visualizza(){
System.Console.WriteLine(Nome);
}
}
In questo caso è cambiata la dichiarazione della variabile Nome.
public class Prova{
public static void Main(){
Alunno uno = new Alunno();
uno.Nome = "Marco";
Alunno due = new Alunno();
due.Nome = "Monica";
uno.Visualizza();
due.Visualizza();
}
}
Lanciando l'esempio di prima il risultato a video cambia:
Monica
Monica
Questo perchè di fatto abbimo fatto due volte l'assegnazione alla stessa variabile statica (comune a tutte le istanze).
In caso di omonimia di variabili statiche o di istanza, o più in generale è buona abitudine identificare i membri di istanza con il prefisso this.
public class Alunno{
public string Nome
public void Visualizza(){
System.Console.WriteLine(this.Nome);
}
public void SetNome(string s){
this.Nome = s;
}
}
In questo esempio abiamo aggiunto un metodo pubblico che accetta come parametro una stringa, ed assegna alla variabile di istanza Nome il valore passato.
Costruttori e distruttori
Come in altri linguaggi, anche in C# abbiamo i costruttori e i distruttori, essi servono per svolgere delle operazioni automatiche alla creazione e alla distruzione di una classe.
COSTRUTTORE
Il costruttore è un metodo definito con lo stesso nome della classe e che non restituisce valori. Ogni classe può avere uno o più costruttori che si differenziano uno dall'altro per via dei parametri che accetta (overloading), es:
public class Alunno{
Alunno(){
this.Nome = "sconosciuto";
}
Alunno(string Nome){
this.Nome = Nome;
}
public string Nome
public void Visualizza(){
System.Console.WriteLine(this.Nome);
}
public void SetNome(string s){
this.Nome = s;
}
}
In questo esempio abbiamo a disposizione due costruttori, il primo, scattta se non viene passato nessun parametro ed assegna al nome il valore "sconosciuto" il secondo invece, scatta se viene passasto un parametro di tipo stringa e setta il campo Nome al valore passato.
DISTRUTTORE
Il distruttore, al contrario del costrttore contiene il codice da eseguire quando 'muore' l'istanza della nostra classe. Ogni classe può avere un solo distruttore, la sistassi per dischiararlo è uguale al construttore, unica differenza, il nome deve essere uguale al nome della classe preceduto dal carattere tilde '~' es: ~Alunno()
Ereditarieta'
In C# per derivare una classe da un altra si utilizza il simbolo : (due punti). Quando si deriva una classe, vengono ereditati i suoi metodi e i suoi campi, ma non costruttore e distruttore, quindi, se necessario occorre definirli.
Per richiamare i metodi della classe base, compreso il costruttore, bisogna utilizzare la keyword BASE.
E' anche possibile limitare l'ereditarietà di una classe che andiamo a definire (se vogliamo che non venga derivata) usando la keyword SEALED. In questo modo quando si cercherà di derivare la classe il compilatore genererà un errore.
Accessibilita'
L'accesibilità dei membri che può essere utilizzata in C# è rappresentata dalle seguenti keyword:
- PUBLIC: l'accesso non è ristretto
- PROTECTED: l'accesso è limitato alla classe che lo contiene e alle classi derivate
- INTERNAL:l'accesso è limitato alle classi dello stesso assembly
- PROTECTED INTERNAL: l'accesso è limitato alle classi dello stesso assembly e a quelle derivate dalla classe che contiene il membro
- PRIVATE (Defoult): l'accesso è limitato alla classe che contiene il membro
Per le classi invece esistono i seguenti modificatori di accesso:
- PUBLIC: permette a chi unque di creare oggetti del tipo della classe.
- INTERNAL: permette di creare degli ogetti solo all'interno dello stesso assembly.
|
