Cours de résumé en langue rapide

Y at-il un moyen de créer une classe abstraite dans le langage Swift, ou est-ce une limitation comme Objective-C? Je voudrais créer une classe abstraite comparable à ce que Java définit comme une classe abstraite.

Il n’y a pas de classes abstraites dans Swift (tout comme Objective-C). Votre meilleur pari sera d’utiliser un protocole , qui est comme une interface Java.

Avec Swift 2.0, vous pouvez ensuite append des implémentations de méthodes et des implémentations de propriétés calculées à l’aide d’extensions de protocole. Vos seules ressortingctions sont que vous ne pouvez pas fournir de variables ou de constantes membres et qu’il n’ya pas de répartition dynamic .

Un exemple de cette technique serait:

protocol Employee { var annualSalary: Int {get} } extension Employee { var biweeklySalary: Int { return self.annualSalary / 26 } func logSalary() { print("$\(self.annualSalary) per year or $\(self.biweeklySalary) biweekly") } } struct SoftwareEngineer: Employee { var annualSalary: Int func logSalary() { print("overridden") } } let sarah = SoftwareEngineer(annualSalary: 100000) sarah.logSalary() // prints: overridden (sarah as Employee).logSalary() // prints: $100000 per year or $3846 biweekly 

Notez que cela fournit des fonctionnalités de type “classe abstraite” même pour les structures, mais les classes peuvent également implémenter le même protocole.

Notez également que chaque classe ou structure qui implémente le protocole Employee devra déclarer à nouveau la propriété annualSalary.

