ฉันต้องการสร้างฟังก์ชันนามธรรมในภาษาที่รวดเร็ว เป็นไปได้ไหม?

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

ข้อเสียที่แท้จริงเพียงอย่างเดียวของวิธีนี้คือเนื่องจากคลาสพื้นฐานไม่ได้ใช้โปรโตคอลหากคุณมีเมธอดคลาสพื้นฐานที่ต้องการเข้าถึงคุณสมบัติ / วิธีการโปรโตคอลคุณจะต้องแทนที่สิ่งนั้นในคลาสที่ได้รับและจากนั้นการเรียกใช้ คลาสพื้นฐาน (ผ่านซุปเปอร์) 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 เพื่อดูผลลัพธ์

ข้อสังเกตบางประการ

• ประการแรกมีคำตอบมากมายแล้ว ฉันหวังว่าจะมีใครสักคนที่สามารถค้นพบสิ่งนี้ได้
• คำถามคือเพื่อค้นหารูปแบบที่ใช้:
  • คลาสเรียกเมธอดที่ต้องนำไปใช้ในคลาสย่อยที่ได้รับมา (แทนที่)
  • ในกรณีที่ดีที่สุดถ้าเมธอดไม่ถูกแทนที่ในคลาสย่อยให้รับข้อผิดพลาดระหว่างเวลาคอมไพล์
• สิ่งที่เกี่ยวกับวิธีนามธรรมก็คือพวกมันเป็นส่วนผสมของนิยามอินเทอร์เฟซและเป็นส่วนหนึ่งของการนำไปใช้จริงในคลาสพื้นฐาน ทั้งสองอย่างในเวลาเดียวกัน. เนื่องจากความรวดเร็วเป็นสิ่งใหม่มากและมีการกำหนดไว้อย่างสะอาดตาจึงไม่มีความสะดวกสบายเช่นนี้ แต่เป็นแนวคิดที่ "ไม่สะอาด" (ยัง)
• สำหรับฉัน (ชายชราชาวชวาที่น่าสงสาร) ปัญหานี้มีวิวัฒนาการเป็นระยะ ๆ ฉันได้อ่านคำตอบทั้งหมดในโพสต์นี้แล้วและคราวนี้ฉันคิดว่าฉันพบรูปแบบที่ดูเป็นไปได้ - อย่างน้อยสำหรับฉัน
• อัปเดต : ดูเหมือนว่าอุปกรณ์ UIKit ที่ Apple จะใช้รูปแบบเดียวกัน UITableViewControllerดำเนินการUITableViewDelegateแต่ยังคงต้องมีการลงทะเบียนในฐานะผู้รับมอบสิทธิ์โดยการตั้งค่าdelegateคุณสมบัติอย่างชัดเจน
• ทั้งหมดนี้ผ่านการทดสอบบน Playground ของ Xcode 7.3.1

วิธีหนึ่งในการทำเช่นนี้คือใช้การปิดทางเลือกที่กำหนดไว้ในคลาสพื้นฐานและเด็ก ๆ สามารถเลือกที่จะใช้หรือไม่ก็ได้

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

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

ฉันรู้ว่าฉันมาสายและอาจจะใช้ประโยชน์จากการเปลี่ยนแปลงที่เกิดขึ้น ขอโทษด้วยกับเรื่องนั้น.

ไม่ว่าในกรณีใดฉันต้องการให้คำตอบของฉันเพราะฉันชอบทำการทดสอบและวิธีแก้ปัญหาfatalError()คือ AFAIK ไม่สามารถทดสอบได้และข้อยกเว้นนั้นทดสอบได้ยากกว่ามาก

ฉันขอแนะนำให้ใช้swiftyมากขึ้นวิธี เป้าหมายของคุณคือการกำหนดสิ่งที่เป็นนามธรรมที่มีรายละเอียดร่วมกัน แต่ยังไม่ได้กำหนดไว้ทั้งหมดนั่นคือวิธีนามธรรม ใช้โปรโตคอลที่กำหนดวิธีการที่คาดหวังทั้งหมดในสิ่งที่เป็นนามธรรมทั้งวิธีที่กำหนดไว้และวิธีที่ไม่ได้กำหนด จากนั้นสร้างส่วนขยายโปรโตคอลที่ใช้วิธีการที่กำหนดไว้ในกรณีของคุณ สุดท้ายคลาสที่ได้รับจะต้องใช้โปรโตคอลซึ่งหมายถึงวิธีการทั้งหมด แต่คลาสที่เป็นส่วนขยายโปรโตคอลมีการใช้งานอยู่แล้ว

ขยายตัวอย่างของคุณด้วยฟังก์ชันที่เป็นรูปธรรม:

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

หากคลาสของคุณเป็นคลาสย่อยโปรโตคอลจะเป็นไปตาม Superclass:

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

อย่างไรก็ตามอย่างที่Steve Waddicorพูดถึงคุณอาจต้องการ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"]
        }
    }
}