• 12 heures
  • Difficile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 12/12/2019

Découvrez les protocoles

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

C'est parti ! Nous allons parler des protocoles !

Une histoire d'héritage...

Pour découvrir les protocoles, je vous ai concocté un petit Playground !

Dans ce Playground, vous trouverez un code assez simple : une classe Animal et deux sous-classes Bird et Dog.

La classe Animal a deux méthodes et une propriété, comme suit :

class Animal {
    func makeSound() {}
    func move() {}

    var description = ""
}

Mais les méthodes sont vides ! Elles ne servent à rien ?

Très bonne question ! En effet, les méthodes sont vides, car je ne peux pas prédire le son que va faire un animal sans savoir précisément de quel animal je parle. De la même manière, un oiseau ne se déplace pas de la même manière qu'un cheval. Donc je ne peux pas remplir la méthode move.

Autrement dit, la classe Animal est trop générique. De ce fait, elle ne sert à rien, à part mettre en commun deux méthodes et une propriété que les sous-classes vont pouvoir implémenter.

En programmation, on n’aime pas trop ce qui ne sert à rien ! En biologie, non plus d'ailleurs... mais c'est un autre débat ! On va donc supprimer cette classe Animal !

Mais attends ! Elle permet quand même aux sous-classes d'hériter de ces méthodes et de cette propriété !

Je sais, mais faites-moi confiance, supprimez cette classe ! On va faire cela différemment... Avec un protocole !

Les protocoles à la rescousse !

En plus de beaucoup d'autres choses, les protocoles sont très pratiques dans notre situation. Et pour comprendre pourquoi, il faut comprendre ce qu'est un protocole !

Définition

Un protocole, c'est une liste d'exigences.

Oui, je sais, dit comme ça, cela ne fait pas rêver... Mais vous allez voir, c'est puissant ! Rentrons dans le vif du sujet !

Syntaxe

Pour déclarer un protocole, on utilise le mot-clé protocol suivi d'un nom et d'accolades :

protocol Animal {

}

Oui, cela ressemble à une classe. Et la ressemblance ne s'arrête pas là !

Méthodes

On peut ajouter des méthodes à un protocole.

protocol Animal {
    func makeSound()
    func move()
}

Hé, mais attends ! Tu as oublié l'implémentation des méthodes.

Eh oui, comme je l'ai dit, un protocole est une liste d'exigences. Ensuite, on va demander à une classe de se conformer à ces exigences.

Propriétés

Un protocole peut aussi contenir des propriétés. Mais, comme pour les méthodes, le protocole va seulement définir si cette propriété peut être modifiée ou non. Il ne va pas lui donner de valeur :

protocol Animal {
    func makeSound()
    func move()

    var description: String { get set }
}

Je définis ici dans mon protocole une propriété description de type String. Jusque là rien de nouveau. Ensuite, j'ajoute entre accolades les mots get et set. Cela signifie que cette propriété pourra être modifiée.

Je veux bien toute cette histoire de protocole, mais à quoi cela sert-il vraiment ?

Je comprends que ce soit un peu flou pour le moment, mais on y vient !

Se conformer à un protocole

Je le répète : un protocole, c'est une liste d'exigences. Autrement dit, un protocole, c'est une entité qui déclare :

Si tu veux être ça, il faut que tu fasses ça.

Par exemple, dans notre cas :

Si tu veux être un Animal, il faut que tu saches faire les choses suivantes :

  • makeSound

  • move

Et donner une valeur à la propriété suivante :

  • description

Nous avons dans notre Playground deux classes qui voudraient bien être des animaux : Dog et Bird.

class Dog {
    var race = ""

    func fetch() {
        print("Je vais chercher la balle...")
    }
 }

class Bird {
    var color = ""
}

Pour que Dog et Bird soient des animaux, ils doivent se conformer au protocole. Cela se fait en deux étapes :

  1. Adopter le protocole

  2. Répondre à ses exigences

Commençons par la première étape :

Adopter le protocole

Pour adopter un protocole, la syntaxe est exactement la même que pour l'héritage :

class Dog: Animal { (...) }

class Bird: Animal { (...) }

On ajoute : puis le nom du protocole (Animal) après la déclaration de la classe.

À ce moment-là, vous devriez avoir une erreur dans votre Playground :

Type 'Dog' does not conform to protocol 'Animal'
Type 'Dog' does not conform to protocol 'Animal'

Cette erreur signifie simplement que nous avons adopté le protocole, mais que nous n'avons pas encore répondu à ses exigences. C'est normal, c'est notre deuxième étape !

Répondre à ses exigences

Pour répondre aux exigences d'un protocole, il suffit de rajouter l'implémentation des méthodes du protocole et de donner une valeur à ses propriétés, comme ceci :

class Dog: Animal {
    var race = ""

    func fetch() {
        print("Je vais chercher la balle...")
    }

    // On répond aux exigences du protocole
    var description = ""

    func move() {
        print("Je cours !")
    }

    func makeSound() {
        print("Wouf !")
    }
}

class Bird: Animal {
    var color = ""

    // On répond aux exigences du protocole
    var description = ""

    func move() {
        print("Je vole !")
    }

    func makeSound() {
        print("Piou Piou")
    }
}

On a simplement rajouté les méthodes et leurs implémentations, et on a donné une valeur à la propriété description. Et ça y est, nos classes se conforment au protocole Animal.

On a remplacé notre classe inutile et trop générique par un protocole qui remplit le même rôle !

En résumé

  • Un protocole est une liste d'exigences. Ces exigences peuvent être des méthodes ou des propriétés.

  • Souvenez-vous de la phrase suivante. Un protocole est une entité qui déclare : "Si tu veux être ça, il faut que tu fasses ça !"

  • Un protocole se déclare avec la syntaxe suivante :

protocol NomDuProtocole {
    func maMethode()
    func maMethodeAvecParametresEtValeurDeRetour(param1: Type, Param2: Type) -> Type

    var maPropriete: Type { get set }
    var maProprieteEnLectureSeule: Type { get }
}
  • Une classe peut se conformer à un protocole en :

    1. Adoptant le protocole

    2. Répondant à ses exigences

// 1. On adopte le protocole
class MaClasse: MonProtocole {
    // 2. On répond à ces exigences
    func laMethodeDeMonProtocole() {
        // Implémentation de la méthode définie par le protocole
    }
}

Ceci constitue un premier tour d'horizon rapide des protocoles. Avant de les mettre en pratique dans notre application, nous allons asseoir un peu plus votre compréhension du sujet ! Cela se passe au prochain chapitre !

Exemple de certificat de réussite
Exemple de certificat de réussite