swift - 继承父工厂方法

Question

我有 A 类及其继承自 A 的子类 B。

现在，我在 A 中有一个类方法，它从某个带有“inout”的地方获取实例，并检查它是否为 nil，如果不是，则用必要的参数填充它。例如:

class A
{
    class func fillInstance(inout instance : Self, parameters : [String]) -> Self
    {
          guard let instance = instance else
         {
             return Self(parameters : parameters)
         }

         return instance
    }
}

现在，当然没有任何有 Self 的东西是无效的 :)

我需要一种方法使其有效。在 Swift 中有可能吗？

这里的一切都是虚构的。我只需要能够实现类方法的想法，该类方法可以由子类继承，并且允许根据调用该类方法的类实例化实例。我不想检查类型，因为它可以在子层次结构中继承很多次(我的意思是它可以变成 A -> B -> C -> D -> E.... 并且都继承一个来自另一个)。请帮助:)

Answer 1

你是对的，链式赋值不会携带用作参数的类类型。但是您可以使用泛型来解决这个问题:

 class A
 {
    class func fillInstance<T:A>(instance : T, parameters : [String]) -> T
    { 
       // do your stuff here
       instance.filledContent["A.fillInstance"] = "\(parameters)"
       return instance 
    }

    class func fillInstance<T:A>(instance : T?, parameters : [String]) -> T?
    {
       if instance != nil 
       { 
         let existing:T = T.fillInstance(instance!, parameters:parameters)
         return existing
       }
       return nil
    } 

    var filledContent:[String:String] = [:]
 }

 class B:A
 {
    func showContent() -> String { return "Showing: \(filledContent)" }

    override class func fillInstance<T:A>(instance : T, parameters : [String]) -> T
    { 
      instance.filledContent["B.fillInstance"] = "B Specific Filling"
      return A.fillInstance(instance, parameters:parameters) 
    }
 }

 let anInstanceOfA = A()

 A.fillInstance(anInstanceOfA, parameters: ["A->Param","To A"]).filledContent
 // ["A.fillInstance": "["A->Param", "To A"]"]

 let anInstanceOfB = B()

 A.fillInstance(anInstanceOfB, parameters: ["A->Param","To B"]).showContent()
 // "Showing: ["A.fillInstance": "["A->Param", "To B"]"]"

 var optionalA:A? = A()

 A.fillInstance(optionalA, parameters: ["A->Param","To A?"])?.filledContent
 // ["A.fillInstance": "["A->Param", "To A?"]"]
 B.fillInstance(optionalA, parameters: ["B->Param","To A?"])?.filledContent
 // ["A.fillInstance": "["B->Param", "To A?"]"]
 optionalA = nil
 A.fillInstance(optionalA, parameters: ["A->Param","To A?(nil)"])?.filledContent
 // nil

 var optionalB:B? = B()
 A.fillInstance(optionalB, parameters: ["A->Param","To B?"])?.showContent()
 // "Showing: ["B.fillInstance": "B Specific Filling", "A.fillInstance": "["A->Param", "To B?"]"]"
 B.fillInstance(optionalB, parameters: ["B->Param","To B?"])?.showContent()
 // "Showing: ["B.fillInstance": "B Specific Filling", "A.fillInstance": "["B->Param", "To B?"]"]"
 optionalB = nil
 A.fillInstance(optionalB, parameters: ["A->Param","To B?(nil)"])?.showContent()
 // nil
 B.fillInstance(optionalB, parameters: ["B->Param","To B?(nil)"])?.showContent()
 // nil

请注意，无论您使用哪个类函数，编译器总是执行与作为参数给定的实例的类对应的类函数。我不确定那是你想要的，但是再一次，我无法想象这样一种场景，你只想用适用于 A 的逻辑部分填充 B 的实例(而不是在B覆盖)。