Classi ed Oggetti

2026

Introduzione alle Classi in C#

Da struct a class: perché?
Dati + metodi insieme
Incapsulamento e accesso controllato
Costruttori e ciclo di vita

Parte I — Motivazione

Il problema con i dati "nudi"

Immaginiamo di rappresentare un orario:

// Approccio "naive": variabili separate
int ora    = 14;
int minuto = 30;
int secondo = 0;

// Nessun controllo: questo è "valido"?
ora = 99;
minuto = -5;

Problema: chiunque può assegnare valori non validi. Non c'è un controllo dei valori e delle operazioni permesse sui dati.

Limitazioni dei dati separati

Nessuna inizializzazione garantita — i valori di partenza non sono definiti
Nessun controllo di validità — ora=99 è accettata dal compilatore
Non è un'unità atomica — non posso passare "un orario" come singolo argomento
Duplicazione del codice — ogni funzione deve rivalidare i dati

La soluzione: la Classe

Una classe raggruppa dati (campi) e comportamenti (metodi) in un'unica entità:

class NomeClasse
{
    // 1. Campi (fields) — lo stato
    private tipo _nomeCampo;

    // 2. Costruttore — inizializzazione
    public NomeClasse(parametri)
    {
        // inizializza i campi
    }

    // 3. Metodi — il comportamento
    public tipoRitorno NomeMetodo(parametri)
    {
        // corpo del metodo
    }
}

Modificatori di accesso

Modificatore	Visibilità
`public`	Chiunque può accedere
`private`	Solo codice interno alla classe
`protected`	Classe + classi derivate

Regola pratica: campi → private, metodi/costruttori → public

Convenzioni sui nomi

https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/coding-style/identifier-names

Punti principali che ci interessano:

