Costruttori in C#

Benvenuto nella prossima lezione! In questa lezione imparerà a conoscere i costruttori in C#, il loro scopo e come utilizzarli per inizializzare gli oggetti. Iniziamo!

Che cos'è un costruttore?

Un costruttore è un metodo speciale di una classe che viene chiamato automaticamente quando viene creato un oggetto della classe. Viene utilizzato per inizializzare i dati dell'oggetto o eseguire attività di configurazione.

Punto chiave: un costruttore ha lo stesso nome della classe e non ha un tipo restituito.

Definizione di un costruttore

Per definire un costruttore, crei un metodo con lo stesso nome della classe. Ecco un esempio:

Suggerimento: utilizzi i costruttori per garantire che gli oggetti vengano sempre creati in uno stato valido.

using System;

class Car {
    public string Color;

    // Constructor
    public Car() {
        Color = "Red"; // Initialize the Color attribute
    }
}

class Program {
    static void Main() {
        Car myCar = new Car(); // Constructor is automatically called
        Console.WriteLine("Car color: " + myCar.Color); // Outputs: Car color: Red
    }
}

Costruttori con parametri

Un costruttore con parametri consente di passare valori per inizializzare i dati dell'oggetto durante la creazione dell'oggetto. Ecco un esempio:

Punto chiave: utilizzi i costruttori con parametri per inizializzare gli oggetti in modo flessibile.

using System;

class Car {
    public string Color;

    // Parameterized Constructor
    public Car(string color) {
        Color = color; // Initialize Color with the passed value
    }
}

class Program {
    static void Main() {
        Car myCar = new Car("Blue"); // Pass "Blue" to the constructor
        Console.WriteLine("Car color: " + myCar.Color); // Outputs: Car color: Blue
    }
}

Costruttori predefiniti

Se non viene definito esplicitamente alcun costruttore, C# fornisce un costruttore predefinito che inizializza i campi ai relativi valori predefiniti. Ecco un esempio:

Suggerimento: definisca un costruttore personalizzato quando è necessaria un'inizializzazione specifica.

using System;

class Car {
    public string Color; // Default value is null
}

class Program {
    static void Main() {
        Car myCar = new Car(); // Default constructor is automatically called
        Console.WriteLine("Car color: " + (myCar.Color ?? "Not set")); // Outputs: Car color: Not set
    }
}

Overload dei costruttori

C# supporta l'overload dei costruttori, ovvero una classe può avere più costruttori con elenchi di parametri diversi. Ecco un esempio:

Punto chiave: l'overload dei costruttori offre flessibilità durante la creazione degli oggetti.

using System;

class Car {
    public string Color;

    // Default Constructor
    public Car() {
        Color = "Red";
    }

    // Parameterized Constructor
    public Car(string color) {
        Color = color;
    }
}

class Program {
    static void Main() {
        Car defaultCar = new Car(); // Calls the default constructor
        Console.WriteLine("Default car color: " + defaultCar.Color); // Outputs: Default car color: Red

        Car customCar = new Car("Green"); // Calls the parameterized constructor
        Console.WriteLine("Custom car color: " + customCar.Color); // Outputs: Custom car color: Green
    }
}

Esercizio pratico

Crei una classe chiamata Book con un costruttore predefinito che imposti il titolo su "Unknown" e un costruttore con parametri che accetti un titolo. Visualizzi il titolo del libro per entrambi i costruttori. Ecco un esempio:

using System;

class Book {
    public string Title;

    // Default Constructor
    public Book() {
        Title = "Unknown";
    }

    // Parameterized Constructor
    public Book(string title) {
        Title = title;
    }
}

class Program {
    static void Main() {
        Book defaultBook = new Book();
        Console.WriteLine("Default book title: " + defaultBook.Title); // Outputs: Default book title: Unknown

        Book customBook = new Book("C# Programming");
        Console.WriteLine("Custom book title: " + customBook.Title); // Outputs: Custom book title: C# Programming
    }
}

Buone pratiche per i costruttori

Ecco alcune buone pratiche per l'utilizzo dei costruttori:

• Mantenga i costruttori semplici e focalizzati sull'inizializzazione.
• Eviti la logica complessa nei costruttori per garantire chiarezza.
• Utilizzi l'overload dei costruttori per rendere flessibile la creazione degli oggetti.

Suggerimento: i costruttori dovrebbero preparare un oggetto a essere completamente operativo subito dopo la creazione.

Ottimo lavoro!

Congratulazioni! Ha imparato che cosa sono i costruttori, come definirli e perché sono importanti per l'inizializzazione degli oggetti. Nella prossima lezione esploreremo il concetto di ereditarietà e impareremo a riutilizzare il codice in modo efficace. Continuiamo a programmare!