Tôi muốn tạo một chức năng trừu tượng trong ngôn ngữ swift. Có thể không?

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

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

Không có khái niệm trừu tượng trong Swift (như Objective-C) nhưng bạn có thể làm điều này:

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

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

Những gì bạn muốn không phải là một lớp cơ sở, mà là một giao thức.

protocol MyProtocol {
    func abstractFunction()
}

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

Nếu bạn không cung cấp trừu tượng trong lớp thì đó là một lỗi.

Nếu bạn vẫn cần lớp cơ sở cho các hành vi khác, bạn có thể làm điều này:

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

Tôi chuyển một số lượng mã hợp lý từ một nền tảng hỗ trợ các lớp cơ sở trừu tượng sang Swift và chạy vào đây rất nhiều. Nếu điều bạn thực sự muốn là chức năng của một lớp cơ sở trừu tượng, thì điều đó có nghĩa là lớp này đóng vai trò là một triển khai của chức năng lớp dựa trên chia sẻ (nếu không nó sẽ chỉ là một giao diện / giao thức) VÀ nó định nghĩa các phương thức phải được thực hiện bởi các lớp dẫn xuất.

Để làm điều đó trong Swift, bạn sẽ cần một giao thức và lớp cơ sở.

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

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

Lưu ý rằng lớp cơ sở thực hiện (các) phương thức được chia sẻ, nhưng không thực hiện giao thức (vì nó không thực hiện tất cả các phương thức).

Sau đó, trong lớp dẫn xuất:

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

Lớp dẫn xuất kế thừa sharedFunction từ lớp cơ sở, giúp nó đáp ứng phần đó của giao thức và giao thức vẫn yêu cầu lớp dẫn xuất thực hiện trừu tượng.

Nhược điểm thực sự duy nhất của phương thức này là vì lớp cơ sở không thực hiện giao thức, nếu bạn có một phương thức lớp cơ sở cần truy cập vào một thuộc tính / phương thức giao thức, bạn sẽ phải ghi đè lên lớp dẫn xuất và từ đó gọi lớp cơ sở (thông qua siêu) đi qua selfđể lớp cơ sở có một thể hiện của giao thức để thực hiện công việc của nó.

Ví dụ: giả sử rằng sharedFunction cần thiết để gọi trừu tượng. Giao thức sẽ giữ nguyên và các lớp bây giờ sẽ như sau:

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

Bây giờ, hàm chia sẻ từ lớp dẫn xuất đang đáp ứng phần đó của giao thức, nhưng lớp dẫn xuất vẫn có thể chia sẻ logic lớp cơ sở theo cách đơn giản hợp lý.

Đây có vẻ là cách "chính thức" để Apple xử lý các phương thức trừu tượng trong UIKit. Hãy xem UITableViewControllervà cách nó hoạt động UITableViewDelegate. Một trong những điều đầu tiên bạn làm là thêm một dòng : delegate = self. Vâng, đó chính xác là mẹo.

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

Kiểm tra với Playground để xem đầu ra.

Một số lưu ý

• Đầu tiên, rất nhiều câu trả lời đã được đưa ra. Tôi hy vọng ai đó tìm thấy tất cả các cách này.
• Câu hỏi thực sự là, để tìm ra một mô hình thực hiện:
  • Một lớp gọi một phương thức, phải được thực hiện trong một trong các lớp con dẫn xuất của nó (ghi đè)
  • Trong trường hợp tốt nhất, nếu phương thức không bị ghi đè trong lớp con, sẽ gặp lỗi trong thời gian biên dịch
• Vấn đề của các phương thức trừu tượng là, chúng là hỗn hợp của một định nghĩa giao diện và một phần của việc triển khai thực tế trong lớp cơ sở. Cả hai cùng một lúc. Vì swift là rất mới và được xác định rất rõ ràng, nó không có khái niệm như vậy mà là các khái niệm "ô uế" (chưa).
• Đối với tôi (một anh chàng Java nghèo khổ), vấn đề này thỉnh thoảng phát triển. Tôi đã đọc qua tất cả các câu trả lời trong bài đăng này và lần này tôi nghĩ rằng tôi đã tìm thấy một mô hình, có vẻ khả thi - ít nhất là với tôi.
• Cập nhật : Có vẻ như những người triển khai UIKit tại Apple sử dụng cùng một mẫu. UITableViewControllerthực hiện UITableViewDelegatenhưng vẫn cần phải được đăng ký như đại biểu bằng cách thiết lập rõ ràng delegatetài sản.
• Tất cả điều này được thử nghiệm trên Playground of Xcode 7.3.1