uso di PascalCase per nomi di classi e nomi di metodi (iniziale maiuscola e iniziali delle parole che compongono il nome anch'esse maiuscole)

esempio: AutoSportiva
campi privati devono iniziare con un underscore '_'

La classe Orario — prima versione

class Orario
{
    private int _ora;
    private int _minuto;
    private int _secondo;

    public void ImpostaOrario(int h, int m, int s)
    {
        _ora    = (h >= 0 && h < 24) ? h : 0;
        _minuto = (m >= 0 && m < 60) ? m : 0;
        _secondo = (s >= 0 && s < 60) ? s : 0;
    }

    public void StampaOrario()
    {
        Console.WriteLine($"{_ora:D2}:{_minuto:D2}:{_secondo:D2}");
    }
}

Usare la classe

// Creare un oggetto con "new"
Orario pranzo = new Orario();

// Chiamare i metodi
pranzo.ImpostaOrario(13, 0, 0);
pranzo.StampaOrario();   // → 13:00:00

// Tentativo di accesso diretto ai campi: ERRORE di compilazione
// pranzo._ora = 99;  // 'Orario._ora' non e' accessibile

new alloca l'oggetto nella memoria heap e restituisce un riferimento ad esso.

Parte II — Costruttori

Cos'è un costruttore

Metodo speciale che viene chiamato automaticamente con new
Stesso nome della classe, nessun tipo di ritorno
Garantisce che l'oggetto sia sempre in uno stato valido
Se non ne scrivi uno, C# ne genera uno vuoto automaticamente

Costruttore con parametri

class Orario
{
    private int _ora;
    private int _minuto;
    private int _secondo;

    // Costruttore
    public Orario(int ora, int minuto, int secondo)
    {
        _ora     = (ora >= 0 && ora < 24)       ? ora     : 0;
        _minuto  = (minuto >= 0 && minuto < 60)  ? minuto  : 0;
        _secondo = (secondo >= 0 && secondo < 60) ? secondo : 0;
    }

    public void Stampa()
    {
        Console.WriteLine($"{_ora:D2}:{_minuto:D2}:{_secondo:D2}");
    }
}

Costruttori multipli (overloading)

class Orario
{
    private int _ora, _minuto, _secondo;

    // Costruttore completo
    public Orario(int ora, int minuto, int secondo)
    {
        ImpostaOrario(ora, minuto, secondo);
    }

    // Costruttore con soli ore e minuti
    public Orario(int ora, int minuto)
        : this(ora, minuto, 0) { }   // chiama il costruttore sopra

    // Costruttore predefinito (mezzanotte)
    public Orario()
        : this(0, 0, 0) { }

    private void ImpostaOrario(int h, int m, int s)
    {
        if (h >= 0 && h < 24) {
            _ora = h;
        } else {
            ora = 0;
        }
        if ( m >= 0 && m < 60) {
            _minuto = m;
        } else {
            _minuto = 0;
        }
        if (s >= 0 && s < 60) {
            _secondo = s;
        } else {
            _secondo = 0;
        }
    }
}

Usare più costruttori

Orario mezzanotte = new Orario();         // 00:00:00
Orario lezione    = new Orario(8, 15);    // 08:15:00
Orario fine       = new Orario(10, 0, 0); // 10:00:00

In C# non esiste il distruttore nel senso di C++. Il Garbage Collector libera automaticamente la memoria quando l'oggetto non è più raggiungibile.

Parte IV — Proprietà

Le Properties di C#

C# introduce le properties: sintassi più pulita per i metodi che permettono di ottenere il valore di un attributo privato (getter) e per i metodi che permettono di impostare un valore per l'attributo (setter) https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties

class Orario
{
    private int _ora; // attributo privato (

    public int Ora
    {
        get { return _ora; }
        set
        {
            if (value >= 0 && value < 24)
                _ora = value;
        }
    }
}

// Utilizzo: sembra un campo, ma esegue il codice get/set
Orario t = new Orario();
t.Ora = 14;          // chiama il setter
Console.WriteLine(t.Ora);  // chiama il getter

Auto-properties

Quando non serve logica di validazione, si usa la forma breve:

class Studente
{
    // Auto-property: il campo privato è generato automaticamente
    public string Nome    { get; set; }
    public string Cognome { get; set; }
    public int    Eta     { get; set; }

    public Studente(string nome, string cognome, int eta)
    {
        Nome    = nome;
        Cognome = cognome;
        Eta     = eta;
    }

    public override string ToString()
    {
        return $"{Cognome} {Nome}, {Eta} anni";
    }
}

Proprietà in sola lettura

class Cerchio
{
    public double Raggio { get; }   // solo get → immutabile dopo costruzione

    public Cerchio(double raggio)
    {
        Raggio = raggio;
    }

    // Proprietà calcolata (non memorizzata)
    public double Area
    {
        get { return Math.PI * Raggio * Raggio; }
    }
}

Cerchio c = new Cerchio(5.0);
Console.WriteLine(c.Area);    // 78.53...
// c.Raggio = 10;             // ERRORE: proprietà in sola lettura

Parte V — Esempio Completo

La classe Conto Bancario

class ContoBancario
{
    private decimal _saldo;

    public string Intestatario { get; }
    public string IBAN          { get; }

    public decimal Saldo
    {
        get { return _saldo; }
    }

    public ContoBancario(string intestatario, string iban,
                         decimal saldoIniziale = 0)
    {
        Intestatario = intestatario;
        IBAN         = iban;
        _saldo       = saldoIniziale >= 0 ? saldoIniziale : 0;
    }

La classe Conto Bancario (metodi)

    public bool Deposita(decimal importo)
    {
        if (importo <= 0) return false;
        _saldo += importo;
        return true;
    }

    public bool Preleva(decimal importo)
    {
        if (importo <= 0 || importo > _saldo) return false;
        _saldo -= importo;
        return true;
    }

    public override string ToString()
    {
        return $"{Intestatario} | {IBAN} | Saldo: {_saldo}";
    }
}

Utilizzo della classe

Questo codice può essere inserito come top-level statement PRIMA della dichiarazione della classe, oppure racchiuso in una funzione Main()

Esempio come top-level statement

ContoBancario conto = new ContoBancario("Mario Rossi", "IT60X0542811101000000123456", 500);

conto.Deposita(200);
Console.WriteLine(conto);          // Mario Rossi | ... | Saldo: €700,00

bool ok = conto.Preleva(1000);
Console.WriteLine(ok);
Console.WriteLine(conto.Saldo);

// conto._saldo = 99999;           // ERRORE: campo privato

Esempio con Main()

class ContoBancario {
    // resto della implementazione
    public static void Main() {
        ContoBancario conto = new ContoBancario("Mario Rossi", "IT60X0542811101000000123456", 500);

        conto.Deposita(200);
        Console.WriteLine(conto);          // Mario Rossi | ... | Saldo: €700,00

        bool ok = conto.Preleva(1000);
        Console.WriteLine(ok);
        Console.WriteLine(conto.Saldo);

        // conto._saldo = 99999;           // ERRORE: campo privato
    }
}

Parte VI — Riepilogo

Concetti chiave

Concetto	C#
Definizione classe	`class NomeClasse { ... }`
Creazione oggetto	`NomeClasse obj = new NomeClasse();`
Campo privato	`private tipo _nomeCampo;`
Costruttore	`public NomeClasse(params) { ... }`
Proprietà	`public tipo Nome { get; set; }`
Metodo	`public tipoRet NomeMetodo() { ... }`
Memoria	Gestita dal Garbage Collector

Prossimi passi

Ereditarietà: una classe può estendere un'altra (class B : A)
Polimorfismo: metodi virtual e override
Interfacce: contratti che una classe si impegna a rispettare
Liste generiche: Dictionary<K,V>

Fine

"Make it work, make it right, make it fast." — Kent Beck