Pourquoi utiliser des Initialiseurs de Swift dans les classes?

Je suis en train d'essayer de comprendre l'utilisation de la required mot-clé dans Swift classes.

class SomeClass 
{
    required init() {
        //initializer implementation goes here
    }
}

required ne pas me forcer à mettre en œuvre la méthode dans mes enfant de la classe. Si je veux remplacer le required désigné de l'initialiseur de ma classe parent j'ai besoin d'écrire required et pas override. Je sais comment il fonctionne, mais ne peut pas comprendre pourquoi je devrais le faire.

Quel est l'avantage de required?
Aussi loin que je peux dire, langages tels que le C# ne pas avoir quelque chose comme ça et fonctionnent très bien avec override.

Mise en œuvre dans votre sous-classes n'est pas nécessaire en raison de l'héritage, ce qui est logique. Cependant, je suis également se demander l'intérêt ici. Si une sous-classe (qui, par hypothèse, les remplacements de init() mais pas des initialiseur) obtient init par un processus appelé la héritées nécessaire d'initialiseur, et il est nécessaire d'initialiseur par la suite des appels init(), ne serait-il pas appel à la sous-classe' substituée init et tout est bon? -- Je pense que la seule bonne raison serait que l'initialiseur de ne pas appel init() sur soi, donc primordiale 'init()' ne sera jamais appelé.
Cela pourrait être intéressant dans ce contexte: Protocole func retour Auto.

InformationsquelleAutor TalkingCode | 2015-05-06

initialization swift

79

Fait juste un moyen de satisfaire le compilateur pour s'assurer qu'il que si cette classe de sous-classes, ils n'héritent ou de mettre en œuvre cette même initialiseur. Il y a un doute sur ce point, en raison de la règle qui si une sous-classe a désigné un initialiseur de son propre, pas de initialiseurs de la classe mère sont hérités. Il est donc possible pour une super-classe d'avoir un initialiseur et de la sous-classe pas de l'avoir. required surmonte cette possibilité.

Une situation où le compilateur a besoin d'être convaincu de cette façon implique protocoles, et fonctionne comme ceci:
```
protocol Flier {
    init()
}
class Bird: Flier {
    init() {} //compile error
}
```
Le problème est que si l'Oiseau avait une sous-classe, cette sous-classe pour la mise en œuvre ou d'en hériter init, et vous n'avez pas la garantie que. Le marquage de l'Oiseau init comme required ne pouvons le garantir.

Alternativement, vous pouvez marquer des Oiseaux comme final, garantissant ainsi, à l'inverse, à savoir qu'il n'aura jamais une sous-classe.

Autre situation où vous avez une méthode de fabrique qui peuvent faire une classe ou de sa sous-classe en appelant le même initialiseur:
```
class Dog {
    var name: String
    init(name: String) {
        self.name = name
    }
}

class NoisyDog: Dog {

}

func dogMakerAndNamer(whattype: Dog.Type) -> Dog {
    let d = whattype.init(name: "Fido") //compile error
    return d
}
```
dogMakerAndNamer est l'appel de la init(name:) initialiseur sur Chien ou un Chien à la sous-classe. Mais comment le compilateur assurez-vous qu'une sous-classe d'avoir un init(name:) initialiseur? Le required désignation calme le compilateur craintes.
- Donc, si "NoisyDog" a "laissez-le bruit: String', que feriez-vous dans " requis init(nom: String)'? Est la "bonne" façon de changer le var de var bruit: Chaîne de caractères!' et j'espère que si quelqu'un inits à l'aide de Chiens.Type que ci-dessus qu'ils savent quelque sorte à définir le "bruit" var après? Ou avez-vous de fournir une valeur par défaut comme " var = bruit "Arf!"' que certains de vos personnalisée initialiseurs de la remplacer? Je suis à la recherche pour les meilleures pratiques ici (cela semble être un mal pensé construction du langage qui brise beaucoup de standard OO modèles, mais je sais que les concepteurs de Swift sont mieux, alors il doit être une bonne façon).
- Sinon, est la "meilleure pratique" que "requis" ne devrait que rarement, voire jamais, être utilisé?
- Le seul moment où vous ne pourriez jamais dire required est quand ils sont forcés par le compilateur. Le compilateur ding vous et vous allez utiliser l'une des solutions décrites ci-dessus. Sinon, ne l'utilisez pas.
InformationsquelleAutor matt
6

