Hızlı bir dilde soyut bir işlev oluşturmak istiyorum. Mümkün mü?

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

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

Swift'de soyut kavramı yoktur (Objective-C gibi) ama bunu yapabilirsiniz:

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

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

İstediğin şey temel sınıf değil, protokoldür.

protocol MyProtocol {
    func abstractFunction()
}

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

Sınıfınızda abstractFunction sağlamazsanız bu bir hatadır.

Diğer davranışlar için hala temel sınıfa ihtiyacınız varsa, bunu yapabilirsiniz:

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

Soyut temel sınıfları destekleyen bir platformdan Swift'e makul miktarda kod aktarıyorum ve buna çokça giriyorum. Gerçekten istediğiniz şey soyut bir temel sınıfın işlevselliğiyse, bu, bu sınıfın hem paylaşılan tabanlı sınıf işlevselliğinin bir uygulaması (aksi halde yalnızca bir arabirim / protokol olacaktır) hem de uygulayıcı tarafından uygulanması gereken yöntemleri tanımladığı anlamına gelir. türetilmiş sınıflar.

Bunu Swift'de yapmak için bir protokole ve bir temel sınıfa ihtiyacınız olacak.

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

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

Temel sınıfın paylaşılan yöntemleri uyguladığını, ancak protokolü uygulamadığını unutmayın (çünkü tüm yöntemleri uygulamaz).

Sonra türetilmiş sınıfta:

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

Türetilmiş sınıf, sharedFunction'ı temel sınıftan miras alır ve protokolün bu bölümünü tatmin etmesine yardımcı olur ve protokol hala türetilmiş sınıfın abstractFunction uygulamasını gerektirir.

Bu yöntemin tek gerçek dezavantajı, temel sınıf protokolü uygulamadığından, bir protokol özelliğine / yöntemine erişime ihtiyaç duyan bir temel sınıf yönteminiz varsa, türetilmiş sınıftaki bunu geçersiz kılmanız ve buradan çağrı yapmanız gerekmesidir. temel sınıf (süper aracılığıyla) geçişi, selfböylece temel sınıf, işini yapmak için protokolün bir örneğine sahip olur.

Örneğin, sharedFunction'ın abstractFunction'ı çağırması gerektiğini varsayalım. Protokol aynı kalacak ve sınıflar artık şöyle görünecekti:

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

Artık türetilmiş sınıftan paylaşılan işlev, protokolün bu bölümünü karşılamaktadır, ancak türetilmiş sınıf yine de temel sınıf mantığını makul ölçüde basit bir şekilde paylaşabilir.

Bu, Apple'ın UIKit'te soyut yöntemleri ele alma şeklinin "resmi" yolu gibi görünüyor. Şuna UITableViewControllerve nasıl çalıştığına bir göz atın UITableViewDelegate. Yaptığınız ilk şeylerden biri bir satır eklemektir:delegate = self . İşte hile de bu.

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

Çıkışı görmek için Playground ile kontrol edin.

Bazı Açıklamalar

• İlk olarak, birçok cevap zaten verildi. Umarım birisi buna kadar her şeyi bulur.
• Asıl soru, uygulayan bir model bulmaktı:
  • Bir sınıf, türetilmiş alt sınıflarından birinde uygulanması gereken bir yöntemi çağırır (geçersiz kılınır)
  • En iyi durumda, yöntem alt sınıfta geçersiz kılınmamışsa, derleme süresi sırasında bir hata alın
• Soyut yöntemlerle ilgili olan şey, bir arayüz tanımının bir karışımı ve temel sınıftaki gerçek bir uygulamanın parçası olmalarıdır. İkisi de aynı anda. Swift çok yeni ve çok temiz tanımlandığı için, böyle bir rahatlığı değil, "kirli" kavramları (henüz) var.
• Bana göre (zavallı eski bir Java adamı), bu sorun zaman zaman gelişir. Bu gönderideki tüm cevapları okudum ve bu sefer, en azından bana uygun görünen bir model bulduğumu düşünüyorum.
• Güncelleme : Görünüşe göre Apple'daki UIKit uygulayıcıları aynı kalıbı kullanıyor. UITableViewControlleruygular, UITableViewDelegateancak yine de delegateözelliği açıkça ayarlayarak temsilci olarak kaydedici olması gerekir .
• Bunların hepsi Playground of Xcode 7.3.1'de test edildi

