Classi e oggetti: creazione, costruttori e inizializzazione

1. Creazione di un oggetto

Eccoci arrivati alla creazione degli oggetti. Probabilmente ci sei già incappato prima, solo che ora vediamo la cosa più in dettaglio. In realtà creare oggetti è facilissimo.

Per creare un oggetto, devi usare l'operatore new. Di solito crei una nuova istanza (oggetto) di una classe e la salvi subito in una variabile dello stesso tipo.

Classe nome = new Classe(parametri);

Dove Classe è il tipo dell'oggetto, nome è il nome della variabile (spesso minuscolo, tipo cat), e a destra di = c'è la creazione di un nuovo oggetto di quella classe.

Esempi:

object o = new object();

Cat pet = new Cat();

var reader = new StreamReader("file.txt");

Spessissimo i programmatori chiamano le variabili con lo stesso nome della classe, solo minuscolo. Per chi è alle prime armi, questo codice può confondere:

Student student = new Student();

Car car = new Car();

PersonInfo personInfo = new PersonInfo();

In realtà non c'è nulla di strano — è codice normalissimo dove si crea una variabile e la si inizializza subito con un oggetto dello stesso tipo.

A sinistra — dichiarazione della variabile, a destra — creazione di un nuovo oggetto in memoria con new. Tutto qui!

2. Costruttore

Avrai notato che spesso quando crei un oggetto gli passi dei parametri. A volte alcuni oggetti li vogliono, altri no. Ma come funziona tutto questo meccanismo dei parametri?

Anche qui è semplice: ogni classe ha un metodo speciale (o più metodi) che gestisce i parametri quando crei un oggetto. Questi metodi si chiamano costruttori. Uno solo si chiama costruttore.

Riconoscere un metodo costruttore da un metodo normale è facile. Ha due caratteristiche:

• il nome del costruttore coincide con il nome della classe (e inizia con la maiuscola)
• il costruttore non ha tipo di ritorno (nemmeno void si scrive).

In generale, la sua forma è così:

modificatori Classe(parametri)
{
   codice del costruttore
}

Esempio di dichiarazione di un costruttore:

public class Point
{
    public int X;
    public int Y;

    public Point(int x, int y) // Costruttore
    {
        X = x;
        Y = y;
    }
}

Utilizzo:

Point p = new Point(5, 10); // Chiamata al costruttore

Quando crei un oggetto con new Point(5, 10) viene chiamato il costruttore con due parametri, che inizializzano i campi X e Y.

A volte i parametri del costruttore hanno lo stesso nome dei campi — per comodità. Questo conflitto si risolve con la parola chiave this:

public Point(int x, int y)
{
    this.x = x; // this.x — campo dell'oggetto, x — parametro del costruttore
    this.y = y;
}

3. Chiamata al costruttore

Quando scrivi new Classe(parametri), C#:

• crea un nuovo oggetto in memoria,
• chiama il costruttore giusto, passando i tuoi parametri.

Esempio con la classe gatto:

public class Cat
{
    public string Name;
    public int Age;

