haben, wie mehrere init() mit Swift

Question

Ist es möglich, wenn ja, wie, mehrere init ohne Parameter zu haben, in der Klasse wie folgt aus (die Zeichenfolge ist nur ein Beispiel):

aVar: String 

init() { 
    aVar = "simple init" 
} 

initWithAGoodVar() { 
    aVar = "Good Var!" 
} 

initWithFooBar() { 
    aVar = "Foo Bar" 
} 

Answer 1

Sie nicht mehr init s ohne Parameter haben kann, da sie nicht eindeutig sein würden, die init Methode, die Sie wollten benutzen. Alternativ könnten Sie die Anfangswerte auch an die Methode init übergeben. Nehmen wir das Beispiel aus Ihrer Frage:

class MyClass { 
    var myString: String 

    init(myString: String) { 
     self.myString = myString 
    } 
} 

let a = MyClass(myString: "simple init") 

Oder, wenn myString nur bestimmte Werte sein soll, könnten Sie ein verwenden enum:

class MyOtherClass { 
    enum MyEnum: String { 
     case Simple = "Simple" 
     case GoodVar = "GoodVar" 
     case FooBar = "FooBar" 
    } 

    var myString: String 

    init(arg: MyEnum) { 
     myString = arg.rawValue 
    } 
} 

let b = MyOtherClass(arg: .GoodVar) 
println(b.myString) // "GoodVar" 

Answer 2

können Sie haben verschiedene init mit unterschiedlichen parameters.When Sie eine neue Instanz der Klasse erstellen, wird die init-Methode mit den Argumenten aufgerufen Sie in

geben

Answer 3

Es ist nicht möglich, mehrere init zu haben, wobei die gleiche (oder nein) params.

Aber wenn Sie nach einer Möglichkeit, Objekte mit vordefinierten Zuständen zu konstruieren, können Sie statische Factory-Methoden verwenden:

class Test { 

    let aVar: String 

    init(aVar: String) { 
    self.aVar = aVar 
    } 

    static func initWithAGoodVar() -> Test { 
    return Test(aVar: "Good Var!") 
    } 

    static func initWithFooBar() -> Test { 
    return Test(aVar: "Foo Bar") 
    } 
} 

let test = Test.initWithFooBar() 
println(test.aVar) // Prints: "Foo Bar" 

Answer 4

Die initWithSomething ist ein Objective-C-Stil, und es wird nicht genau funktionieren wie das in Swift.

In Swift heißen alle Initialisierer init und können optional einige Parameter übernehmen.

Sie Standardwerte wie diese verwenden:

class Example { 
    var aVar: String 

    init(goodVar : String = "Good Var!") { 
     aVar = goodVar 
    } 
} 

let example1 = Example() 
println(example1.aVar) // prints "Good Var!" 

Doch dieser Ansatz wird nicht genau wie in Ihrem Beispiel arbeiten, denn wenn man die zweite init Methode einführen, dann ist es nicht eindeutig, was man wollte:

class Example { 
    var aVar: String 

    init(goodVar : String = "Good Var!") { 
     aVar = goodVar 
    } 

    init(fooBar : String = "Foo Bar") { 
     aVar = fooBar 
    } 
} 

let example1 = Example() // error: cannot invoke initializer… 

Ein besserer Ansatz könnte sein, Swift enum zu verwenden:

class Example { 
    enum ExampleType : String { 
     case GoodVar = "Good Var!" 
     case FooBar = "Foo Bar" 
    } 

    var aVar: String 

    init(type : ExampleType) { 
     aVar = type.rawValue 
    } 
} 

let example1 = Example(type: .GoodVar) 
println(example1.aVar) // "Good Var!" 

let example2 = Example(type: .FooBar) 
println(example2.aVar) // "Foo Bar" 

Dieser Ansatz bietet die gewünschte Flexibilität mit der normalen Swift-Syntax.