Quelle est la différence entre protocoles et classes lorsqu'il s'agit de classes abstraites?

Le protocole définit un contrat : un ensemble d’exigences (méthodes, propriétés, initialisateurs) qu’un type doit implémenter s’il se conforme à ce protocole. Les protocoles n’ont pas d’implémentation de la majorité de leurs exigences. Il n’est pas possible de créer des instances d’un protocole.

Une classe abstraite dans des langages autres que Swift (par exemple, Java) représente une classe qui ne peut pas être instanciée directement. Elle contient à la fois des méthodes (ou propriétés) implémentées et des méthodes abstraites qui doivent être implémentées dans ses sous-classes.

En Swift, il n’existe pas de concept de classes abstraites dans leur sens traditionnel. La fonctionnalité des classes abstraites en Swift est réalisée par une combinaison de protocoles et de classes.

En utilisant un protocole, on peut définir une interface, puis créer une classe normale qui se conforme à ce protocole et fournit une implémentation. Une implémentation partielle du protocole peut être fournie via des extensions (protocol extensions), mais cela ne transforme pas le protocole en une "classe abstraite" au sens strict.

	Protocole (Swift)	Classe abstraite (traditionnelle)
Objectif	Définir un contrat (interface)	Définir un comportement et une structure communs avec une implémentation partielle
Implémentation	En général, ne contient pas d’implémentation (sauf dans les extensions)	Peut contenir des méthodes implémentées et abstraites
Instanciation	Impossible de créer une instance du protocole	Impossible de créer une instance d’une classe abstraite directement
Héritage	Conformité au protocole (conformance)	Héritage (inheritance)
Multiplicité	Le type peut se conformer à plusieurs protocoles	La classe ne peut hériter que d’une seule classe (dans la plupart des langages)
En Swift	C’est la principale forme d’abstraction	Il n’y a pas d’équivalent direct, cela s’imite avec des protocoles et des classes

Exemple d’imitation d’une classe abstraite avec un protocole et une classe en Swift :

Protocole définissant des exigences abstraites :

// Protocole, comme contrat
protocol Drawable {
    func draw()
    var color: String { get set }
}

Classe conforme au protocole et fournissant des implémentations :

// Classe implémentant le protocole
class Circle: Drawable {
    var color: String

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

    func draw() {
        print("Dessiner un cercle de couleur \(color)")
    }
}

Extension pour fournir une implémentation partielle par défaut :

// Extension pour fournir une implémentation par défaut (ne rend pas le protocole une classe abstraite)
extension Drawable {
    func draw() {
        print("Commencer à dessiner quelque chose de couleur \(color)")
    }
}

Ainsi, en Swift, les protocoles jouent un rôle clé dans la réalisation du polymorphisme et de l’abstraction, en remplaçant la notion de classes abstraites d’autres langages.