    public Cat(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

Utilizzo:

Cat cat = new Cat("Vaska", 2); // Ok: viene chiamato il costruttore con due parametri
Cat cat2 = new Cat("Vaska");   // Non va: non esiste un costruttore così — errore di compilazione
Cat cat3 = new Cat();          // Non va: non c'è un costruttore senza parametri — errore di compilazione

Se la classe ha solo costruttori con parametri, devi per forza passare i valori quando crei l'oggetto.

4. Più costruttori

Se vuoi, puoi aggiungere più costruttori a una classe. Non ci sono limiti al numero di costruttori o ai loro parametri. Quando crei un oggetto, il compilatore sceglie quello giusto in base ai parametri.

Esempio:

public class Cat
{
    public const int SCONOSCIUTO = -1;
    public string Name;
    public int Age;

    public Cat(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public Cat(string name)
    {
        Name = name;
        Age = SCONOSCIUTO; // Valore "di default" per età sconosciuta
    }
}

Utilizzo:

Cat cat1 = new Cat("Vaska", 2); // Usa il primo costruttore
Cat cat2 = new Cat("Murka");    // Usa il secondo costruttore
Cat cat3 = new Cat();           // Errore! Non c'è un costruttore senza parametri

Abbiamo pensato che l'età del gatto possa essere sconosciuta. Per questo abbiamo aggiunto una costante speciale — SCONOSCIUTO e un costruttore che prende solo il nome del gatto.

Nota che inizializziamo comunque entrambe le variabili di classe dentro entrambi i costruttori. I parametri mancanti o sconosciuti li sostituiamo con la costante SCONOSCIUTO.

5. Costruttore di default

Se la tua classe non ha nessun costruttore, il compilatore aggiunge automaticamente un costruttore vuoto senza parametri:

public ClassName()
{
}

Ma se nella classe hai già dichiarato almeno un costruttore tuo — il costruttore vuoto non viene più aggiunto in automatico.

Esempio 1:

public class Cat
{
    public string Name;
    public int Age;
}

// Ok:
Cat cat = new Cat(); // Verrà chiamato il costruttore di default (senza parametri)

Esempio 2:

public class Cat
{
    public string Name;
    public int Age;

    public Cat(string name) { Name = name; }
}

// Non va:
Cat cat = new Cat(); // Errore: non c'è più il costruttore senza parametri!

6. Inizializzazione delle variabili

In C# puoi inizializzare le variabili di classe sia direttamente nella dichiarazione, sia nel costruttore.

Esempio:

public class Cat
{
    public string Name;
    public int Age = -1; // Valore iniziale

    public Cat(string name, int age)
    {
        Name = name;
        Age = age; // Sovrascrive il valore iniziale
    }

    public Cat()
    {
        Name = "SenzaNome";
        // Age resta -1 (valore iniziale)
    }
}

Spiegazione:

• Se crei con new Cat("Vaska", 2) la variabile Age sarà prima -1, poi il costruttore la mette a 2.
• Se crei con new Cat() — Age resta -1.

7. Ordine di inizializzazione delle variabili

I dati di un nuovo oggetto vengono inizializzati in questo ordine:

1. I campi della classe ricevono prima i valori di default (0 per int, null per i tipi reference, ecc.).
2. Poi vengono eseguiti gli inizializzatori che hai messo nella dichiarazione dei campi, nell'ordine in cui compaiono nel codice.
3. E solo dopo viene eseguito il codice del costruttore.

Le variabili vengono inizializzate prima del costruttore e nell'ordine di dichiarazione. Quindi occhio alle dipendenze tra i campi.

Esempio sbagliato

I campi non statici non si possono inizializzare con altre variabili non statiche:

public class Solution
{
    public int a = 1; 
    public int b = a;        // non puoi usare a
    public int c = a + b;   // non puoi usare a e b
}
// Questo codice darà errore di compilazione!

Esempio giusto

Per le variabili statiche funziona tutto:

public class Solution
{
    public static int a = 1;          // Impostiamo a = 1
    public static int b = a + 2;      // b = 1 + 2 ⇒ 3
    public static int c = a + b + 3;  // c = 1 + 3 + 3 ⇒ 7

    public Solution()
    {
        Console.WriteLine($"a = {a}, b = {b}, c = {c}");
        // Stampa: a = 1, b = 3, c = 7 — proprio come ci si aspetta
    }
}

Esempio giusto 2

Per i campi statici puoi anche scrivere così:

public class Solution
{
    public static int a = b + c + 1;    // b e c sono ancora 0
    public static int b = a + c + 2;    // a == 1, c è ancora 0
    public static int c = a + b + 3;    // a == 1, b == 3
}

2

Compito

C# SELF, livello 12, lezione 0

Bloccato

Creazione di una classe e di un oggetto

Creazione di una classe e di un oggetto

Apri

2

Compito

C# SELF, livello 12, lezione 0

Bloccato

Inizializzazione delle variabili e diversi costruttori

Inizializzazione delle variabili e diversi costruttori

Apri