virtual/override/sealed e classi astratte
Apprenda i metodi virtual, l'override, la sigillatura degli override e le classi astratte; osservi come i riferimenti alla classe base eseguono il dispatch verso le implementazioni derivate.
virtual/override/sealed e classi astratte è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 3 lezioni in totale.
Basi dell'ereditarietà
Obiettivo: Riutilizzare e personalizzare il comportamento tramite l'ereditarietà.
- virtual nella classe base
- override nella classe derivata
- sealed override per impedire ulteriori modifiche
- La classe abstract definisce un contratto e fornisce codice condiviso
virtual e override
virtual abilita l'override. Le chiamate tramite un riferimento alla classe base usano l'override della classe derivata (dispatch dinamico).
using System;
// Base method is virtual so derived classes can customize it
public class Shape
{
public virtual double Area()
{
return 0.0; // default
}
}
public class Rectangle : Shape
{
public int Width { get; private set; }
public int Height { get; private set; }
public Rectangle(int w, int h)
{
Width = w; Height = h;
}
public override double Area()
{
return Width * Height;
}
}
public class Program
{
public static void Main(string[] args)
{
Shape s = new Shape();
Shape r = new Rectangle(3, 4); // base reference
Console.WriteLine("Shape area = " + s.Area());
Console.WriteLine("Rectangle area = " + r.Area()); // calls Rectangle.Area()
}
}
sealed override
Usi sealed override per bloccare un metodo a un determinato livello della gerarchia.
using System;
public class BaseLogger
{
public virtual string Prefix()
{
return "[LOG]";
}
}
public class ConsoleLogger : BaseLogger
{
public sealed override string Prefix()
{
return "[CONSOLE]";
}
}
// Further derived class cannot override Prefix again:
// public class FancyLogger : ConsoleLogger
// {
// public override string Prefix() { return "[FANCY]"; } // compile error
// }
public class Program
{
public static void Main(string[] args)
{
ConsoleLogger log = new ConsoleLogger();
Console.WriteLine(log.Prefix() + " Ready");
}
}
Classi abstract
Le classi abstract definiscono i membri obbligatori (abstract) e possono anche fornire codice condiviso.
using System;
// Abstract class: cannot be instantiated; must implement abstract members
public abstract class Animal
{
public abstract string Speak(); // no body here
public string Info()
{
return "Animal says: " + Speak(); // shared code uses the abstract member
}
}
public class Dog : Animal
{
public override string Speak()
{
return "Woof";
}
}
public class Program
{
public static void Main(string[] args)
{
// Animal a = new Animal(); // compile error: abstract
Animal d = new Dog();
Console.WriteLine(d.Info()); // calls Dog.Speak()
}
}
virtual e abstract a confronto
Scelta:
- virtual: fornisce un corpo predefinito che i tipi derivati possono sovrascrivere.
- abstract: non ha un corpo; i tipi derivati devono implementarlo.
- sealed override: impedisce ulteriori override una volta definito il comportamento.
Chiamate polimorfiche
Il polimorfismo consente a un metodo di accettare il tipo base e di chiamare i membri sovrascritti sulle istanze derivate.
using System;
public class Notifier
{
public virtual string Channel() { return "Base"; }
}
public class EmailNotifier : Notifier
{
public override string Channel() { return "Email"; }
}
public class SmsNotifier : Notifier
{
public override string Channel() { return "SMS"; }
}
public class Program
{
// Works with any Notifier (polymorphism)
static void Send(Notifier n, string msg)
{
Console.WriteLine("[" + n.Channel() + "] " + msg);
}
public static void Main(string[] args)
{
Send(new EmailNotifier(), "Hello");
Send(new SmsNotifier(), "Hi");
}
}
Regola di virtual, override e sealed
Riepilogo
Riepilogo: Contrassegni i metodi della classe base con virtual, li sovrascriva nei tipi derivati e usi sealed override per bloccare il comportamento. Usi le classi abstract per richiedere implementazioni condividendo al contempo il codice comune.
Domande Frequenti
La lezione «virtual/override/sealed e classi astratte» è gratuita?
Sì — il testo completo di «virtual/override/sealed e classi astratte» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 3 lezioni in totale.
Cosa imparerò in «virtual/override/sealed e classi astratte»?
Apprenda i metodi virtual, l'override, la sigillatura degli override e le classi astratte; osservi come i riferimenti alla classe base eseguono il dispatch verso le implementazioni derivate. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare C# Academy?
Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.
Quanto tempo richiede la lezione «virtual/override/sealed e classi astratte»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione C# Academy?
Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- virtual/override/sealed e classi astratte
- Interfacce (introduzione) e implementazione di più interfacce
- Polimorfismo e dispatch dinamico