Wat is het verschil tussen protocollen en klassen als het gaat om abstracte klassen?

Het protocol definieert een contract: een verzameling vereisten (methoden, eigenschappen, initialisatoren) die een type moet implementeren dat aan dit protocol voldoet. Protocols bevatten de meeste van hun vereisten niet in hun implementatie. Het is niet mogelijk om instanties van een protocol te maken.

Een abstracte klasse in talen anders dan Swift (bijvoorbeeld Java) vertegenwoordigt een klasse die niet direct geïnstantieerd kan worden. Het bevat zowel geïmplementeerde methoden (of eigenschappen) als abstracte methoden die in zijn subclasses geïmplementeerd moeten worden.

In Swift bestaat het concept van abstracte klassen niet in de traditionele zin. De functionaliteit van abstracte klassen in Swift wordt bereikt door een combinatie van protocols en klassen.

Door een protocol te gebruiken, kan een interface worden gedefinieerd, en vervolgens kan een gewone klasse worden gemaakt die aan dat protocol voldoet en een implementatie biedt. Een gedeeltelijke implementatie van het protocol kan worden geleverd via protocol extensies, maar dit maakt het protocol niet tot een "abstracte klasse" in de zuivere vorm.

	Protocol (Swift)	Abstracte klasse (traditioneel)
Doel	Definiëren van een contract (interface)	Definiëren van algemeen gedrag en structuur met mogelijkheid tot gedeeltelijke implementatie
Implementatie	Bevat meestal geen implementatie (behalve in extensies)	Kan zowel geïmplementeerde als abstracte methoden bevatten
Instantie	Kan geen instantie van het protocol worden gemaakt	Kan niet direct een instantie van een abstracte klasse maken
Erfelijkheid	Conformiteit aan het protocol (conformance)	Erfenis (inheritance)
Meervoudige erfenis	Het type kan aan meerdere protocollen voldoen	Een klasse kan slechts van één klasse erven (in de meeste talen)
In Swift	Is de belangrijkste vorm van abstractie	Heeft geen direct equivalent, wordt geïmiteerd met protocollen en klassen

Voorbeeld van het imiteren van een abstracte klasse met een protocol en klasse in Swift:

Protocol dat abstracte vereisten definieert:

// Protocol, als contract
protocol Drawable {
    func draw()
    var color: String { get set }
}

Klasse die aan het protocol voldoet en implementaties biedt:

// Klasse die het protocol implementeert
class Circle: Drawable {
    var color: String

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

    func draw() {
        print("Tekent een cirkel met kleur \(color)")
    }
}

Uitbreiding om een gedeeltelijke standaardimplementatie te bieden:

// Uitbreiding om een standaardimplementatie te bieden (maakt het protocol niet tot een abstracte klasse)
extension Drawable {
    func draw() {
        print("Begin met het tekenen van iets met kleur \(color)")
    }
}

Op deze manier spelen protocollen een sleutelrol in Swift bij het bereiken van polymorfisme en abstractie, en vervangen ze het concept van abstracte klassen uit andere talen.