Qual è la differenza tra protocolli e classi quando si tratta di classi astratte?

Il protocollo definisce un contratto: un insieme di requisiti (metodi, proprietà, inizializzatori) che un tipo deve implementare per conformarsi a questo protocollo. I protocolli non hanno implementazione della maggior parte dei loro requisiti. Non è possibile creare istanze di un protocollo.

Una classe astratta in linguaggi diversi da Swift (ad esempio Java) rappresenta una classe che non può essere istanziata direttamente. Contiene sia metodi (o proprietà) implementati che metodi astratti che devono essere implementati nelle sue sottoclassi.

In Swift, non esiste il concetto di classi astratte nel senso tradizionale. La funzionalità delle classi astratte in Swift si ottiene tramite una combinazione di protocolli e classi.

Usando un protocollo, si può definire un'interfaccia e poi creare una classe normale che si conforma a questo protocollo e fornisce un'implementazione. Un'implementazione parziale del protocollo può essere fornita tramite estensioni (protocol extensions), ma questo non rende il protocollo una "classe astratta" nel senso puro.

	Protocollo (Swift)	Classe astratta (tradizionale)
Scopo	Definire un contratto (interfaccia)	Definire comportamento e struttura comuni con possibilità di implementazione parziale
Implementazione	Generalmente, non contiene implementazione (eccetto nelle estensioni)	Può contenere metodi implementati e astratti
Istanziazione	Non è possibile creare un'istanza del protocollo	Non è possibile creare un'istanza di una classe astratta direttamente
Ereditarietà	Conformità al protocollo (conformance)	Ereditarietà (inheritance)
Molteplicità	Il tipo può conformarsi a più protocolli	La classe può ereditare solo da una classe (nella maggior parte dei linguaggi)
In Swift	È la principale forma di astrazione	Non ha equivalente diretto, si imita con protocolli e classi

Esempio di imitazione di una classe astratta usando protocollo e classe in Swift:

Protocollo che definisce requisiti astratti:

// Protocollo, come contratto
protocol Drawable {
    func draw()
    var color: String { get set }
}

Classe che si conforma al protocollo e fornisce implementazioni:

// Classe che implementa il protocollo
class Circle: Drawable {
    var color: String

    init(color: String) {
        self.color = color
    }

    func draw() {
        print("Disegnare un cerchio di colore \(color)")
    }
}

Estensione per fornire un'implementazione parziale di default:

// Estensione per fornire un'implementazione di default (non rende il protocollo una classe astratta)
extension Drawable {
    func draw() {
        print("Inizio a disegnare qualcosa di colore \(color)")
    }
}

In questo modo, in Swift, i protocolli svolgono un ruolo chiave nel raggiungimento del polimorfismo e dell'astrazione, sostituendo il concetto di classi astratte di altri linguaggi.