C#

LE CLASSI - costruttori-1

Ogni qual volta creiamo una classe abbiamo bisogno di un costruttore, ovvero di un metodo che viene eseguito quando la classe viene creata. Il costruttore viene normalmente fornito dal programmatore, diversamente ci pensa il compilatore ad offrirne uno con tutte le inizializzazioni previste di default. Vediamo subito un esempio:

  Esempio 21.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using System;

class Numeri
{
  public int x;
  public int y;
  public Numeri()
  {
    x = 1;
    y = 2;
  }
}

class Test
{
  public static void Main()
  {
    Numeri n1 = new Numeri();
    Console.WriteLine(n1.x + n1.y);
  }
}

Dalla riga 7 alla 11 abbiamo il nostro costruttore.  Come si vede è un  metodo che ha lo stesso nome della classe e nel quale vengono attribuiti valori alle variabili precedentemente definite. Quando viene definita un'istanza della classe il costruttore entra in azione attribuendo il valore ai campi variabile definiti. Si tratta, nella sua semplicità, del tipo più comune di costruttore e lo incontrerete spesso in programmi semplici o didattici ma anche in applicazioni più corpose. En passant, notiamo che Il fatto che esista un costruttore di default è dimostrato dal risultato che ottenete, come già accennato nel paragrafo precedente, se eliminate il costruttore dall'esempio 21.1 il risultato è 0, ovvero viene assegnato, ad x e y, il valore di default per il tipo intero. Come è comprensibile, la definizione di un costruttore custom taglia fuori quello di default provvisto dal compilatore.
Un costruttore di istanza può avere anche dei parametri, come nell'esempio seguente:

  Esempio 21.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;

class Numeri
{
  public int x;
  public int y;
  public Numeri(int a, int b) {
    x = a;
    y = b;
  }
}

class Test
{
  public static void Main()
  {
    Numeri n1 = new Numeri(10, 12);
    Console.WriteLine(n1.x + n1.y);
  }
}

Nell'esempio 21.2 alla riga 17 l'istanza viene creata passando due valori in forma parametri e questi sono riversati nei capi x e y dell'istanza di classe. Interessante è anche il fatto che è possibile fornire due costruttori:

  Esempio 21.3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;

class Numeri
{
  public int x;
  public int y;
  public Numeri(int a, int b) {
    x = a;
    y = b;
  }
  public Numeri()
  {
    x = 9;
    y = 7;
  }
}

class Test
{
  public static void Main()
  {
    Numeri n1 = new Numeri(10, 12);
    Console.WriteLine(n1.x + n1.y);
    Numeri n2 = new Numeri();
    Console.WriteLine(n2.x + n2.y);
  }
}

Come evidenziato, abbiamo due costruttori, uno alla riga 7 ed uno alla 11 che vengono richiamati rispettivamente alla 22 ed alla 24.

Se si vuole che il costruttore non entri in azione allora bisogna mettere il modificatore private al metodo costruttore. Infatti, se provate, alla riga 7, a sostituire la parola public con private il compilatore si lamenta. Una classe che abbia solo costruttori privati non può evidentemente essere istanziata. Vi potrete chiedere come possa essere utilizzata una classe con un costruttore di questo genere, lo vediamo nel seguente esempio:

  Esempio 21.4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using System;

class Numeri
{
  public static int x;
  public static int y;
  private Numeri() {}
}

class Test
{
  public static void Main()
  {
    Numeri.x = 100;
    Numeri.y = 200;
    Console.WriteLine(Numeri.x + Numeri.y);
  }
}

La classe Numeri non può essere istanziata ma x e y al suo interno possono essere raggiunti in quanto statici.

Un costruttore può anche essere definito statico e in questo caso è usato per inizializzare membri statici o per effettuare operazioni particolari una sola volta. Viene eseguita una sola volta per tipo, piuttosto che per istanza. In altre parole il runtime richiama il costruttore anche prima che il tipo sia usato e, se vogliamo, anche senza che il tipo sia usato. Questo può essere utile in alcuni casi. Di contro è evidente che l'utente non ha alcun controllo su questo tipo di costruttore, non può intervenire su di esso.  Un costruttore statico non può avere parametri e nemmeno modficatori; inoltre in ogni classe può esservi un solo costruttore statico. In questa fase non ci serviranno. Di seguito ecco un semplice esempio:

  Esempio 21.5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using System;

class Numeri
{
  public static int x;
  public static int y;
  static Numeri() {
    x = 2;
    y = 3;
  }
}

class Test
{
  public static void Main()
  {
    Console.WriteLine(Numeri.x + Numeri.y);
  }
}