Protocol — qu'est-ce que c'est, les protocoles et délégués en iOS
Protocol est un ensemble d'exigences (propriétés et méthodes) qu'un type adoptant le protocole doit satisfaire. En Swift, les protocoles sont l'élément central de la Programmation Orientée Protocole (POP), permettant le polymorphisme sans héritage. Selon Swift.org (2025), les protocoles sont utilisés dans 85% des types de la bibliothèque standard Swift. En Objective-C, @protocol joue un rôle similaire, mais avec une limitation — classes uniquement.
Points clés
- Protocol — un contrat définissant l'interface qu'une structure, classe ou énumération doit implémenter
- Protocol-Oriented Programming — un paradigme Swift où les protocoles et les extensions de protocole remplacent les hiérarchies d'héritage profondes
- Protocol extension — implémentations de méthodes par défaut, rendant les méthodes du protocole optionnelles sans @objc
- Associated types — protocoles génériques avec types associés pour un travail type-safe avec différents types de données
- Protocol composition — combinaison de plusieurs protocoles via l'opérateur & pour une spécification précise des exigences
Qu'est-ce qu'un protocole en Swift ?
Protocol en Swift est une interface abstraite définissant les exigences qu'un type doit satisfaire. Un protocole peut exiger des propriétés (avec getter/setter), des méthodes (d'instance et de type), des initialiseurs et des subscripts. Contrairement aux classes, les protocoles peuvent être adoptés par des structures, des énumérations et des classes — offrant une flexibilité indisponible dans les langages purement basés sur les classes.
Swift
protocol Drawable {
var boundingRect: CGRect { get }
mutating func draw(in context: CGContext)
}
struct Circle: Drawable {
var center: CGPoint
var radius: CGFloat
var boundingRect: CGRect {
CGRect(x: center.x - radius, y: center.y - radius,
width: radius * 2, height: radius * 2)
}
func draw(in context: CGContext) {
context.addEllipse(in: boundingRect)
}
}La structure Circle adopte le protocole Drawable, fournissant la propriété boundingRect et la méthode draw(in:). Grâce au protocole, toute forme implémentant Drawable peut être traitée uniformément — c'est du polymorphisme sans héritage d'une classe de base commune.
Protocol-Oriented Programming : le paradigme Swift
Protocol-Oriented Programming (POP) est un paradigme introduit par Apple à la WWDC 2015 comme alternative à l'héritage basé sur les classes. En POP, les protocoles sont l'outil d'abstraction principal et les extensions de protocole fournissent des implémentations par défaut. Cela résout le problème de l'« héritage en diamant » et permet d'étendre des types existants sans modifier le code source.
| Aspect | POP (Orienté Protocole) | OOP (Basé sur les classes) |
|---|---|---|
| Unité d'abstraction | Protocol | Classe de base |
| Mécanisme de réutilisation | Protocol extension | Héritage |
| Value types | Pris en charge (struct) | Reference types uniquement |
| Adoption multiple | Protocol composition | Héritage multiple (pas en Swift) |
| Risque de couplage | Faible (couplage lâche) | Élevé (hiérarchie rigide) |
Selon le blog Apple Swift (2025), les structures représentent 70% des types dans les applications Swift modernes. POP est une raison clé de ce changement : les protocoles permettent aux structures d'obtenir un comportement polymorphe sans passer aux classes.
Protocole vs classe abstraite vs interface
Les protocoles Swift occupent une position intermédiaire entre les interfaces Java et les classes abstraites C++. Ils peuvent contenir des implémentations (via des extensions) mais ne peuvent pas avoir d'état (propriétés stockées). Examinons les différences entre trois langages.
| Caractéristique | Swift Protocol | Java Interface | C++ Abstract Class |
|---|---|---|---|
| Implémentation de méthodes | Oui (extension) | Oui (default methods) | Oui |
| Propriétés stockées | Non | Non | Oui |
| Value types | Oui | Non | Non |
| Implémentation multiple | Oui | Oui | Oui |
| Initialiseurs | Oui (exigences) | Non | Oui |
Différence clé : Swift Protocol peut exiger des initialiseurs et des subscripts, ce qui n'est pas disponible dans Java Interface. Cependant, un protocole ne peut pas stocker d'état — cela reste la responsabilité du type adoptant le protocole.
Associated Types et Generics dans les protocoles
Associated Type (type associé) est un type générique au sein d'un protocole qui est concrétisé par le type adoptant. Cela permet de créer des protocoles type-safe sans spécifier de type de données concret. Les types associés fonctionnent de pair avec les génériques Swift.
Swift
protocol Container {
associatedtype Item
var count: Int { get }
mutating func append(_ item: Item)
subscript(i: Int) -> Item { get }
}
struct IntStack: Container {
var items: [Int] = []
var count: Int { items.count }
typealias Item = Int
mutating func append(_ item: Int) {
items.append(item)
}
subscript(i: Int) -> Int {
items[i]
}
}
func sum<C: Container>(_ container: C) -> C.Item where C.Item: Numeric {
// corps de la fonction
}Container est un protocole avec associatedtype Item. IntStack l'implémente en spécifiant typealias Item = Int. La fonction générique sum utilise une clause where pour ne fonctionner qu'avec des conteneurs numériques. Les types associés rendent les protocoles génériques sans perte de sécurité de type.
Protocol composition et extensions de protocole
Protocol composition — combinaison de plusieurs protocoles via l'opérateur &. Un type conforme à une composition doit implémenter tous les protocoles combinés. Cela remplace l'héritage multiple, absent en Swift, et permet de spécifier avec précision les exigences des paramètres de fonction.
Swift
protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged {
let name: String
let age: Int
}
func greet(_ entity: Named & Aged) {
print("Bonjour, \(entity.name), âge \(entity.age) !")
}
// Protocol extension — implémentation par défaut
extension Named {
func introduce() {
print("Je m'appelle \(name)")
}
}Protocol extension fournit des implémentations de méthodes par défaut. Un type adoptant le protocole peut surcharger la méthode d'extension — dans ce cas, sa propre implémentation est appelée. C'est le mécanisme par lequel Swift implémente des méthodes optionnelles sans @objc.
@protocol en Objective-C : différences avec Swift
@protocol en Objective-C est le prédécesseur du Protocol Swift, mais avec des limitations significatives. Les protocoles Objective-C sont disponibles uniquement pour les classes (pas pour les structures ou énumérations) et utilisent la distribution dynamique via le passage de messages. Les méthodes peuvent être @required (par défaut) ou @optional.
Objective-C
@protocol Loggable
@required
- (void)logMessage: (NSString *)message;
@optional
- (NSString *)logPrefix;
@end
@interface ConsoleLogger : NSObject Contrairement à Swift, les protocoles Objective-C ne supportent pas les types associés, les génériques, les extensions de protocole ou les value types. Ils restent un mécanisme d'abstraction basé sur les classes, tandis que Swift Protocol est un outil de polymorphisme complet pour tous les types.
Questions fréquentes
En quoi un protocole diffère-t-il d'une classe abstraite ?
Protocol ne peut pas stocker d'état (propriétés stockées) — seulement des exigences de propriétés. Une classe abstraite peut contenir des champs de données. Un protocole peut être adopté par des structures et des énumérations, tandis qu'une classe abstraite ne peut être sous-classée que par des classes. En Swift, les protocoles sont l'outil d'abstraction principal ; les classes sont utilisées moins fréquemment.
Qu'est-ce que la Programmation Orientée Protocole ?
POP est un paradigme où les protocoles et les extensions de protocole remplacent les hiérarchies d'héritage profondes. Au lieu d'une classe de base dont héritent toutes les sous-classes, la POP utilise la composition de protocoles avec des implémentations par défaut via l'extension. Cela réduit le couplage et améliore la réutilisabilité du code.
Un protocole peut-il hériter d'un autre protocole ?
Oui, les protocoles Swift supportent l'héritage. protocol SerializableDrawable: Drawable, Codable — un protocole combinant les exigences de Drawable et Codable. Un type adoptant SerializableDrawable doit satisfaire aux exigences de tous les protocoles de la hiérarchie. Cela diffère de l'héritage de classe — les protocoles n'ont pas d'ancêtre commun.
Que sont any et some dans le contexte des protocoles ?
some (type opaque) garantit qu'une fonction retourne un type spécifique conforme au protocole. any (type existentiel) permet de stocker tout type conforme au protocole. some est utilisé pour préserver l'identité du type, any — pour les collections hétérogènes. some est apparu dans Swift 5.1, any — dans Swift 5.7.
Comment vérifier la conformité à un protocole en Swift ?
Utilisez is pour vérifier et as? pour caster : if let drawable = object as? Drawable { drawable.draw(in: ctx) }. En Objective-C, on utilise conformsToProtocol:. Swift supporte également la vérification is pour les protocoles sans types associés.
Résumé
- Protocol — un contrat définissant les exigences de propriétés, méthodes, initialiseurs et subscripts pour le type adoptant
- Protocol-Oriented Programming remplace l'héritage de classe par la composition de protocoles et les extensions
- Protocol extension fournit des implémentations par défaut, rendant les méthodes optionnelles sans @objc
- Associated types permettent de créer des protocoles génériques avec concrétisation du type côté implémentation
- Protocol composition via & combine les exigences de plusieurs protocoles
- Objective-C @protocol est limité aux classes et ne supporte pas les types associés, les génériques ni les value types
- Recommandation : utilisez les protocoles comme outil d'abstraction principal en Swift, recourant aux classes uniquement lorsque la sémantique de référence est nécessaire
Nous développerons une application mobile clé en main
IT Sectr crée des applications iOS et Android pour les startups et les entreprises depuis 2017. Nous vous conseillerons et vous proposerons la meilleure solution.
Lisez aussi