Adopter et conforme une classe, la structure, ou une énumération à un protocole rapide

Tous les principaux types (classes, structures et énumérations) peut adopter des protocoles. Vous pouvez créer un protocole qui est adoptée par l'un d'eux, ou vous pouvez spécifier qu'il est adoptable seulement par une classe. Voici des exemples de conforme au protocole de base (MyProtocol

Sommaire

).

Conformément une classe à un protocole

Beaucoup de protocoles utilisés dans les cadres Cocoa et Cocoa Touch sont adoptées par les classes dans les cadres en partie parce que dans l'objectif # 8208-C, les protocoles sont généralement utilisés seulement avec les classes. Vous serez en mesure d'aller au-delà des classes, mais, lorsque vous écrivez du code qui utilise les cadres écriture, vous aurez souvent besoin d'écrire du code qui est conforme aux protocoles pour les classes.

Voici quelques lignes directrices à se conformer aux protocoles des classes:

  • Vous spécifiez qu'une classe adopte un protocole dans sa déclaration, comme dans l'exemple suivant:

    classe MyClass: MyProtocol {
  • Si vous adoptez plus d'un protocole, les séparer par des virgules, comme dans l'exemple suivant:

    MyClass de classe: MyProtocol, MyProtocol2 {
  • Si votre classe est une sous-classe d'une autre classe, sa superclasse apparaît en premier dans la liste, comme dans l'exemple suivant:

    class MyClass: MySuperclass, MyProtocol2

    Rappelez-vous que Swift ne supporte pas l'héritage multiple, donc il ne peut être l'une superclasse (ou aucun). Vous pouvez ajouter des protocoles à la liste si nécessaire.

Si votre classe est une sous-classe d'une classe qui adopte un protocole, vous devez vous conformer à ce protocole dans votre propre classe, sauf si la superclasse est déjà conforme à elle. Vous ne spécifiez pas ce protocole adopté hérité dans votre propre déclaration.

Après avoir indiqué que votre classe adopte un protocole, vous devez maintenant mettre en œuvre toutes les propriétés et méthodes nécessaires. (Il est possible de signifier que certaines méthodes et propriétés sont facultatives, mais le réglage par défaut est qu'ils sont tous tenus.)

Voici un exemple d'une classe qui est conforme à un protocole. Noter que myFunc qui est requis par le protocole, tandis que INTVAL est un établissement de classe qui n'a rien à voir avec le protocole:

classe MyClass: MyProtocol {fonc myFunc () -> Chaîne {return "Protocole 1"} var INTVAL: Int = 0}

Vous pouvez créer une variable (avec var) Ou constante (avec laisser) Qui contient une instance de la classe avec ce code:

var myClass: MyClass = MyClass ()

Vous pouvez ensuite accéder à la classe de INTVAL propriété d'instance ainsi que la méthode requise par le protocole myFunc:

myClass.intVal 25myClass.myFunc = ()

À ce stade, vous ne faites pas de distinction entre les méthodes et les propriétés requises par le protocole et ceux qui sont tout simplement partie de la classe.

Une structure conforme à un protocole


Une structure (struct) Adopte un protocole de la même manière comme une classe fait - avec le code suivant:

struct MyStruct: MyProtocol {fonc myFunc () -> Chaîne {return "Protocole 2"} var INTVAL: Int = 0var Un = 1VAR Deux = 2}

Vous pouvez déclarer une variable qui utilise la structure. Vous pouvez ensuite accéder aux membres de la structure ainsi que la fonction qui est requis par le protocole:

var myStruct: MyStruct = MyStruct () myStruct.intVal = 15myStruct.myFunc ()

Conformément une énumération à un protocole

Énumérations suivent la même conception de base. Vous pouvez déclarer une énumération qui adopte un protocole aux côtés de ses propres données, comme dans le code suivant:

énumération MyEnum: MyProtocol {fonc myFunc () -> Chaîne {return "Protocole 3"} cas Onecase Twocase Threecase Quatre}

Ensuite, utilisez l'énumération avec une variable dans votre code:

var MyEnum: MyEnum = MyEnum.TwomyEnum.myFunc ()

Mettre tous ensemble

La liste suivante montre ces échantillons réunis.

// Aire de jeux - nom: un endroit où les gens peuvent playprotocol MyProtocol {fonc myFunc () -> Chaîne} class MyClass: MyProtocol {fonc myFunc () -> Chaîne {return "Protocole 1"} var INTVAL: Int = 0} var myClass : MyClass = MyClass () myClass.intVal = 25myClass.myFunc () struct MyStruct: MyProtocol {fonc myFunc () -> Chaîne {return "Protocole 2"} var INTVAL: Int = 0var Un = 1VAR Deux = 2} enum MyEnum: MyProtocol {fonc myFunc () -> Chaîne {return "Protocole 3"} cas Onecase Twocase Threecase Quatre} var myStruct: MyStruct = MyStruct () myStruct.intVal = 15myStruct.myFunc () var MyEnum: MyEnum = MyEnum.TwomyEnum.myFunc ( )

» » » » Adopter et conforme une classe, la structure, ou une énumération à un protocole rapide