Classi Astratte in [C#] con esempi

Nella programmazione orientata agli oggetti, le classi astratte svolgono un ruolo cruciale nella definizione di comportamenti e caratteristiche comuni per le classi derivate.

C# fornisce un potente supporto per le classi astratte, consentendo agli sviluppatori di creare architetture di codice robuste e flessibili.

In questo articolo vediamo il concetto di classi astratte in C# ed i suoi vantaggi e poi vediamo qualche esempio pratico per iniziare a padroneggiarne l’utilizzo.

Cos’è una classe astratta?

Una classe astratta in C# è una classe di cui non è possibile creare direttamente un’istanza : “serve come modello per altre classi”.

Le classi astratte possono contenere metodi astratti (metodi senza implementazione) e metodi non astratti (metodi con implementazione).

Le classi derivate devono implementare i metodi astratti definiti nella classe astratta.

Caratteristiche principali delle classi astratte

• Non può essere istanziato: non è possibile creare un oggetto di una classe astratta.
• Può contenere metodi astratti: questi metodi devono essere implementati da classi derivate.
• Può contenere metodi non astratti: questi metodi possono essere ereditati da classi derivate.
• Può contenere campi e proprietà: le classi astratte possono definire campi e proprietà che possono essere condivisi dalle classi derivate.

Quando utilizzare le classi astratte?

• Funzionalità condivisa: quando si dispone di funzionalità comuni che devono essere condivise tra più classi derivate.
• Classe base con comportamento predefinito: quando si desidera fornire a una classe base un comportamento predefinito che può essere sovrascritto dalle classi derivate.
• Implementazione parziale: quando è necessaria una classe base che definisca alcuni metodi senza implementazione, lasciando alle classi derivate il compito di fornire l’implementazione.

Esempio di classe astratta in C#

Vediamo un esempio per comprendere come funzionano le classi astratte in C#.

Esempio 1. Definire la classe astratta.

Per prima cosa definiamo una classe astratta Shape con un metodo astratto CalculateArea e un metodo non astratto Display.

 

public abstract class Shape
{
    public string Color { get; set; }

    // Metodo astratto (non ha una implementazione)
    public abstract double CalculateArea();

    // Metodo NON astratto (HA una implementazione)
    public void Display()
    {
        Console.WriteLine($"The color of the shape is {Color}");
    }
}

Esempio 2. Creare classi derivate.

Successivamente, creiamo le classi derivate Circle e Rectangle che ereditano dalla classe astratta Shape e implementano il metodo astratto CalculateArea.

public class Circle : Shape
{
    public double Radius { get; set; }

    public override double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public override double CalculateArea()
    {
        return Width * Height;
    }
}

Esempio  3. Utilizzare le classi derivate.

Infine, utilizziamo le classi derivate per creare oggetti e chiamare i loro metodi.

class Program
{
    static void Main()
    {
        Circle circle = new Circle { Color = "Red", Radius = 5 };
        Rectangle rectangle = new Rectangle { Color = "Blue", Width = 4, Height = 6        };

        circle.Display();
        Console.WriteLine($"The area of the circle is {circle.CalculateArea()}");

        rectangle.Display();
        Console.WriteLine($"The area of the rectangle is {rectangle.CalculateArea()}");
    }
}

Vantaggi delle classi astratte

• Riutilizzabilità del codice: le classi astratte consentono di definire funzionalità comuni in un unico posto, promuovendo il riutilizzo del codice.
• Estendibilità: le classi derivate possono estendere la classe astratta aggiungendo nuove funzionalità o sovrascrivendo quelle esistenti.
• Manutenibilità: centralizzare la logica comune in una classe astratta semplifica la manutenzione e l’aggiornamento del codice.

Classe astratta (abstract) e interfaccia (interface)

Sebbene le classi e le interfacce astratte in C# possano entrambe definire contratti per classi derivate, presentano alcune differenze fondamentali.

• Classi astratte
  • Può contenere metodi astratti e non astratti.
  • Può avere campi, proprietà e costruttori.
  • Supporta i modificatori di accesso per metodi e proprietà.
  • Consente l’ereditarietà singola (una classe può ereditare solo una classe astratta).
• Interfacce
  • Può contenere solo firme di metodi (fino a C# 8,0, che ha introdotto implementazioni predefinite).
  • Non può avere campi o costruttori.
  • Tutti i membri sono implicitamente pubblici.
  • Supporta l’ereditarietà multipla (una classe può implementare più interfacce).

Conclusione

Le classi astratte sono una funzionalità potente di C# che consente agli sviluppatori di creare architetture di codice flessibili e gestibili.

Definendo funzionalità comuni nelle classi astratte e richiedendo alle classi derivate di implementare metodi specifici, si può creare una base di codice solida ed estensibile.

Comprendere e padroneggiare le classi astratte è essenziale per qualsiasi sviluppatore C# che desideri creare applicazioni scalabili e gestibili.

Riferimenti Utili

• C# 12 & .NET 8, Guida completa per sviluppatori e principianti: Programmazione ad oggetti, machine learning, creazione di siti e applicazioni, con oltre 200 esercizi risolti
• C#: Algoritmi e Programmi
• Esplorando ChatGPT: Un’introduzione alla conversazione con l’intelligenza artificiale