Я хотел бы создать абстрактную функцию на быстром языке. Является ли это возможным?

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

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

В Swift нет концепции абстрактного (например, Objective-C), но вы можете сделать это:

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

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

Вам нужен не базовый класс, а протокол.

protocol MyProtocol {
    func abstractFunction()
}

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

Если вы не предоставляете abstractFunction в своем классе, это ошибка.

Если вам все еще нужен базовый класс для другого поведения, вы можете сделать это:

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

Я переношу изрядное количество кода с платформы, которая поддерживает абстрактные базовые классы, на Swift и часто использую его. Если то, что вы действительно хотите, - это функциональность абстрактного базового класса, то это означает, что этот класс служит как реализацией функциональности общего класса (в противном случае это был бы просто интерфейс / протокол), И он определяет методы, которые должны быть реализованы производные классы.

Для этого в Swift вам понадобится протокол и базовый класс.

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

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

Обратите внимание, что базовый класс реализует общие методы, но не реализует протокол (поскольку он не реализует все методы).

Затем в производном классе:

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

Производный класс наследует sharedFunction от базового класса, помогая ему удовлетворить эту часть протокола, и протокол по-прежнему требует, чтобы производный класс реализовал abstractFunction.

Единственный реальный недостаток этого метода заключается в том, что, поскольку базовый класс не реализует протокол, если у вас есть метод базового класса, которому требуется доступ к свойству / методу протокола, вам придется переопределить его в производном классе и оттуда вызвать передача базового класса (через super), selfчтобы у базового класса был экземпляр протокола, с которым он мог бы выполнять свою работу.

Например, допустим, что sharedFunction необходимо вызвать abstractFunction. Протокол останется прежним, а классы теперь будут выглядеть так:

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");
    }
}

Теперь sharedFunction из производного класса удовлетворяет эту часть протокола, но производный класс по-прежнему может совместно использовать логику базового класса достаточно простым способом.

Похоже, это «официальный» способ, которым Apple обрабатывает абстрактные методы в UIKit. Взгляните на UITableViewControllerто, как он работает UITableViewDelegate. Одна из самых первых вещей , которые вы делаете, чтобы добавить строку: delegate = self. Что ж, в этом и весь фокус.

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()

Проверьте с Playground, чтобы увидеть результат.

Некоторые замечания

• Во-первых, уже было дано много ответов. Я надеюсь, что кто-нибудь найдет вплоть до этого.
• На самом деле вопрос заключался в том, чтобы найти шаблон, реализующий:
  • Класс вызывает метод, который должен быть реализован в одном из его производных подклассов (переопределен)
  • В лучшем случае, если метод не переопределен в подклассе, получить ошибку во время компиляции
• Суть абстрактных методов в том, что они представляют собой смесь определения интерфейса и части фактической реализации в базовом классе. И то и другое одновременно. Поскольку swift является очень новым и очень четким определением, у него нет такого удобства, кроме "нечистых" концепций (пока).
• Для меня (бедного старого Java-парня) эта проблема время от времени развивается. Я прочитал все ответы в этом посте, и на этот раз я думаю, что нашел шаблон, который выглядит выполнимым - по крайней мере, для меня.
• Обновление : похоже, что разработчики UIKit в Apple используют тот же шаблон. UITableViewControllerреализует, UITableViewDelegateно по-прежнему должен быть зарегистрирован как делегат, явно установив delegateсвойство.
• Все это проверено на игровой площадке Xcode 7.3.1

Один из способов сделать это - использовать необязательное замыкание, определенное в базовом классе, и дочерние элементы могут выбирать, реализовывать его или нет.

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

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

Что ж, я знаю, что опаздываю в игру и, возможно, использую произошедшие изменения. Извини за это.

В любом случае, я хотел бы внести свой ответ, потому что мне нравится проводить тестирование, и решения с fatalError(), AFAIK, не тестируются, а те, которые имеют исключения, намного сложнее тестировать.

Я бы посоветовал использовать более быстрый подход. Ваша цель - определить абстракцию, которая имеет некоторые общие детали, но не полностью определена, то есть абстрактный метод (ы). Используйте протокол, который определяет все ожидаемые методы в абстракции, как те, которые определены, так и те, которые не определены. Затем создайте расширение протокола, реализующее методы, определенные в вашем случае. Наконец, любой производный класс должен реализовывать протокол, что означает все методы, но те, которые являются частью расширения протокола, уже имеют свою реализацию.

Расширение вашего примера одной конкретной функцией:

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.
    }
}

Обратите внимание, что, делая это, компилятор снова становится вашим другом. Если метод не «переопределен», вы получите ошибку во время компиляции вместо тех, которые вы бы получили, fatalError()или исключений, которые произошли бы во время выполнения.

Я понимаю, что вы сейчас делаете, думаю, вам лучше воспользоваться протоколом

protocol BaseProtocol {
    func abstractFunction()
}

Затем вы просто соответствуете протоколу:

class SubClass : BaseProtocol {

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

Если ваш класс также является подклассом, протоколы следуют за суперклассом:

class SubClass: SuperClass, ProtocolOne, ProtocolTwo {}

Использование assertключевого слова для принудительного применения абстрактных методов:

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

Однако, как сказал Стив Ваддикор, вы, вероятно, захотите protocolвзамен.

Я понимаю вопрос и искал такое же решение. Протоколы - это не то же самое, что абстрактные методы.

В протоколе вам необходимо указать, что ваш класс соответствует такому протоколу, абстрактный метод означает, что вы должны переопределить такой метод.

Другими словами, протоколы являются своего рода необязательными, вам нужно указать базовый класс и протокол, если вы не укажете протокол, вам не нужно переопределять такие методы.

Абстрактный метод означает, что вам нужен базовый класс, но вам необходимо реализовать свой собственный метод или два, что не одно и то же.

Мне нужно такое же поведение, поэтому я искал решение. Думаю, в Swift такой функции нет.

Есть еще одна альтернатива этой проблеме, хотя есть и обратная сторона по сравнению с предложением @ jaumard; для этого требуется оператор возврата. Хотя я упускаю из виду необходимость этого, потому что он заключается в непосредственной выдаче исключения:

class AbstractMethodException : NSException {

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

А потом:

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

Все, что будет после этого, недостижимо, поэтому я не понимаю, зачем форсировать возврат.

Не знаю, будет ли это полезно, но у меня была аналогичная проблема с абстрактным методом при попытке создать игру SpritKit. Мне нужен был абстрактный класс Animal с такими методами, как move (), run () и т.д., но имена спрайтов (и другие функции) должны предоставляться дочерними элементами класса. В итоге я сделал что-то вроде этого (проверено на 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"]
        }
    }
}