Plus important encore, notez qu’il n’y a pas de dépêche dynamic . Lorsque logSalary est appelé sur l’instance stockée en tant que SoftwareEngineer il appelle la version surchargée de la méthode. Lorsque logSalary est appelé sur l’instance après sa dissortingbution à un Employee , il appelle l’implémentation d’origine (il n’est pas dissortingbué dynamicment à la version surchargée, même si l’instance est en fait un Software Engineer .

Pour plus d’informations, consultez la vidéo de WWDC sur cette fonctionnalité: Création de meilleures applications avec des types de valeur dans Swift

Notez que cette réponse est destinée à Swift 2.0 et supérieur

Vous pouvez obtenir le même comportement avec les protocoles et les extensions de protocole.

Tout d’abord, vous écrivez un protocole qui sert d’interface pour toutes les méthodes à implémenter dans tous les types qui s’y conforment.

 protocol Drivable { var speed: Float { get set } } 

Ensuite, vous pouvez append un comportement par défaut à tous les types qui s’y conforment

 extension Drivable { func accelerate(by: Float) { speed += by } } 

Vous pouvez maintenant créer de nouveaux types en implémentant Drivable .

 struct Car: Drivable { var speed: Float = 0.0 init() {} } let c = Car() c.accelerate(10) 

Donc, fondamentalement, vous obtenez:

  1. Comstackz les contrôles de temps qui garantissent que tous les Drivable implémentent la speed
  2. Vous pouvez implémenter un comportement par défaut pour tous les types conformes à Drivable ( accelerate )
  3. Drivable est garanti pour ne pas être instancié puisqu’il ne s’agit que d’un protocole

Ce modèle se comporte en réalité beaucoup plus comme des traits, ce qui signifie que vous pouvez vous conformer à plusieurs protocoles et implémenter des implémentations par défaut, alors qu’avec une superclasse abstraite, vous êtes limité à une hiérarchie de classes simple.

Je pense que c’est le plus proche du abstract de Java ou du abstract C #:

 class AbstractClass { private init() { } } 

Notez que pour que les modificateurs private fonctionnent, vous devez définir cette classe dans un fichier Swift distinct.

EDIT: Ce code ne permet cependant pas de déclarer une méthode abstraite et donc de forcer son implémentation.

Après avoir lutté pendant plusieurs semaines, j’ai finalement réalisé comment traduire une classe abstraite Java / PHP en Swift:

 public class AbstractClass: NSObject { internal override init(){} public func getFoodToEat()->Ssortingng { if(self._iAmHungry()) { return self._myFavoriteFood(); }else{ return ""; } } private func _myFavoriteFood()->Ssortingng { return "Sandwich"; } internal func _iAmHungry()->Bool { fatalError(__FUNCTION__ + "Must be overridden"); return false; } } public class ConcreteClass: AbstractClass, IConcreteClass { private var _hungry: Bool = false; public override init() { super.init(); } public func starve()->Void { self._hungry = true; } public override func _iAmHungry()->Bool { return self._hungry; } } public protocol IConcreteClass { func _iAmHungry()->Bool; } class ConcreteClassTest: XCTestCase { func testExample() { var concreteClass: ConcreteClass = ConcreteClass(); XCTAssertEqual("", concreteClass.getFoodToEat()); concreteClass.starve(); XCTAssertEqual("Sandwich", concreteClass.getFoodToEat()); } } 

Cependant, je pense qu’Apple n’a pas implémenté de classes abstraites car il utilise généralement le pattern delegate + protocol. Par exemple, le même schéma ci-dessus serait mieux fait comme ceci:

 import UIKit public class GoldenSpoonChild { private var delegate: IStomach!; internal init(){} internal func setup(delegate: IStomach) { self.delegate = delegate; } public func getFoodToEat()->Ssortingng { if(self.delegate.iAmHungry()) { return self._myFavoriteFood(); }else{ return ""; } } private func _myFavoriteFood()->Ssortingng { return "Sandwich"; } } public class Mother: GoldenSpoonChild, IStomach { private var _hungry: Bool = false; public override init() { super.init(); super.setup(self); } public func makeFamilyHungry()->Void { self._hungry = true; } public func iAmHungry()->Bool { return self._hungry; } } protocol IStomach { func iAmHungry()->Bool; } class DelegateTest: XCTestCase { func testGetFood() { var concreteClass: Mother = Mother(); XCTAssertEqual("", concreteClass.getFoodToEat()); concreteClass.makeFamilyHungry(); XCTAssertEqual("Sandwich", concreteClass.getFoodToEat()); } } 

J’avais besoin de ce type de modèle car je voulais partager certaines méthodes dans UITableViewController telles que viewWillAppear, etc.

Le moyen le plus simple est d’utiliser un appel à fatalError("Not Implemented") dans la méthode abstraite (non variable) de l’extension de protocole.

 protocol MyInterface { func myMethod() -> Ssortingng } extension MyInterface { func myMethod() -> Ssortingng { fatalError("Not Implemented") } } class MyConcreteClass: MyInterface { func myMethod() -> Ssortingng { return "The output" } } MyConcreteClass().myMethod() 

Il existe un moyen de simuler des classes abstraites à l’aide de protocoles. Ceci est un exemple:

 protocol MyProtocol { func doIt() } class BaseClass { var myDelegate: MyProtocol! init() { ... } func myFunc() { ... self.myDelegate.doIt() ... } } class ChildClass: BaseClass, MyProtocol { override init(){ super.init() self.myDelegate = self } func doIt() { // Custom implementation } } 

Une autre façon d’implémenter la classe abstraite est de bloquer l’initialiseur. Je l’ai fait de cette façon:

 class Element:CALayer { // IT'S ABSTRACT CLASS override init(){ super.init() if self.dynamicType === Element.self { fatalError("Element is abstract class, do not try to create instance of this class") } } } 

J’essayais de créer une classe abstraite Weather , mais l’utilisation de protocoles n’était pas idéale car je devais écrire les mêmes méthodes d’ init encore et encore. L’extension du protocole et l’écriture d’une méthode d’ init présentaient des problèmes, en particulier depuis que j’utilisais NSObject conformément à NSCoding .

Donc, je suis venu avec cela pour la conformité NSCoding :

 required init?(coder aDecoder: NSCoder) { guard type(of: self) != Weather.self else { fatalError(" This is an abstract class. Use a subclass of `Weather`.") } // Initialize... } 

Comme pour init :

 fileprivate init(param: Any...) { // Initialize } 

Déplacer toutes les références aux propriétés abstraites et aux méthodes de l’implémentation de l’extension de la classe de base vers le protocole, où Self contrainte à la classe de base. Vous aurez access à toutes les méthodes et propriétés de la classe de base. De plus, le compilateur vérifie l’implémentation de méthodes abstraites et de propriétés dans le protocole pour les classes dérivées

 protocol Commom:class{ var tableView:UITableView {get}; func update(); } class Base{ var total:Int = 0; } extension Common where Self:Base{ func update(){ total += 1; tableView.reloadData(); } } class Derived:Base,Common{ var tableView:UITableView{ return owner.tableView; } }