Je voudrais créer une fonction abstraite dans un langage rapide. C'est possible?

class BaseClass {
    func abstractFunction() {
        // How do I force this function to be overridden?
    }
}

class SubClass : BaseClass {
    override func abstractFunction() {
        // Override
    }
}

Il n'y a pas de concept d'abstrait dans Swift (comme Objective-C) mais vous pouvez le faire:

class BaseClass {
    func abstractFunction() {
        preconditionFailure("This method must be overridden") 
    } 
}

class SubClass : BaseClass {
     override func abstractFunction() {
         // Override
     } 
}

Ce que vous voulez, ce n'est pas une classe de base, mais un protocole.

protocol MyProtocol {
    func abstractFunction()
}

class MyClass : MyProtocol {
    func abstractFunction() {
    }
}

Si vous ne fournissez pas abstractFunction dans votre classe, c'est une erreur.

Si vous avez toujours besoin de la classe de base pour un autre comportement, vous pouvez le faire:

class MyClass : BaseClass, MyProtocol {
    func abstractFunction() {
    }
}

Je porte une bonne quantité de code depuis une plate-forme qui prend en charge les classes de base abstraites vers Swift et j'y suis souvent connecté. Si ce que vous voulez vraiment, c'est la fonctionnalité d'une classe de base abstraite, cela signifie que cette classe sert à la fois d'implémentation de fonctionnalité de classe partagée (sinon ce serait juste une interface / protocole) ET qu'elle définit des méthodes qui doivent être implémentées par classes dérivées.

Pour ce faire dans Swift, vous aurez besoin d'un protocole et d'une classe de base.

protocol Thing
{
    func sharedFunction()
    func abstractFunction()
}

class BaseThing
{
    func sharedFunction()
    {
        println("All classes share this implementation")
    }
}

Notez que la classe de base implémente la ou les méthodes partagées, mais n'implémente pas le protocole (car elle n'implémente pas toutes les méthodes).

Puis dans la classe dérivée:

class DerivedThing : BaseThing, Thing 
{
    func abstractFunction() 
    {
        println("Derived classes implement this");
    }
}

La classe dérivée hérite de sharedFunction de la classe de base, ce qui l'aide à satisfaire cette partie du protocole, et le protocole nécessite toujours que la classe dérivée implémente abstractFunction.

Le seul inconvénient réel de cette méthode est que, puisque la classe de base n'implémente pas le protocole, si vous avez une méthode de classe de base qui a besoin d'accéder à une propriété / méthode de protocole, vous devrez la remplacer dans la classe dérivée, et à partir de là, appeler la classe de base (via super) passant de selfsorte que la classe de base ait une instance du protocole avec laquelle faire son travail.

Par exemple, disons que sharedFunction avait besoin d'appeler abstractFunction. Le protocole resterait le même et les classes ressembleraient maintenant à:

class BaseThing
{
    func sharedFunction(thing: Thing)
    {
        println("All classes share this implementation")
        thing.abstractFunction()
    }
}

class DerivedThing : BaseThing, Thing 
{
    func sharedFunction()
    {
        super.sharedFunction(self)
    }

    func abstractFunction() 
    {
        println("Derived classes implement this");
    }
}

Maintenant, la fonction sharedFunction de la classe dérivée satisfait cette partie du protocole, mais la classe dérivée est toujours capable de partager la logique de la classe de base d'une manière raisonnablement simple.

Celui-ci semble être la manière "officielle" dont Apple gère les méthodes abstraites dans UIKit. Jetez un œil à UITableViewControllerla façon dont il fonctionne UITableViewDelegate. L' une des premières choses que vous faites, est d'ajouter une ligne: delegate = self. Eh bien, c'est exactement le truc.

protocol AbstractMethodsForClassX {
    func abstractMethod() -> String
}

/// It takes an implementation of the protocol as property (same like the delegate in UITableViewController does)
/// And does not implement the protocol as it does not implement the abstract methods. It has the abstract methods available in the `delegate`
class BaseClassX {
    var delegate: AbstractMethodsForClassX!

