Classi astratte

Benvenuto nella lezione successiva! In questa lezione imparerà a conoscere le classi astratte in C#, il loro scopo e le differenze rispetto alle interfacce. Cominciamo!

Che cos'è una classe astratta?

Una classe astratta è una classe che non può essere istanziata direttamente. Funge da schema per altre classi e può includere metodi astratti, che devono essere implementati dalle classi derivate.

Punto chiave: Le classi astratte possono includere sia metodi completamente implementati sia metodi dichiarati soltanto (metodi astratti).

Definire una classe astratta

Per definire una classe astratta, utilizzi la parola chiave abstract. Ecco un esempio:

Suggerimento: Utilizzi le classi astratte per fornire una base comune a classi correlate.

using System;

abstract class Animal {
    public abstract void Speak(); // Abstract method
    public void Sleep() { // Non-abstract method
        Console.WriteLine("The animal is sleeping.");
    }
}

Implementare una classe astratta

Le classi derivate devono implementare tutti i metodi astratti della classe astratta. Ecco un esempio:

Punto chiave: I metodi astratti definiscono un comportamento che deve essere implementato dalle classi derivate.

using System;

abstract class Animal {
    public abstract void Speak(); // Abstract method
    public void Sleep() {
        Console.WriteLine("The animal is sleeping.");
    }
}

class Dog : Animal {
    public override void Speak() {
        Console.WriteLine("The dog barks.");
    }
}

class Program {
    static void Main() {
        Dog myDog = new Dog();
        myDog.Speak(); // Outputs: The dog barks.
        myDog.Sleep(); // Outputs: The animal is sleeping.
    }
}

Classi astratte e interfacce a confronto

Sia le classi astratte sia le interfacce vengono utilizzate per l'astrazione, ma differiscono sotto diversi aspetti:

• Le classi astratte possono contenere metodi implementati e astratti, mentre le interfacce possono contenere solo metodi astratti (prima di C# 8.0).
• Le classi astratte possono includere campi, costruttori e modificatori di accesso per i membri.
• Una classe può ereditare da una sola classe astratta, ma può implementare più interfacce.

Suggerimento: Utilizzi le classi astratte per classi strettamente correlate e le interfacce per un'astrazione più ampia.

Quando utilizzare le classi astratte

Le classi astratte sono più adatte quando:

• Desidera definire una classe base comune con funzionalità condivise.
• Ha bisogno di includere metodi non astratti che forniscono un'implementazione predefinita.
• Lavora con classi correlate che condividono una gerarchia comune.

Esempio: Una classe astratta «Shape» per le classi «Circle» e «Rectangle».

Esercizio pratico

Crei una classe astratta Shape con un metodo astratto CalculateArea(). Implementi questo metodo nelle classi derivate Rectangle e Circle. Ecco un esempio:

using System;

abstract class Shape {
    public abstract double CalculateArea();
}

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

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

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

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

class Program {
    static void Main() {
        Shape rectangle = new Rectangle { Width = 5, Height = 4 };
        Shape circle = new Circle { Radius = 3 };

        Console.WriteLine("Rectangle Area: " + rectangle.CalculateArea());
        Console.WriteLine("Circle Area: " + circle.CalculateArea());
    }
}

Buone pratiche per le classi astratte

Ecco alcune buone pratiche:

• Utilizzi le classi astratte quando dispone di funzionalità condivise che devono essere ereditate.
• Mantenga la classe astratta focalizzata ed eviti di aggiungere membri non necessari.
• Combini le classi astratte con le interfacce quando appropriato.

Suggerimento: Le classi astratte dovrebbero fornire una base solida per le classi derivate.

Ottimo lavoro!

Congratulazioni! Ha imparato a utilizzare le classi astratte per definire comportamenti condivisi e garantire coerenza tra le classi derivate. Nella prossima lezione esploreremo i membri e i metodi statici in C#. Continui a scrivere codice!