Fonction de class d'appel rapide de la sous-class correspondante dans la fonction de superclass

Je voudrais implémenter init(coder aDecoder: NSCoder!) Dans une superclass, et l'utiliser dans toutes les sous-classs en appelant une méthode de class sur la sous-class particulière dans la superclass à l'exécution.

MySuperClass

 class func dummyDict() -> NSDictionary init(coder aDecoder: NSCoder!) { for(key,value) in self.class.dummyDict(){ -------------------- ^ | | Get this from the corresponding subclass at runtime! NSLog("encoding \(value) for key \(key)") } } 

Est-il possible que les sous-classs de MySuperClass accèdent à la fonction de class dummyDict() au moment de l'exécution?

Je pense que j'ai attrapé ce que tu veux dire. Vous créez une class de Base , en implémentant un initialiseur et une fonction de class (statique):

 class Base { class func dummyDict() -> Dictionary<Ssortingng, Ssortingng> { return ["base1": "val1"] } init() { for (key, value) in self.dynamicType.dummyDict() { println("encoding \(value) for key \(key)") } } } 

Ensuite, vous voulez créer des sous-classs, et avoir l'initialisateur pour appeler une version substituée de la méthode dummyDict . Vous devez simplement replace cette méthode:

 class Subclass1 : Base { override class func dummyDict() -> Dictionary<Ssortingng, Ssortingng> { return ["subclass1": "sub1"] } } 

Maintenant, lorsque vous créez une instance de Subclass1 , ce qui est imprimé est:

 encoding sub1 for key subclass1 

qui est la sortie attendue.

Notez que la boucle for de l'initialiseur utilise self.dynamicType.dummyDict() plutôt que Base.dummyDict() . Ce dernier appelle toujours la méthode de class définie dans la class Base , alors que le premier l'appelle dans la scope de la class réelle héritée de Base

dynamicType est obsolète dans Swift 3. Nous devons utiliser type(of:) .

Donc, l'exemple d'Antonio est maintenant:

 class Base { class func dummyDict() -> [Ssortingng: Ssortingng] { return ["base1": "val1"] } init() { for (key, value) in type(of: self).dummyDict() { print("encoding \(value) for key \(key)") } } } class Subclass1 : Base { override class func dummyDict() -> [Ssortingng: Ssortingng] { return ["subclass1": "sub1"] } } 

[SUPPRIMÉ]

utilisez dynamicType comme suggéré par Antonio dans sa réponse

 class Test : NSObject { class func dummy() -> Ssortingng { return "t" } init() { super.init() println("\(self.dynamicType.dummy())") } } class Test1 : Test { override class func dummy() -> Ssortingng { return "t1" } } class Test2 : Test { override class func dummy() -> Ssortingng { return "t2" } }