Bunu yapmanın bir yolu, temel sınıfta tanımlanan isteğe bağlı bir kapatma kullanmaktır ve çocuklar bunu uygulamayı ya da uygulamamayı seçebilirler.

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

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

Pekala, oyuna geç kaldığımı ve meydana gelen değişikliklerden yararlanıyor olabileceğimi biliyorum. Bunun için üzgünüm.

Her durumda, cevabıma katkıda bulunmak isterim, çünkü test yapmayı ve çözümleri ile fatalError() is, AFAIK, test edilemez ve istisnaları olanların test edilmesi çok daha zor.

Daha hızlı bir yaklaşım kullanmanızı öneririm . Amacınız, bazı ortak ayrıntıları olan, ancak tam olarak tanımlanmamış bir soyutlama, yani soyut yöntem (ler) tanımlamaktır. Soyutlamada hem tanımlanan hem de tanımlanmayan tüm beklenen yöntemleri tanımlayan bir protokol kullanın. Ardından, durumunuzda tanımlanan yöntemleri uygulayan bir protokol uzantısı oluşturun. Son olarak, türetilmiş herhangi bir sınıf, protokolü uygulamalıdır; bu, tüm yöntemler anlamına gelir, ancak protokol uzantısının parçası olanların uygulamalarına zaten sahiptir.

Örneğinizi tek bir somut işlevle genişletmek:

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

Bunu yaparak derleyicinin yine arkadaşınız olduğuna dikkat edin. Yöntem "geçersiz kılınmamış" ise, fatalError()çalışma zamanında meydana gelebilecek istisnalar veya karşılaşabileceğiniz istisnalar yerine derleme zamanında bir hata alırsınız .

Şu an ne yaptığını anlıyorum, bence bir protokol kullansan daha iyi olur

protocol BaseProtocol {
    func abstractFunction()
}

Ardından, sadece protokole uyarsınız:

class SubClass : BaseProtocol {

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

Sınıfınız aynı zamanda bir alt sınıfsa, protokoller Süper Sınıfı izler:

class SubClass: SuperClass, ProtocolOne, ProtocolTwo {}

assertSoyut yöntemleri zorlamak için anahtar kelimeyi kullanma :

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

Ancak, Steve Waddicor'un bahsettiği gibi, muhtemelen protocolonun yerine bir tane istiyorsunuz .

Soruyu anlıyorum ve aynı çözümü arıyordum. Protokoller Soyut yöntemlerle aynı değildir.

Bir protokolde, sınıfınızın bu tür bir protokole uygun olduğunu belirtmeniz gerekir; soyut bir yöntem, bu yöntemi geçersiz kılmanız gerektiği anlamına gelir.

Başka bir deyişle, protokoller isteğe bağlı bir türdür, temel sınıfı ve protokolü belirtmeniz gerekir, protokolü belirtmezseniz, bu tür yöntemleri geçersiz kılmanız gerekmez.

Soyut bir yöntem, bir temel sınıf istediğiniz, ancak aynı olmayan kendi yönteminizi veya iki yönteminizi uygulamanız gerektiği anlamına gelir.

Aynı davranışa ihtiyacım var, bu yüzden bir çözüm arıyordum. Sanırım Swift böyle bir özelliği eksik.

Bu sorunun başka bir alternatifi daha var, ancak @ jaumard'ın önerisiyle karşılaştırıldığında hala bir dezavantajı var; bir dönüş ifadesi gerektirir. Bunu talep etme noktasını kaçırmama rağmen, çünkü doğrudan bir istisna atmaktan ibarettir:

class AbstractMethodException : NSException {

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

Ve sonra:

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

Bundan sonra gelen her şeye ulaşılamaz, bu yüzden neden geri dönüşü zorladığını anlamıyorum.

Faydalı olacak mı bilmiyorum ama SpritKit oyununu oluşturmaya çalışırken soyutlanmış yöntemle benzer bir sorun yaşadım. İstediğim şey, move (), run () vb. Gibi yöntemlere sahip soyut bir Animal sınıfıdır, ancak hareketli grafik adları (ve diğer işlevler) sınıf çocukları tarafından sağlanmalıdır. Bu yüzden şöyle bir şey yaptım (Swift 2 için test edildi):

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