Parco Auto 3: ereditarietà e polimorfismo

Auto elettriche e sportive senza riscrivere codice: classi figlie, virtual e override, e una sola List per tutti i tipi di auto.

Ultima tappa del Parco Auto. Riparti dal progetto delle lezioni Parco Auto 1 e Parco Auto 2: la classe Automobile c'è già, e ora le diamo dei figli.

Ereditarietà: Le Classi Figlie

Hai creato la classe Automobile. Ma cosa succede se vuoi gestire anche AutoElettrica o AutoSportiva? Hanno molte cose in comune con Automobile, ma anche caratteristiche diverse. Devi riscrivere tutto da capo? No! Esiste l'ereditarietà.

🤔 Il Problema Senza Ereditarietà

❌ SENZA Ereditarietà - Codice Duplicato

// Devi scrivere due classi SEPARATE con tutto il codice ripetuto
class Automobile
{
    private string _modello;
    private int _cilindrata;
    private string _carburante;
    // ... costruttore, proprietà, metodi ...
}

class AutoElettrica
{
    private string _modello;       // ← DUPLICATO!
    private int _cilindrata;       // ← DUPLICATO!
    private string _carburante;    // ← DUPLICATO!
    private int _autonomiaKm;      // Nuovo campo specifico
    // ... tutto il costruttore duplicato ...
    // ... tutte le proprietà duplicate ...
}

// 😱 Problemi:
// 1. Codice identico scritto due volte → errori facilissimi
// 2. Se devi correggere un bug, devi farlo in ENTRAMBE le classi
// 3. Non è scalabile: per 10 tipi di auto, 10 classi duplicate!

✅ CON Ereditarietà - Codice Riutilizzato