Một cách để làm điều này là sử dụng một bao đóng tùy chọn được xác định trong lớp cơ sở và trẻ có thể chọn thực hiện nó hay không.

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

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

Chà, tôi biết rằng tôi đến trễ trò chơi và tôi có thể đang tận dụng những thay đổi đã xảy ra. Xin lỗi vì điều đó.

Trong mọi trường hợp, tôi muốn đóng góp câu trả lời của mình, vì tôi thích thực hiện kiểm tra và các giải pháp với fatalError(), là AFAIK, không thể kiểm tra và những giải pháp có ngoại lệ khó kiểm tra hơn nhiều.

Tôi sẽ đề nghị sử dụng một cách tiếp cận khéo léo hơn. Mục tiêu của bạn là xác định một sự trừu tượng có một số chi tiết phổ biến, nhưng điều đó không được xác định đầy đủ, tức là (các) phương thức trừu tượng. Sử dụng một giao thức xác định tất cả các phương thức dự kiến ​​trong trừu tượng hóa, cả hai phương thức được xác định và cả các phương thức không được xác định. Sau đó tạo một phần mở rộng giao thức thực hiện các phương thức được xác định trong trường hợp của bạn. Cuối cùng, bất kỳ lớp dẫn xuất nào cũng phải thực hiện giao thức, có nghĩa là tất cả các phương thức, nhưng các phương thức là một phần của phần mở rộng giao thức đã có triển khai.

Mở rộng ví dụ của bạn với một hàm cụ thể:

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

Lưu ý rằng bằng cách này, trình biên dịch lại là bạn của bạn. Nếu phương thức không bị "ghi đè", bạn sẽ gặp lỗi khi biên dịch, thay vì phương thức bạn sẽ gặp phải fatalError()hoặc ngoại lệ sẽ xảy ra trong thời gian chạy.

Tôi hiểu những gì bạn đang làm bây giờ, tôi nghĩ rằng bạn nên sử dụng một giao thức tốt hơn

protocol BaseProtocol {
    func abstractFunction()
}

Sau đó, bạn chỉ cần tuân thủ giao thức:

class SubClass : BaseProtocol {

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

Nếu lớp của bạn cũng là một lớp con, các giao thức tuân theo Superclass:

class SubClass: SuperClass, ProtocolOne, ProtocolTwo {}

Sử dụng asserttừ khóa để thực thi các phương thức trừu tượng:

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

Tuy nhiên, như Steve Waddicor đã đề cập, có lẽ bạn muốn protocolthay thế.

Tôi hiểu câu hỏi và đang tìm kiếm giải pháp tương tự. Các giao thức không giống như các phương thức Trừu tượng.

Trong một giao thức bạn cần xác định rằng lớp của bạn tuân thủ giao thức đó, một phương thức trừu tượng có nghĩa là bạn phải ghi đè phương thức đó.

Nói cách khác, các giao thức là loại tùy chọn, bạn cần chỉ định lớp cơ sở và giao thức, nếu bạn không chỉ định giao thức, thì bạn không phải ghi đè các phương thức đó.

Một phương thức trừu tượng có nghĩa là bạn muốn có một lớp cơ sở nhưng cần phải thực hiện một hoặc hai phương thức của riêng bạn, không giống nhau.

Tôi cần hành vi tương tự, đó là lý do tại sao tôi đang tìm kiếm một giải pháp. Tôi đoán Swift đang thiếu tính năng như vậy.

Có một giải pháp khác cho vấn đề này, mặc dù vẫn còn một nhược điểm khi so sánh với đề xuất của @ jaumard; nó đòi hỏi một tuyên bố trở lại. Mặc dù tôi bỏ lỡ điểm cần thiết, bởi vì nó bao gồm việc ném trực tiếp một ngoại lệ:

class AbstractMethodException : NSException {

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

Và sau đó:

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

Bất cứ điều gì đến sau đó là không thể truy cập được, vì vậy tôi không hiểu tại sao buộc phải quay lại.

Tôi không biết là nó sẽ hữu ích, nhưng tôi gặp vấn đề tương tự với phương pháp trừu tượng trong khi cố gắng xây dựng trò chơi SpritKit. Điều tôi muốn là một lớp Động vật trừu tượng có các phương thức như move (), run (), v.v., nhưng tên sprite (và các chức năng khác) nên được cung cấp bởi các lớp con. Vì vậy, cuối cùng tôi đã làm một cái gì đó như thế này (đã thử nghiệm cho 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"]
        }
    }
}