Je tiens à attirer l'attention sur une autre solution fournie par Required, à l'exception de Matt a donné ci-dessus.
```
class superClass{
    var name: String
    required init(){
        //initializer implementation goes here
        self.name = "Untitled"
    }
}
class subClass: superClass {
    var neakName: String = "Subclass Untitled"

}
let instanceSubClass = subClass()
instanceSubClass.name        //output: "Untitled"
instanceSubClass.neakName    //output: "Subclass Untitled"
```
Que vous pouvez vérifier dans l'exemple ci-dessus, j'ai déclaré required init() sur superClass, init() initialiseur de la super-classe est héritée par défaut sur subClass, de Sorte que vous en mesure de créer une instance de la sous-classe let instanceSubClass = subClass().

Mais, supposons que vous vouliez ajouter un initialiseur sur sous-classe d'attribuer moment de l'exécution de la valeur pour l'entreposage des biens neakName. Bien sûr, vous pouvez l'ajouter, mais qui en résultera à pas les initialiseurs de la super-classe est transmise à la sous-classe, Donc si vous allez créer une instance de subClass vous permettra de créer, à travers sa propre initialiseur comme ci-dessous.
```
class superClass{
    var name: String
    init(){
        //initializer implementation goes here
        self.name = "Untitled"
    }
}
class subClass: superClass {
    var neakName: String = "Subclass Untitled"
    init(neakName: String) {
        self.neakName = neakName
    }
}
let instanceSubClass = subClass(neakName: "Bobby")
instanceSubClass.name       //output: "Untitled"
instanceSubClass.neakName   //output: "Bobby"
```
Ci-dessus, vous ne serez pas en mesure de créer une instance de subClass par juste subClass(), Mais si vous voulez que tous les sous-classes de la classe mère doit avoir son propre init() initialiseur à la création directe d'une instance par subClass(). Il suffit de placer required mot-clé avant de init() sur la super-classe, il va vous forcer à ajouter init() initialiseur sur subClass trop comme ci-dessous.
```
class superClass{
    var name: String
    required init(){
        //initializer implementation goes here
        self.name = "Untitled"
    }
}
class subClass: superClass {
    var neakName: String = "Subclass Untitled"
    init(neakName: String) {
        self.neakName = neakName
    }
}    //Compiler error <------------ required `init()` must be provided by subClass.
let instanceSubClass = subClass(neakName: "Bobby")
instanceSubClass.name       //output: "Untitled"
instanceSubClass.neakName   //output: "Bobby"  
```
AINSI, l'utilisation de required mot-clé avant de l'initialiseur sur la super-classe, quand vous voulez, toutes les sous-classes doivent avoir été mises en œuvre required initializer de la super-classe.
- Qui n'a pas de sens. Alors, pour remédier à cela, vous devez fournir un init() sur sous-classe, ce qui laisse à la sous-classe var unset. Cela conduit à beaucoup de code difficile à maintenir, en s'appuyant sur var ...! et des erreurs d'exécution, si les "requis" init est jamais utilisé, sans y revenir et de nettoyage de ces "sera initialisé avant d'utiliser' vars, au lieu de laisser ... Nécessitant une init() pour appeler super.init(withanyargs) gère cette préoccupation loin beaucoup mieux.
InformationsquelleAutor Kiran Jasvanee

Selon la la documentation:

Write the required modifier before the definition of a class initializer to
indicate that every subclass of the class must implement that initializer

Donc oui, requis ne force tous les enfants des classes pour mettre en œuvre ce constructeur. Cependant, ce n'est pas nécessaire

 if you can satisfy the requirement with an inherited initializer.

Donc, si vous avez créé plus complexe classes qui ne peuvent pas être entièrement initialisé avec un constructeur parent, vous devez mettre en œuvre l'exigent constructeur.

Exemple à partir de la documentation (avec quelques trucs):

class SomeClass {
    required init() {
        //initializer implementation goes here
    }
}

class SomeSubclass: SomeClass {
    let thisNeedsToBeInitialized: String
    required init() {
        //subclass implementation of the required initializer goes here
        self.thisNeedsToBeInitialized = "default value"
    }
}

InformationsquelleAutor pseudonym117

0

Si vous essayez d'ajouter votre propre initialiser dans la sous-classe, alors, vous devez suivre certaines choses, ceux qui ont été déclarées dans la classe super. Donc assurez-vous que vous n'oublierez pas de mettre en œuvre cette méthode. Si vous oubliez le compilateur va vous donner l'erreur //fatal error, we've not included the required init(). Une autre raison est qu'il crée un ensemble de conditions qui jamais sous-classe doit suivre la sous-classe est la définition de ses propres initialiser.

InformationsquelleAutor Amit89

Vous devez vous connecter pour publier un commentaire.