Care este diferența dintre protocoale și clase atunci când vine vorba de clase abstracte?

Protocolul definește un contract: un set de cerințe (metode, proprietăți, constructori) pe care trebuie să le implementeze un tip care respectă acest protocol. Protocoalele nu conțin implementarea majorității cerințelor lor. Nu se pot crea instanțe ale unui protocol.

O clasă abstractă în limbaje diferite de Swift (de exemplu, Java) reprezintă o clasă care nu poate fi instanțiată direct. Conține atât metode (sau proprietăți) implementate, cât și metode abstracte care trebuie implementate în subclasele sale.

În Swift, nu există conceptul de clase abstracte în sensul lor tradițional. Funcționalitatea claselor abstracte în Swift se realizează printr-o combinație de protocoale și clase.

Folosind un protocol, se poate defini o interfață, apoi se poate crea o clasă obișnuită care respectă acest protocol și oferă o implementare. O implementare parțială a protocolului poate fi furnizată prin extensii (protocol extensions), dar acest lucru nu face ca protocolul să fie o "clasă abstractă" în sensul pur.

	Protocol (Swift)	Clasă abstractă (tradițional)
Scop	Definirea unui contract (interfață)	Definirea comportamentului și structurii comune cu posibilitatea de implementare parțială
Implementare	În general, nu conține implementare (cu excepția extensiilor)	Poate conține metode implementate și abstracte
Instanțiere	Nu se poate crea o instanță a protocolului	Nu se poate crea o instanță a unei clase abstracte direct
Moștenire	Conformarea la protocol (conformance)	Moștenire (inheritance)
Multiplicitate	Tipul poate fi conform mai multor protocoale	O clasă poate moșteni doar de la o singură clasă (în majoritatea limbajelor)
În Swift	Este forma principală de abstractizare	Nu are un echivalent direct, este imitat cu protocoale și clase

Exemplu de imitație a unei clase abstracte cu ajutorul unui protocol și a unei clase în Swift:

Protocol care definește cerințe abstracte:

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

Clasă care respectă protocolul și oferă implementări:

// Clasă care implementează protocolul
class Circle: Drawable {
    var color: String

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

    func draw() {
        print("Desenează un cerc de culoare \(color)")
    }
}

Extensie pentru a oferi o implementare parțială implicită:

// Extensie pentru a oferi o implementare implicită (nu face ca protocolul să fie o clasă abstractă)
extension Drawable {
    func draw() {
        print("Începem să desenăm ceva de culoare \(color)")
    }
}

Astfel, în Swift, protocoalele joacă un rol cheie în atingerea polimorfismului și abstractizării, înlocuind conceptul de clase abstracte din alte limbaje.