✅ CON Ereditarietà - DRY (Don't Repeat Yourself)

// La classe BASE ha tutto il codice comune
class Automobile
{
    private string _modello;
    private int _cilindrata;
    private string _carburante;
    // ... proprietà e metodi comuni a TUTTE le auto ...
}

// La classe FIGLIA eredita tutto e aggiunge solo il nuovo
class AutoElettrica : Automobile   // ← Il ":" significa "estende"
{
    private int _autonomiaKm;      // Solo la parte NUOVA!
    // tutto il resto lo prende GRATIS da Automobile!
}

// ✅ Vantaggi:
// 1. AutoElettrica ha già Modello, Cilindrata, Carburante
// 2. Correggi un bug in Automobile → fix automatico per tutti
// 3. Aggiungi 10 tipi di auto senza duplicare nulla

🎯 Analogia del Mondo Reale

Pensa alla biologia:

• Animale (classe base) → respira, si muove, ha un nome
• Cane (classe figlia) → eredita tutto da Animale + abbaia, ha una razza
• Gatto (classe figlia) → eredita tutto da Animale + fa le fusa, è indipendente

Il Cane non deve "reimparare" a respirare: lo eredita dall'Animale!

              Automobile (CLASSE BASE / GENITORE)
              ├── Modello
              ├── Cilindrata
              ├── Carburante
              └── ToString()
                      │
          ┌───────────┼───────────┐
          ↓           ↓           ↓
    AutoElettrica  AutoSportiva  AutoLusso
    (FIGLIA)       (FIGLIA)      (FIGLIA)
    + AutonomiaKm  + Cavalli     + Prezzo
    + Batteria     + Turbo       + Brand

Come Si Scrive una Classe Figlia

1. Modificare la Classe Base: aggiungere protected

Prima di creare classi figlie, devi modificare la classe Automobile. Le classi figlie non possono accedere ai campi private del genitore. Devi usare protected:

Automobile.cs - Campi diventano protected

public class Automobile
{
    // ─────────────────────────────────────────────────────────
    // PRIMA usavi "private" → SOLO questa classe poteva vederli
    // ORA usi "protected" → anche le classi FIGLIE possono vederli
    // Dall'esterno (Form, altri) rimangono comunque nascosti!
    // ─────────────────────────────────────────────────────────
    protected string _modello;        // ← protected, non private
    protected int _cilindrata;        // ← protected, non private
    protected string _carburante;     // ← protected, non private

    // Le PROPRIETÀ e i METODI pubblici rimangono uguali
    public string Modello
    {
        get { return _modello; }
        set { if (!string.IsNullOrEmpty(value)) _modello = value; }
    }
    public int Cilindrata
    {
        get { return _cilindrata; }
        set { if (value >= 500 && value <= 10000) _cilindrata = value; }
    }
    public string Carburante
    {
        get { return _carburante; }
        set { if (!string.IsNullOrEmpty(value)) _carburante = value; }
    }

    // Il costruttore rimane uguale
    public Automobile(string modello, int cilindrata, string carburante)
    {
        Modello = modello;
        Cilindrata = cilindrata;
        Carburante = carburante;
    }

    // ─────────────────────────────────────────────────────────
    // IMPORTANTE: aggiungi "virtual" ai metodi che le figlie
    // potranno personalizzare (override)
    // ─────────────────────────────────────────────────────────
    public virtual string Stampa()
    {
        return $"{Modello} - {Cilindrata}cc - {Carburante}";
    }

    public override string ToString()
    {
        return Stampa();
    }
}

🔑 I Tre Livelli di Visibilità

2. Creare la Classe Figlia: AutoElettrica

Aggiungi un nuovo file AutoElettrica.cs al progetto (come hai fatto per Automobile.cs).

AutoElettrica.cs - Classe Figlia Completa

using System;
using System.Windows.Forms;

namespace ParcoAuto
{
    // ═══════════════════════════════════════════════════
    //  AutoElettrica ESTENDE Automobile
    //  Il ":" indica "eredita da"
    //  Leggi: "AutoElettrica è un tipo di Automobile"
    // ═══════════════════════════════════════════════════
    public class AutoElettrica : Automobile
    {
        // ─────────────────────────────────────────────
        // CAMPI PRIVATI propri di AutoElettrica
        // (quelli di Automobile li ha già ereditati!)
        // ─────────────────────────────────────────────
        private int _autonomiaKm;
        private int _percentualeBatteria;

        // ─────────────────────────────────────────────
        // PROPRIETÀ proprie di AutoElettrica
        // ─────────────────────────────────────────────
        public int AutonomiaKm
        {
            get { return _autonomiaKm; }
            set
            {
                if (value >= 50 && value <= 1000) { _autonomiaKm = value; } else { MessageBox.Show("Autonomia deve essere tra 50 e 1000 km!", "ERRORE", MessageBoxButtons.OK, MessageBoxIcon.Error); } } } public int PercentualeBatteria { get { return _percentualeBatteria; } set { if (value >= 0 && value <= 100)
                    _percentualeBatteria = value;
                else
                    MessageBox.Show("Percentuale batteria deve essere tra 0 e 100!",
                                  "ERRORE", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // ─────────────────────────────────────────────
        // PROPRIETÀ CALCOLATA: km rimasti con la carica attuale
        // ─────────────────────────────────────────────
        public double KmRimasti
        {
            get { return _autonomiaKm * (_percentualeBatteria / 100.0); }
        }

        // ─────────────────────────────────────────────
        // COSTRUTTORE della classe figlia
        // Deve chiamare il costruttore del GENITORE con "base(...)"
        // ─────────────────────────────────────────────
        public AutoElettrica(string modello, int autonomiaKm, int percentualeBatteria)
            : base(modello, 0, "Elettrica")   // ← chiama Automobile(modello, 0, "Elettrica")
        {
            // Dopo che il costruttore base ha fatto il suo lavoro,
            // impostiamo le proprietà specifiche di AutoElettrica
            AutonomiaKm = autonomiaKm;
            PercentualeBatteria = percentualeBatteria;
        }

        // ─────────────────────────────────────────────
        // OVERRIDE di Stampa() → versione personalizzata
        // Sostituisce la versione del genitore
        // ─────────────────────────────────────────────
        public override string Stampa()
        {
            return $"{Modello} [⚡ Elettrica] - Autonomia: {AutonomiaKm}km - " +
                   $"Batteria: {PercentualeBatteria}% ({KmRimasti:F0}km rimasti)";
        }
        // ToString() NON serve riscriverlo! Chiama già Stampa()
        // che ora è la versione override di AutoElettrica ✅
    }
}

🔍 Analisi del Costruttore Figlia

public AutoElettrica(string modello, int autonomiaKm, int percentualeBatteria)
    : base(modello, 0, "Elettrica")
//  ↑
//  "base(...)" = chiama il costruttore di AUTOMOBILE
//  Gli passo:  modello (dall'utente), 0 (cilindrata 0 per elettrica),
//              "Elettrica" (carburante fisso)
//
// ORDINE di esecuzione:
// 1. Prima viene eseguito il costruttore di Automobile (base)
//    → imposta _modello, _cilindrata, _carburante
// 2. Poi viene eseguito il corpo di AutoElettrica
//    → imposta _autonomiaKm, _percentualeBatteria

3. Creare una Seconda Figlia: AutoSportiva

AutoSportiva.cs

namespace ParcoAuto
{
    public class AutoSportiva : Automobile
    {
        private int _cavalliVapore;
        private bool _hasTurbo;

        public int CavalliVapore
        {
            get { return _cavalliVapore; }
            set
            {
                if (value >= 100 && value <= 2000)
                    _cavalliVapore = value;
                else
                    MessageBox.Show("Cavalli vapore devono essere tra 100 e 2000!",
                                  "ERRORE", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        public bool HasTurbo
        {
            get { return _hasTurbo; }
            set { _hasTurbo = value; }
        }

        // Costruttore: chiama base per modello, cilindrata, carburante
        public AutoSportiva(string modello, int cilindrata, string carburante,
                            int cavalliVapore, bool hasTurbo)
            : base(modello, cilindrata, carburante)
        {
            CavalliVapore = cavalliVapore;
            HasTurbo = hasTurbo;
        }

        // Override personalizzato per AutoSportiva
        public override string Stampa()
        {
            string turbo = HasTurbo ? " [TURBO]" : "";
            return $"{Modello} [🏎️ Sport]{turbo} - {Cilindrata}cc - " +
                   $"{CavalliVapore}cv - {Carburante}";
        }
    }
}

Override: Personalizzare i Metodi Ereditati

override significa letteralmente "sostituire". Una classe figlia può riscrivere un metodo del genitore per dargli un comportamento diverso, più adatto al suo tipo specifico.

🔑 Le Tre Parole Chiave: virtual, override, base

Esempio completo - virtual, override, base

// ─────────────────────────────────────────────────
// CLASSE BASE
// ─────────────────────────────────────────────────
public class Automobile
{
    public virtual string Stampa()          // ← virtual: "può essere overridato"
    {
        return $"{Modello} - {Cilindrata}cc - {Carburante}";
    }
}

// ─────────────────────────────────────────────────
// CLASSE FIGLIA - Override completo
// ─────────────────────────────────────────────────
public class AutoElettrica : Automobile
{
    public override string Stampa()        // ← override: "sostituisco la versione base"
    {
        // Versione completamente nuova, ignora quella di Automobile
        return $"{Modello} [⚡] - Autonomia: {AutonomiaKm}km";
    }
}

// ─────────────────────────────────────────────────
// CLASSE FIGLIA - Override con base (estende senza perdere)
// ─────────────────────────────────────────────────
public class AutoSportiva : Automobile
{
    public override string Stampa()
    {
        // Richiama il metodo del genitore e CI AGGIUNGE qualcosa
        string testoBase = base.Stampa();  // ← "base." chiama Automobile.Stampa()
        // testoBase = "Ferrari 488 - 3900cc - Benzina"

        return testoBase + $" | {CavalliVapore}cv";
        // Risultato: "Ferrari 488 - 3900cc - Benzina | 660cv"
    }
}

// ─────────────────────────────────────────────────
// Risultato nelle listbox:
// ─────────────────────────────────────────────────
// Automobile normale:  "Fiat 500 - 1200cc - Benzina"
// AutoElettrica:       "Tesla [⚡] - Autonomia: 500km"
// AutoSportiva:        "Ferrari 488 - 3900cc - Benzina | 660cv"

⚠️ Errore Comune: dimenticare "virtual"

// ❌ SBAGLIATO: metodo nella base senza "virtual"
public class Automobile
{
    public string Stampa()   // ← manca "virtual"!
    {
        return $"{Modello} - {Cilindrata}cc";
    }
}

public class AutoElettrica : Automobile
{
    public override string Stampa()   // 💥 ERRORE di compilazione!
    // "non si può fare override di un metodo non-virtual"
    { ... }
}

// ✅ SOLUZIONE: aggiungi "virtual" nella classe base
public class Automobile
{
    public virtual string Stampa()   // ← ora le figlie possono overridarlo
    { ... }
}

Polimorfismo: Un'Unica Lista per Tutti i Tipi

Polimorfismo viene dal greco: "molte forme". È il concetto più potente dell'ereditarietà: puoi trattare oggetti di tipo diverso come se fossero tutti dello stesso tipo base.

🤔 Il Problema: Tre Liste Separate

❌ SENZA Polimorfismo - Devi gestire tre liste

// Devi tenere tre liste separate:
private List<Automobile>   listaAuto;
private List<AutoElettrica> listaElettriche;
private List<AutoSportiva>  listaSportive;

// Tre foreach per aggiornare la ListBox:
foreach (Automobile a in listaAuto)       lstAuto.Items.Add(a);
foreach (AutoElettrica e in listaElettriche) lstAuto.Items.Add(e);
foreach (AutoSportiva s in listaSportive)  lstAuto.Items.Add(s);

// Tre cicli per salvare su file:
// ... idem ...

// 😱 Il codice esplode di complessità!

✅ CON Polimorfismo - Una sola lista, tutto funziona

✅ CON Polimorfismo - Elegante e semplice

// UNA SOLA lista di tipo Automobile
// ma può contenere anche AutoElettrica e AutoSportiva!
// Perché AutoElettrica e AutoSportiva SONO Automobile (ereditarietà)
private List<Automobile> listaAuto;

// Aggiungi tutti i tipi nella stessa lista:
listaAuto.Add(new Automobile("Fiat 500", 1200, "Benzina"));
listaAuto.Add(new AutoElettrica("Tesla Model 3", 500, 85));
listaAuto.Add(new AutoSportiva("Ferrari 488", 3900, "Benzina", 660, true));

// UN SOLO foreach per aggiornarla:
foreach (Automobile auto in listaAuto)
{
    // C# chiama automaticamente il Stampa() GIUSTO per ogni oggetto!
    // - Se è Automobile normale → usa Automobile.Stampa()
    // - Se è AutoElettrica     → usa AutoElettrica.Stampa() (override)
    // - Se è AutoSportiva      → usa AutoSportiva.Stampa()  (override)
    lstAuto.Items.Add(auto);   // ToString() → Stampa() corretto!
}

// Risultato nella ListBox:
// Fiat 500 - 1200cc - Benzina
// Tesla Model 3 [⚡ Elettrica] - Autonomia: 500km - Batteria: 85%
// Ferrari 488 [🏎️ Sport][TURBO] - 3900cc - 660cv - Benzina

🎬 Come Funziona il Polimorfismo - Dietro le Quinte

// La lista contiene oggetti di tipo diverso, MA la variabile è Automobile:
Automobile auto = listaAuto[1];   // Prendo il secondo elemento

// Questo oggetto è in realtà un'AutoElettrica (era il Tesla)
// Ma C# SA che tipo è realmente (lo ricorda in memoria)

// Quando chiami Stampa()...
string testo = auto.Stampa();
//             ↑
// C# non chiama Automobile.Stampa()
// C# chiama AutoElettrica.Stampa()  ← quello giusto!
//
// Questo si chiama DISPATCH DINAMICO:
// la versione del metodo da chiamare viene scelta
// a RUNTIME (mentre il programma gira) non a compilazione

// È come se l'oggetto dicesse:
// "Sì, mi chiami Automobile, ma io so CHI SONO davvero!"

🔎 Riconoscere il Tipo Reale: is e as

A volte hai bisogno di sapere il tipo reale di un oggetto nella lista e accedere alle proprietà specifiche.

foreach (Automobile auto in listaAuto)
{
    // "is" controlla se l'oggetto è di quel tipo
    if (auto is AutoElettrica)
    {
        // "as" converte l'oggetto al tipo specifico
        AutoElettrica elettrica = auto as AutoElettrica;

        // Ora puoi accedere alle proprietà di AutoElettrica
        MessageBox.Show($"Autonomia: {elettrica.AutonomiaKm}km");
    }
    else if (auto is AutoSportiva)
    {
        AutoSportiva sportiva = auto as AutoSportiva;
        MessageBox.Show($"Potenza: {sportiva.CavalliVapore}cv");
    }
    else
    {
        // È un'Automobile normale
        MessageBox.Show($"Auto standard: {auto.Modello}");
    }
}

Esempio Pratico: Aggiungere le Classi Figlie al Form

Vediamo come modificare il Form del Parco Auto per gestire anche AutoElettrica e AutoSportiva con la stessa lista.

1. Aggiungere una ComboBox per il Tipo di Auto

Aggiungi una ComboBox chiamata cmbTipoAuto con le voci: "Standard", "Elettrica", "Sportiva".

Form1.cs - Inizializzazione

private void InizializzaTipiAuto()
{
    cmbTipoAuto.Items.Add("Standard");
    cmbTipoAuto.Items.Add("Elettrica");
    cmbTipoAuto.Items.Add("Sportiva");
    cmbTipoAuto.SelectedIndex = 0;
}

2. Logica di Aggiunta: creare il tipo giusto in base alla scelta

Form1.cs - btnAggiungi_Click con Polimorfismo

private void btnAggiungi_Click(object sender, EventArgs e)
{
    if (!ControllaCampi()) return;
    if (!ValidaCilindrata(txtCilindrata.Text)) return;

    string modello    = txtModello.Text;
    int cilindrata    = Convert.ToInt32(txtCilindrata.Text);
    string carburante = cmbCarburante.SelectedItem.ToString();
    string tipoScelto = cmbTipoAuto.SelectedItem.ToString();

    // Variabile di tipo BASE → può contenere qualsiasi figlia
    Automobile nuovaAuto;

    // Crea il tipo giusto in base alla scelta dell'utente
    if (tipoScelto == "Elettrica")
    {
        // Chiedi i dati specifici per l'elettrica
        int autonomia = 400;     // Potresti leggerli da una TextBox dedicata
        int batteria = 100;
        nuovaAuto = new AutoElettrica(modello, autonomia, batteria);
    }
    else if (tipoScelto == "Sportiva")
    {
        int cv = 300;            // Anche questi da TextBox dedicate
        bool turbo = false;
        nuovaAuto = new AutoSportiva(modello, cilindrata, carburante, cv, turbo);
    }
    else
    {
        // Standard
        nuovaAuto = new Automobile(modello, cilindrata, carburante);
    }

    // Aggiunge alla lista (polimorfismo: sempre List<Automobile>!)
    listaAuto.Add(nuovaAuto);

    // Aggiorna - funziona per TUTTI i tipi grazie al polimorfismo
    AggiornaListaAuto();
    AggiornaStatistiche();
    PulisciCampi();
}

3. Statistiche per Tipo - Usare is per contare

Form1.cs - AggiornaStatistiche con tipi

private void AggiornaStatistiche()
{
    int totale      = listaAuto.Count;
    int standard    = 0;
    int elettriche  = 0;
    int sportive    = 0;

    foreach (Automobile auto in listaAuto)
    {
        if (auto is AutoElettrica) elettriche++;
        else if (auto is AutoSportiva) sportive++;
        else standard++;
    }

    lblTotaleAuto.Text = $"Totale: {totale} " +
                         $"(Standard: {standard} | " +
                         $"⚡ Elettriche: {elettriche} | " +
                         $"🏎️ Sportive: {sportive})";
}

Schema Riassuntivo: Ereditarietà e Polimorfismo

┌─────────────────────────────────────────────────────────────────┐
│                    AUTOMOBILE (Classe Base)                     │
│  protected: _modello, _cilindrata, _carburante                  │
│  public:    Modello, Cilindrata, Carburante (proprietà)         │
│  virtual:   Stampa()  ← può essere sostituito dalle figlie      │
└──────────────────────────┬──────────────────────────────────────┘
                           │  eredita con ":"
             ┌─────────────┼─────────────┐
             ↓             ↓             ↓
   ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
   │AutoElettrica │ │ AutoSportiva │ │  AutoLusso   │
   │ (figlia)     │ │  (figlia)    │ │  (figlia)    │
   │              │ │              │ │              │
   │ +AutonomiaKm │ │ +CavalliVap. │ │ +Prezzo      │
   │ +Batteria%   │ │ +HasTurbo    │ │ +Brand       │
   │ +KmRimasti   │ │              │ │              │
   │              │ │              │ │              │
   │ override     │ │ override     │ │ override     │
   │ Stampa()     │ │ Stampa()     │ │ Stampa()     │
   └──────────────┘ └──────────────┘ └──────────────┘

POLIMORFISMO in azione:
  List<Automobile> lista = new List<Automobile>();
  lista.Add(new Automobile(...));      // ✅ Standard
  lista.Add(new AutoElettrica(...));   // ✅ Figlia accettata!
  lista.Add(new AutoSportiva(...));    // ✅ Figlia accettata!

  foreach (Automobile a in lista)
  {
      lstAuto.Items.Add(a);   // Chiama Stampa() GIUSTO per ognuno ✅
  }

REGOLA FONDAMENTALE:
  "Una figlia PUÒ essere usata dove si aspetta il genitore"
  AutoElettrica IS-A Automobile  → true ✅
  Automobile IS-A AutoElettrica  → false ❌

🎯 Riepilogo: Tre Concetti in Tre Frasi

🧬 Ereditarietà

La classe figlia riceve gratis tutto quello che ha la classe genitore. Aggiungi solo le parti nuove. Si scrive con : NomeGenitore.

class AutoElettrica : Automobile
{ /* eredita tutto! */ }

🔁 Override

La figlia può riscrivere un metodo del genitore per adattarlo al suo caso. Il genitore marca il metodo virtual, la figlia usa override.

public override string Stampa()
{ return "versione mia!"; }

🎭 Polimorfismo

Puoi mettere tipi diversi nella stessa lista (di tipo base). Ogni oggetto risponde con il metodo giusto per il suo tipo.

List<Automobile> lista;
lista.Add(new AutoElettrica(...));
// funziona! ✅

Riepilogo: Cosa Hai Imparato

1️⃣ Ereditarietà

Le classi figlie ricevono gratis tutto il codice del genitore con : NomeClasse. Scrivi meno, riusa di più: niente più codice duplicato!

2️⃣ Override

Con virtual nel genitore e override nella figlia, ogni classe può personalizzare un metodo mantenendo la stessa firma. Puoi anche richiamare l'originale con base.Metodo().

3️⃣ Polimorfismo

Una sola List<Automobile> può contenere Automobile, AutoElettrica, AutoSportiva. Ogni oggetto risponde con il metodo giusto per il suo tipo, automaticamente.

🏆 Con le tre lezioni del Parco Auto hai imparato a progettare classi, rendere i dati permanenti e costruire gerarchie di classi: la base di qualsiasi applicazione seria.

Esercizi per Fare Pratica

🚗 Parco Auto con Ereditarietà: la sfida!

• Parti dal progetto Parco Auto delle lezioni precedenti
• Crea la classe figlia AutoElettrica con AutonomiaKm e PercentualeBatteria
• Crea la classe figlia AutoSportiva con CavalliVapore e HasTurbo
• Overrida Stampa() in entrambe per mostrare i dati specifici
• Usa una sola List<Automobile> per contenere tutti i tipi
• Nelle statistiche, mostra il conteggio separato per tipo (is)

📱 Livello Base: Device Elettronici con suggerimenti

💡 Suggerimento: Inizia con una classe base Device con marca, modello e prezzo

• Crea una classe base Device con: Marca, Modello, Prezzo (virtual per calcolo sconto)
• Crea classi derivate:
  • Smartphone con SistemaOperativo e MemoriaGB
  • Tablet con HasPenna e PolliciSchermo
  • Laptop con RamGB e Processore
• 🔍 Override del metodo Descrizione() in ogni classe figlia
• Aggiungi CalcolaPrezzoScontato() nella base e overridalo in Smartphone (sconto 10%) e Laptop (sconto 15%)
• Usa List<Device> per gestire tutti i dispositivi

💰 Livello Facile: App Pagamenti Digitali

🌍 Ispirato a Satispay, PayPal, carte di credito

• Classe base MetodoPagamento con: Intestatario, Saldo
• Classi derivate:
  • CartaCredito: Numero, Scadenza, CVV, Massimale
  • PayPal: Email, CashbackPercentuale
  • AppBancaria: IBAN, Banca, HasBiometricAuth
• Override di EseguiPagamento(decimal importo):
  • CartaCredito: verifica massimale
  • PayPal: applica cashback se importo > 50€
  • AppBancaria: richiede conferma biometrica
• 🎯 Extra: Override di CalcolaCostoTransazione() diverso per ogni metodo

🏠 Livello Intermedio: Casa Intelligente

🏷️ Dispositivi smart che comunicano come nella vita reale

• Classe base astratta SmartDevice con: Nome, Stanza, Stato, Consumo
• Interfaccia ITimerSupport per dispositivi con timer
• Classi derivate:
  • LampadinaSmart: ColoreRGB, Luminosità, ITimerSupport
  • Termostato: TemperaturaAttuale, TemperaturaTarget
  • TapparellaElettrica: PercentualeApertura
• Override obbligatorio di EseguiComando(string comando) per ogni dispositivo
• Gestisci tutto con List<SmartDevice> (polimorfismo)

🛵 Livello Avanzato: App di Delivery

📦 Ispirato a Glovo/JustEat - diversi tipi di consegna

• Classe base Ordine con: ID, Cliente, Indirizzo
• Interfacce:
  • IConsegnaFresco per catena del freddo
  • IConsegnaUrgente per consegne prioritarie
  • ITracciabile per tracking GPS
• Classi con interfacce multiple:
  • OrdineCibo: TipoCucina, Temperatura → IConsegnaFresco, IConsegnaUrgente
  • OrdineFarmacia: RicettaMedica → IConsegnaUrgente, ITracciabile
  • OrdineRegalo: Messaggio → ITracciabile
• Override di CalcolaCostoConsegna() con regole diverse per ogni tipo
• 🏆 Challenge: Sistema di priorità - ordini urgenti processati prima

🎮 Livello Esperto: Personaggi RPG

⚔️ Gerarchia complessa con override a catena

• Classe base astratta Personaggio con: Nome, Livello, PV, Mana
• Metodi virtual: Attacca(), Difendi(), UsaAbilita()
• Gerarchia a 3 livelli:
  • Liv1: Guerriero, Mago, Arciere
  • Liv2: Paladino (da Guerriero), Negromante (da Mago)
  • Liv3: CavaliereDrago (da Paladino)
• Override a catena con base.Attacca() per accumulare bonus
• Pattern Observer: quando un personaggio muore, tutti i nemici reagiscono

⭐ BONUS: Gestione Dipendenti Aziendale

Simula ruoli aziendali con diverse regole di stipendio - Confronto tra didattica e realtà

• Classe base Dipendente: Nome, Cognome, Matricola, Anzianità
• Classi derivate:
  • Impiegato: Livello, Straordinari (override stipendio con bonus)
  • Manager: BudgetTeam, Progetti (override bonus progetti)
  • Dirigente: StockOptions (override partecipazione utili)
  • Stagista: Tutor, Durata (override stipendio = rimborso spese)
• Interfaccia IConsulente per chi lavora su progetti esterni
• Override di ToString() per riepilogo completo

CONFRONTO: Come funziona nel programma vs Come funziona davvero

LE DIFFERENZE PIÙ IMPORTANTI

PROGRAMMA

Il nostro codice è fatto per imparare a programmare, non per fare paghe vere. Serve a capire:

• Override - Come le classi figlie possono cambiare i metodi del padre
• Polimorfismo - Lo stesso metodo (CalcolaStipendio()) funziona in modo diverso per ogni tipo
• Incapsulamento - I dati sono protetti ma accessibili alle classi che servono

Se dovessimo fare un programma vero per paghe, sarebbe molto più complicato: bisognerebbe distinguere mensile da annuale, calcolare tasse, contributi, e mille altre cose. Ma per imparare l'ereditarietà e il polimorfismo, così va benissimo!

Mappa dei Concetti negli Esercizi:

🖥️ Suggerimenti per l'Interfaccia Grafica:

• ComboBox per selezionare il tipo di oggetto da creare
• Campi che cambiano dinamicamente in base al tipo selezionato
• DataGridView con colonne specifiche usando polimorfismo
• Pannello statistiche che conta i tipi con 'is'
• Per RPG: barre della vita visive che si aggiornano

Prossimi Passi

Nelle Prossime Lezioni Imparerai:

• ⚡ Eventi Multipli: Un solo metodo per gestire tanti controlli
• 🎯 Il Parametro sender: Scoprire QUALE controllo ha generato l'evento
• ✅ Validazione in Tempo Reale: Controllare mentre l'utente digita
• 🎨 Feedback Visivo: Cambiare colori per guidare l'utente

🎯 Scriverai codice più elegante e programmi più user-friendly!

✅ Nelle tre lezioni del Parco Auto hai affrontato:

• 🏗️ Classi con campi private/protected e proprietà con validazione
• 📋 CRUD completo su List<Automobile>
• 💾 Salvataggio e lettura da file TXT e CSV
• 🔄 Ordinamento con Sort() e lambda
• 🧬 Ereditarietà con classi figlie (: NomeClasse)
• 🔁 Override di metodi (virtual + override + base)
• 🎭 Polimorfismo: una lista, tanti tipi, ogni oggetto risponde correttamente

📚 Teoria collegata (percorso C# – il linguaggio, esempi in console): Ereditarietà, polimorfismo, classi astratte e interfacce.