    func doSomethingWithAbstractMethod() -> String {
        return delegate.abstractMethod() + " - And I believe it"
    }
}

/// First and only additional thing you have to do, you must set the "delegate" property
class ClassX: BaseClassX, AbstractMethodsForClassX {
    override init() {
        super.init()
        delegate = self
    }

    func abstractMethod() -> String {return "Yes, this works!"}
}

let x = ClassX()
x.doSomethingWithAbstractMethod()

Vérifiez avec Playground pour voir la sortie.

Quelques remarques

• Premièrement, beaucoup de réponses ont déjà été données. J'espère que quelqu'un trouvera tout le chemin jusqu'à celui-ci.
• La question était en fait de trouver un modèle qui implémente:
  • Une classe appelle une méthode, qui doit être implémentée dans l'une de ses sous-classes dérivées (remplacée)
  • Dans le meilleur des cas, si la méthode n'est pas remplacée dans la sous-classe, obtenez une erreur lors de la compilation
• Le truc à propos des méthodes abstraites est qu'elles sont un mélange d'une définition d'interface et d'une partie d'une implémentation réelle dans la classe de base. Les deux en même temps. Comme swift est très nouveau et très propre, il n'a pas une telle commodité mais des concepts "impurs" (encore).
• Pour moi (un pauvre vieux Java), ce problème évolue de temps en temps. J'ai lu toutes les réponses dans cet article et cette fois, je pense avoir trouvé un modèle qui semble réalisable - du moins pour moi.
• Mise à jour : il semble que les implémenteurs d'UIKit chez Apple utilisent le même modèle. UITableViewControllerimplémente UITableViewDelegatemais doit toujours être des registres en tant que délégué en définissant explicitement la delegatepropriété.
• Tout cela est testé sur Playground de Xcode 7.3.1

Une façon de faire est d'utiliser une fermeture facultative définie dans la classe de base, et les enfants peuvent choisir de l'implémenter ou non.

class BaseClass {
    var abstractClosure?:(()->())?
    func someFunc()
    {
        if let abstractClosure=abstractClosure
        {
            abstractClosure()
        }
    } 
}

class SubClass : BaseClass {
    init()
    {
        super.init()
        abstractClosure={ ..... }
    }
}

Eh bien, je sais que je suis en retard au match et que je profite peut-être des changements qui se sont produits. Désolé pour ça.

Dans tous les cas, j'aimerais apporter ma réponse, car j'aime faire des tests et les solutions avec fatalError()est, AFAIK, non testable et celles avec des exceptions sont beaucoup plus difficiles à tester.

Je suggérerais d'utiliser une approche plus rapide . Votre objectif est de définir une abstraction qui a des détails communs, mais qui ne sont pas entièrement définis, c'est-à-dire la ou les méthodes abstraites. Utilisez un protocole qui définit toutes les méthodes attendues dans l'abstraction, à la fois celles qui sont définies et celles qui ne le sont pas. Créez ensuite une extension de protocole qui implémente les méthodes définies dans votre cas. Enfin, toute classe dérivée doit implémenter le protocole, ce qui signifie toutes les méthodes, mais celles qui font partie de l'extension de protocole ont déjà leur implémentation.

Prolonger votre exemple avec une fonction concrète:

protocol BaseAbstraction {
    func abstractFunction() {
        // How do I force this function to be overridden?
    }
}

extension BaseAbstraction {
    func definedFunction() {
        print("Hello")
}

class SubClass : BaseAbstraction {
    func abstractFunction() {
        // No need to "Override". Just implement.
    }
}

Notez qu'en faisant cela, le compilateur est à nouveau votre ami. Si la méthode n'est pas "surchargée", vous obtiendrez une erreur au moment de la compilation, au lieu de celles que vous obtiendriez avec fatalError()ou des exceptions qui se produiraient au moment de l'exécution.

Je comprends ce que tu fais maintenant, je pense que tu ferais mieux d'utiliser un protocole

protocol BaseProtocol {
    func abstractFunction()
}

Ensuite, vous vous conformez simplement au protocole:

class SubClass : BaseProtocol {

