标签：
/*
如果一个类、结构体或枚举类型的对象,在构造自身的过程中有可能失败,则为其定义一个可失败构造器,是非
常有用的。这里所指的“失败”是指,如给构造器传入无效的参数值,或缺少某种所需的外部资源,又或是不满
足某种必要的条件等。
为了妥善处理这种构造过程中可能会失败的情况。你可以在一个类,结构体或是枚举类型的定义中,添加一个或多个可失败构造器。其语法为在 init 关键字后面加添问号 (init?) 。
注意:可失败构造器的参数名和参数类型,不能与其它非可失败构造器的参数名,及其类型相同。
可失败构造器,在构建对象的过程中,创建一个其自身类型为可选类型的对象。你通过 return nil 语句,来表明可失败构造器在何种情况下“失败”。
注意:严格来说,构造器都不支持返回值。因为构造器本身的作用,只是为了能确保对象自身能被正确构建。所以即使你在表明可失败构造器,失败的这种情况下,用到了 return nil。也不要在表明可失败构造器成 功的这种情况下,使用关键字 return。
下例中,定义了一个名为 Animal的结构体,其中有一个名为 species的, String 类型的常量属性。同时该结构体还定义了一个,带一个 String类型参数 species 的,可失败构造器。这个可失败构造器,被用来检查传入的参数是否为一个空字符串,如果为空字符串,则该可失败构造器,构建对象失败,否则成功。
*/
struct Animal {
let species: String
init?(species: String) {
if species.isEmpty {return nil }
self.species = species
}
}
//你可以通过该可失败构造器来构建一个Animal的对象,并检查其构建过程是否成功。
let someCreature =Animal(species:"Giraffe") // someCreature 的类型是 Animal?而不是 Animal
if let giraffe =someCreature {
print("An animal was initialized with a species of\(giraffe.species)")
}
// 打印 "An animal was initialized with a species of Giraffe"
//如果你给该可失败构造器传入一个空字符串作为其参数,则该可失败构造器失败。
let anonymousCreature = Animal(species: "")
// anonymousCreature 的类型是 Animal?, 而不是 Animal
if anonymousCreature ==nil {
print("The anonymous creature could not be initialized")
}
// 打印 "The anonymous creature could not be initialized"
//注意:空字符串(如 "" ,而不是 "Giraffe" )和一个值为 nil 的可选类型的字符串是两个完全不同的概念。上例中的空字符串( "" )其实是一个有效的,非可选类型的字符串。这里我们只所以让 Animal的可失败 构造器,构建对象失败,只是因为对于 Animal 这个类的 species 属性来说,它更适合有一个具体的值,而不是空字符串。
//枚举类型的可失败构造器
//你可以通过构造一个带一个或多个参数的可失败构造器来获取枚举类型中特定的枚举成员。还能在参数不满足枚
//举成员期望的条件时,构造失败。
//下例中,定义了一个名为TemperatureUnit的枚举类型。其中包含了三个可能的枚举成员( Kelvin , Celsius ,和 Fahrenheit )和一个被用来找到 Character值所对应的枚举成员的可失败构造器:
enum TemperatureUnit {
case Kelvin, Celsius, Fahrenheit
init?(symbol: Character) {
switch symbol {
case "K":
self = .Kelvin
case "C":
self = .Celsius
case "F":
self = .Fahrenheit
default:
return nil }
} }
//你可以通过给该可失败构造器传递合适的参数来获取这三个枚举成员中相匹配的其中一个枚举成员。当参数的值不能与任意一枚举成员相匹配时,该枚举类型的构建过程失败:
let fahrenheitUnit = TemperatureUnit(symbol: "F")
if fahrenheitUnit !=nil {
print("This is a defined temperature unit, so initialization succeeded.")
}
// 打印 "This is a defined temperature unit, so initialization succeeded."
let unknownUnit = TemperatureUnit(symbol: "X")
if unknownUnit ==nil {
print("This is not a defined temperature unit, so initialization failed.")
}
// 打印 "This is not a defined temperature unit, so initialization failed."
//带原始值的枚举类型的可失败构造器
//带原始值的枚举类型会自带一个可失败构造器 init?(rawValue:) ,该可失败构造器有一个名为 rawValue的默认参 数,其类型和枚举类型的原始值类型一致,如果该参数的值能够和枚举类型成员所带的原始值匹配,则该构造器构造一个带此原始值的枚举成员,否则构造失败。
//因此上面的 TemperatureUnit的例子可以重写为:
enum TemperatureUnit1: Character {
case Kelvin = "K", Celsius = "C", Fahrenheit = "F"
}
let fahrenheitUnit1 = TemperatureUnit1(rawValue: "F")
if fahrenheitUnit1 !=nil {
print("This is a defined temperature unit, so initialization succeeded.")
}
// prints "This is a defined temperature unit, so initialization succeeded."
let unknownUnit1 = TemperatureUnit1(rawValue: "X")
if unknownUnit1 ==nil {
print("This is not a defined temperature unit, so initialization failed.")
}
// prints "This is not a defined temperature unit, so initialization failed."
//类的可失败构造器
//值类型(如结构体或枚举类型)的可失败构造器,对何时何地触发构造失败这个行为没有任何的限制。比如在前面的例子中,结构体 Animal的可失败构造器触发失败的行为,甚至发生在 species属性的值被初始化以前。
//而对类而言,就没有那么幸运了。类的可失败构造器只能在所有的类属性被初始化后和所有类之间的构造器之间
//的代理调用发生完后触发失败行为。
//下面例子展示了如何使用隐式解析可选类型来实现这个类的可失败构造器的要求:
class Product {
let name: String!
init?(name: String) {
self.name = name
if name.isEmpty {return nil }
}
}
//上面定义的 Product类,其内部结构和之前 Animal结构体很相似。 Product 类有一个不能为空字符串的 name 常量属性。为了强制满足这个要求, Product类使用了可失败构造器来确保这个属性的值在构造器成功时不为空。
//毕竟, Product是一个类而不是结构体,也就不能和 Animal一样了。 Product 类的所有可失败构造器必须在自己失败前给 name 属性一个初始值。
//上面的例子中, Product类的 name 属性被定义为隐式解析可选字符串类型( String! )。因为它是一个可选类型,所以在构造过程里的赋值前, name属性有个默认值 nil 。用默认值 nil意味着 Product 类的所有属性都有一个合法的初始值。因而,在构造器中给 name属性赋一个特定的值前,可失败构造器能够在传入一个空字符串时触发构造过程的失败。
//因为 name属性是一个常量,所以一旦 Product类构造成功, name 属性肯定有一个非 nil的值。即使它被定义为 隐式解析可选类型,也完全可以放心大胆地直接访问,而不用考虑 name 属性是否有值。
if let bowTie =Product(name: "bow tie") {
// 不需要检查 bowTie.name == nil
print("The product‘s name is\(bowTie.name)")
}
// 打印 "The product‘s name is bow tie"
//构造失败的传递
//可失败构造器允许在同一类,结构体和枚举中横向代理其他的可失败构造器。类似的,子类的可失败构造器也能
//向上代理基类的可失败构造器。
//无论是向上代理还是横向代理,如果你代理的可失败构造器,在构造过程中触发了构造失败的行为,整个构造过
//程都将被立即终止,接下来任何的构造代码都将不会被执行。
//注意:可失败构造器也可以代理调用其它的非可失败构造器。通过这个方法,你可以为已有的构造过程加入构造失败的条件。
//下面这个例子,定义了一个名为 CartItem的 Product 类的子类。这个类建立了一个在线购物车中的物品的模型,它有一个名为 quantity的常量参数,用来表示该物品的数量至少为1:
class CartItem: Product {
let quantity: Int!
init?(name: String, quantity:Int) {
self.quantity = quantity
super.init(name: name)
if quantity < 1 { return nil }
}
}
//和 Product类中的 name 属性相类似的, CartItem类中的 quantity 属性的类型也是一个隐式解析可选类型,只不过由( String! )变为了( Int! )。这样做都是为了确保在构造过程中,该属性在被赋予特定的值之前能有一个默认的初始值nil。
//可失败构造器总是先向上代理调用基类, Product的构造器 init(name:) 。这满足了可失败构造器在触发构造失 败这个行为前必须总是执行构造代理调用这个条件。
//如果由于 name的值为空而导致基类的构造器在构造过程中失败。则整个 CartIem类的构造过程都将失败,后面的子类的构造过程都将不会被执行。如果基类构建成功,则继续运行子类的构造器代码。
//如果你构造了一个 CartItem对象,并且该对象的 name属性不为空以及 quantity属性为 1 或者更多,则构造成功:
if let twoSocks =CartItem(name: "sock", quantity:2) {
print("Item: \(twoSocks.name), quantity:\(twoSocks.quantity)")
}
// 打印 "Item: sock, quantity: 2"
//如果你构造一个 CartItem对象,其 quantity的值 0 , 则 CartItem 的可失败构造器触发构造失败的行为:
if let zeroShirts =CartItem(name: "shirt", quantity:0) {
print("Item: \(zeroShirts.name), quantity:\(zeroShirts.quantity)")
} else {
print("Unable to initialize zero shirts")
}
// 打印 "Unable to initialize zero shirts"
//类似的,如果你构造一个 CartItem 对象,但其 name的值为空, 则基类 Product的可失败构造器将触发构造失败 的行为,整个 CartItem的构造行为同样为失败:
if let oneUnnamed =CartItem(name: "", quantity:1) {
print("Item: \(oneUnnamed.name), quantity:\(oneUnnamed.quantity)")
} else {
print("Unable to initialize one unnamed product")
}
// 打印 "Unable to initialize one unnamed product"
//重写一个可失败构造器
//就如同其它构造器一样,你也可以用子类的可失败构造器重写基类的可失败构造器。或者你也可以用子类的非可失败构造器重写一个基类的可失败构造器。这样做的好处是,即使基类的构造器为可失败构造器,但当子类的构造器在构造过程不可能失败时,我们也可以把它修改过来。
//注意当你用一个子类的非可失败构造器重写了一个父类的可失败构造器时,子类的构造器将不再能向上代理父类的可失败构造器。一个非可失败的构造器永远也不能代理调用一个可失败构造器。
//注意:你可以用一个非可失败构造器重写一个可失败构造器,但反过来却行不通。
//下例定义了一个名为 Document的类,这个类中的 name属性允许为 nil 和一个非空字符串,但不能是一个空字符串:
class Document {
var name: String?
// 该构造器构建了一个name属性值为nil的document对象
init() {}
// 该构造器构建了一个name属性值为非空字符串的document对象
init?(name: String) {
if name.isEmpty {return nil }
self.name = name
}
}
//下面这个例子,定义了一个 Document类的子类 AutomaticallyNamedDocument。这个子类重写了父类的两个指定构造器,确保不论是通过没有 name参数的构造器,还是通过传一个空字符串给 init(name:)构造器,生成的实例中的 name 属性总有初始值 "[Untitled]" 。
class AutomaticallyNamedDocument: Document {
override init() {
super.init()
self.name ="[Untitled]"
}
override init(name:String) {
super.init()
if name.isEmpty {
self.name ="[Untitled]"
} else {
self.name = name
} }
}
//AutomaticallyNamedDocument 用一个非可失败构造器 init(name:) ,重写了父类的可失败构造器 init?(name:)。因为子类用不同的方法处理了 name 属性的值为一个空字符串的这种情况。所以子类将不再需要一个可失败的构造器,用一个非可失败版本代替了父类的版本。
//你可以在构造器中调用父类的可失败构造器强制解包,以实现子类的非可失败构造器。比如,下面的 UntitledDoc ument 子类总有值为 "[Untitled]"的 name 属性,它在构造过程中用了父类的可失败的构造器 init(name:)。
class UntitledDocument: Document {
override init() {
super.init(name:"[Untitled]")!
}
}
//在这个例子中,如果在调用父类的构造器 init(name:)时传给 name 的是空字符串,那么强制解绑操作会造成运行时错误。不过,因为这里是通过字符串常量来调用它,所以并不会发生运行时错误。
//可失败构造器 init!
//
//通常来说我们通过在 init关键字后添加问号的方式( init? )来定义一个可失败构造器,但你也可以使用通过在 init后面添加惊叹号的方式来定义一个可失败构造器 (init!) ,该可失败构造器将会构建一个特定类型的隐式解
//析可选类型的对象。
//你可以在 init?构造器中代理调用 init! 构造器,反之亦然。你也可以用 init? 重写 init! ,反之亦然。你还可以用 init 代理调用 init! ,但这会触发一个断言: init!构造器是否会触发构造失败?
标签：
原文地址：http://blog.csdn.net/guiguihao/article/details/51518305
