Protokoll-Erweiterung-Initialisierer

Müssen Sie eine gültige Kette von init für die Erstellung einer Instanz einer Klasse und das schränkt Ihre Optionen für die Initialisierungen in den Protokollen.

Seit Ihr Protokoll können nicht sicher sein, um alle Mitglieder der Klasse, der es verwendet, jeder Initialisierung erklären Sie in Ihrem Protokoll müssen delegieren Initialisierung des "unbekannten" Mitglieder der Klasse zu einer anderen Initialisierung zur Verfügung gestellt, die von der Klasse selbst.

Ich angepasst, Ihrem Beispiel zu illustrieren dies mit einem einfachen init() die delegation Initialisierer für das Protokoll.

Wie Sie sehen können, dies erfordert, dass Sie Ihre Klasse implementieren, die ursprünglichen Werte für alle Mitglieder, wenn init() aufgerufen wird. In diesem Fall hatte ich das, indem default-Werte in den einzelnen Mitgliedstaaten in der Erklärung. Und da gibt es nicht immer eine tatsächliche Startwert für einige Mitglieder, änderte ich Sie auf auto-unwrap Optionen.

Zu machen und denkt mehr interessant, Ihre Klasse kann nicht delegieren die Initialisierung eines Protokolls geliefert Initialisierer, es sei denn, er tut dies durch einen Komfort-Initialisierer.

Ich Frage mich, ob all diese Einschränkungen sind der Mühe Wert. Ich vermute, Sie versuchen, verwenden Sie ein Protokoll, weil Sie eine Reihe von gemeinsamen Variablen initialisiert werden konsequent zwischen Klassen, das Protokoll umzusetzen. Vielleicht mit einem delegate-Klasse wäre eine einfacherer Lösung als die Protokolle (nur ein Gedanke).

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

Hier ist, was ich im Sinn hatte, für die "delegate-Klasse".

Es ist eine Technik, die ich verwenden zum hinzufügen von gespeicherten Variablen zu einer Klasse mithilfe von Protokollen.

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