协议扩展初始化器

Question

我想知道一个简单类中的初始化器的等效协议是什么，它只包含初始化功能并且只打算在具体类中扩展。

所以可能最简单的方法是显示代码 - 我正在寻找与以下内容等效的协议扩展：

import UIKit

class Thing {
    var color:UIColor
    init(color:UIColor) {
        self.color = color
    }
}
class NamedThing:Thing {
    var name:String
    init(name:String,color:UIColor) {
        self.name = name
        super.init(color:color)
    }
}
var namedThing = NamedThing(name: "thing", color: UIColor.blueColor())

我希望代码看起来像这样：

protocol Thing {
    var color:UIColor {get set}
}
extension Thing {
    init(color:UIColor) {
        self.color = color
    }
}
class NamedThing:Thing {
    var name:String
    var color:UIColor
    init(name:String,color:UIColor) {
        self.name = name
        self.init(color:color)
    }
}

我在其他 StackOverflow 问题中看到了建议的解决方案（例如 How to define initializers in a protocol extension?），但我不确定它们是否有效，也不确定它们是否专门解决了类初始化程序中附加参数的问题。

Answer 1

您必须提供有效的 init 链来创建类的实例，这会限制您对协议中的初始化程序的选择。

由于您的协议不能确定覆盖使用它的类的所有成员，因此您在协议中声明的任何初始化程序都需要将类的“未知”成员的初始化委托给该类提供的另一个初始化程序自己。

我调整了您的示例以使用基本的 init() 作为协议的委托初始化程序来说明这一点。

如您所见，这要求您的类在调用 init() 时为所有成员实现初始值。在这种情况下，我通过在每个成员的声明中提供默认值来做到这一点。而且，由于某些成员并不总是有实际的初始值，因此我将它们更改为自动展开选项。

为了让思考更有趣，你的类不能将初始化委托给协议提供的初始化器，除非它通过便利初始化器这样做。

我想知道所有这些限制是否值得麻烦。我怀疑您正在尝试使用协议，因为您需要在实现该协议的类之间一致地初始化一堆公共变量。也许使用委托类会提供比协议更简单的解决方案（只是一个想法）。

protocol Thing:AnyObject
{
    var color:UIColor! { get set }
    init()
}

extension Thing 
{    
    init(color:UIColor)
    {  
       self.init()
       self.color = color
    }
}

class NamedThing:Thing 
{
    var name:String!   = nil
    var color:UIColor! = nil

    required init() {}

    convenience init(name:String,color:UIColor) 
    {
        self.init(color:color)
        self.name = name
    }
}

Answer 2

protocol Thing {
    var color: UIColor {get set}
}

太棒了，没问题。

extension Thing {
    init(color: UIColor) {
        self.color = color
    }
}

没有。那永远行不通。这打破了太多的规则。第一个也是最重要的是，这并不一定会设置所有属性。考虑您的NamedThing。在这种情况下，name 是什么？如果color 设置器获取其他尚未设置的属性会发生什么？编译器还不能看到所有可能的实现，所以它不知道color 是否只是一个 ivar 或者更复杂的东西。不，这行不通。

真正的问题是“可以在具体类中扩展的抽象类”。忘记上课。忘记继承。 Swift 完全是关于组合和协议，而不是继承。

让我们考虑一下您在 cmets 中描述的示例（尽管在 Cocoa 中也没有“抽象类”）。让我们假设设置颜色实际上是很多您不想复制的代码。那没问题。你只需要一个函数。

import UIKit

protocol Thing {
    var color: UIColor {get set}
}

private extension Thing {
    static func colorForColor(color: UIColor) -> UIColor {
        // We don't really use the color directly. We have some complicated code that we don't want to repeat
        return color
    }
}

final class NamedThing: Thing {
    var name: String
    var color: UIColor

    init(name: String, color: UIColor) {
        self.name = name
        self.color = NamedThing.colorForColor(color)
    }
}

既然你的扩展的目的是处理部分初始化，让它计算你需要的部分。不要试图让它成为扩展中的初始化器，因为那样它就必须负责初始化所有东西，而当你将它与继承混合时，这很难正确地做到。

Answer 3

这是我对“代表课程”的想法。

这是我用来使用协议将存储变量添加到类的一种技术。

class ManagedColors
{
   var color:UIColor
   // other related variables that need a common initialisation
   // ...
   init(color:UIColor)
   {
      self.color = color
      // common initialisations for the other variables
   }
}

protocol ManagedColorClass
{
    var managedColors:ManagedColors { get }
}

extension ManagedColorClass 
{    
    // makes properties of the delegate class accessible as if they belonged to the
    // class that uses the protocol
    var color:UIColor { 
                        get { return managedColors.color } 
                        set { managedColors.color = newValue }
                      }    
}


// NamedThing objects will be able to use .color as if it had been
// declared as a variable of the class
//
// if you add more properties to ManagedColors (and the ManagedColorHost protocol)
// all your classes will inherit the properties as if you had inherited from them through a superclass
// 
// This is an indirect way to achive multiple inheritance, or add additional STORED variables with
// a protocol
//
class NamedThing:ManagedColorClass 
{
    var name:String
    var managedColors:ManagedColors 

    init(name:String,color:UIColor) 
    {
        managedColors = ManagedColors(color:color)
        self.name = name
    }
}

let red = NamedThing(name:"red", color:UIColor.redColor())
print(" \(red.name)  \(red.color)")

Answer 4

我得出的结论是，这个问题有点无法回答，因为协议扩展不能动态定义属性（除非它为属性提供默认值，或者将它们声明为隐式展开）。为了以更加面向协议的方式解决这个问题，它需要一种不同的方法，它仍然涉及在具体类中声明和初始化所有变量，例如：

import UIKit
protocol Colorable {
    var color: UIColor {get set}
}
protocol Nameable {
    var name: String {get set}
}
class ColoredNamedThing: Colorable, Nameable {
    var name: String
    var color: UIColor

    init(name: String, color: UIColor) {
        self.name = name
        self.color = color
    }
}

var coloredNamedThing = ColoredNamedThing(name: "Name", color: UIColor.redColor())

感谢@alain-t 的回答，我将接受它，因为它最接近地找到了我的问题的解决方案，尽管它包含隐式展开的属性。

也感谢@rob-napier 的贡献。