    func abstractFunction() {
        // Override
        println("Override")
    }
}

Si votre classe est également une sous-classe, les protocoles suivent la superclasse:

class SubClass: SuperClass, ProtocolOne, ProtocolTwo {}

Utilisation de assertmots-clés pour appliquer des méthodes abstraites:

class Abstract
{
    func doWork()
    {
        assert(false, "This method must be overriden by the subclass")
    }
}

class Concrete : Abstract
{
    override func doWork()
    {
        println("Did some work!")
    }
}

let abstract = Abstract()
let concrete = Concrete()

abstract.doWork()    // fails
concrete.doWork()    // OK

Cependant, comme Steve Waddicor l'a mentionné, vous en voulez probablement un à la protocolplace.

Je comprends la question et je cherchais la même solution. Les protocoles ne sont pas les mêmes que les méthodes abstraites.

Dans un protocole, vous devez spécifier que votre classe est conforme à ce protocole, une méthode abstraite signifie que vous devez remplacer cette méthode.

En d'autres termes, les protocoles sont des sortes d'options, vous devez spécifier la classe de base et le protocole, si vous ne spécifiez pas le protocole, vous n'avez pas à remplacer ces méthodes.

Une méthode abstraite signifie que vous voulez une classe de base mais que vous devez implémenter votre propre méthode ou deux, ce qui n'est pas la même chose.

J'ai besoin du même comportement, c'est pourquoi je cherchais une solution. Je suppose que Swift manque une telle fonctionnalité.

Il existe une autre alternative à ce problème, bien qu'il y ait toujours un inconvénient par rapport à la proposition de @ jaumard; il nécessite une déclaration de retour. Bien que je manque le point de l'exiger, car cela consiste à lancer directement une exception:

class AbstractMethodException : NSException {

    init() {
        super.init(
            name: "Called an abstract method",
            reason: "All abstract methods must be overriden by subclasses",
            userInfo: nil
        );
    }
}

Puis:

class BaseClass {
    func abstractFunction() {
        AbstractMethodException.raise();
    }
}

Tout ce qui vient après est inaccessible, donc je ne vois pas pourquoi forcer le retour.

Je ne sais pas si cela va être utile, mais j'ai eu un problème similaire avec la méthode abstraite en essayant de créer le jeu SpritKit. Ce que je voulais, c'est une classe animale abstraite qui a des méthodes telles que move (), run () etc., mais les noms de sprite (et d'autres fonctionnalités) devraient être fournis par les enfants de la classe. J'ai donc fini par faire quelque chose comme ça (testé pour Swift 2):

import SpriteKit

// --- Functions that must be implemented by child of Animal
public protocol InheritedAnimal
{
    func walkSpriteNames() -> [String]
    func runSpriteNames() -> [String]
}


// --- Abstract animal
public class Animal: SKNode
{
    private let inheritedAnimal: InheritedAnimal

    public init(inheritedAnimal: InheritedAnimal)
    {
        self.inheritedAnimal = inheritedAnimal
        super.init()
    }

    public required init?(coder aDecoder: NSCoder)
    {
        fatalError("NSCoding not supported")
    }

    public func walk()
    {
        let sprites = inheritedAnimal.walkSpriteNames()
        // create animation with walking sprites...
    }

    public func run()
    {
        let sprites = inheritedAnimal.runSpriteNames()
        // create animation with running sprites
    }
}


// --- Sheep
public class SheepAnimal: Animal
{
    public required init?(coder aDecoder: NSCoder)
    {
        fatalError("NSCoding not supported")
    }

    public required init()
    {
        super.init(inheritedAnimal: InheritedAnimalImpl())
    }

    private class InheritedAnimalImpl: InheritedAnimal
    {
        init() {}

        func walkSpriteNames() -> [String]
        {
            return ["sheep_step_01", "sheep_step_02", "sheep_step_03", "sheep_step_04"]
        }

        func runSpriteNames() -> [String]
        {
            return ["sheep_run_01", "sheep_run_02"]
        }
    }
}