本文大部分内容翻译至《Pro Design Pattern In Swift》By Adam Freeman，一些地方做了些许修改，并将代码升级到了Swift2.0,翻译不当之处望多包涵。
对象模版模式
这里我们将介绍一个对于面向对象编程来说非常基础的技术以至于不把它归类到设计模式里面－用类或结构体创建新对象。
Swift中的元组是一系列的值组合在一起，用起来也很方便和简单，但是它们却有一些限制。下面我们创建Command Line Tool 工程，请看main.swift文件。
main.swift
import Foundation
var products = [
("Kayak", "A boat for one person", 275.0, 10),
("Lifejacket", "Protective and fashionable", 48.95, 14),
("Soccer Ball", "FIFA-approved size and weight", 19.5, 32)
]
func calculateTax(product:(String, String, Double, Int)) -> Double {
return product.2 * 0.2
}
func calculateStockValue(tuples:[(String, String, Double, Int)]) -> Double {
return tuples.reduce(0, combine: {
(total, product) -> Double in
return total + (product.2 * Double(product.3))
})
}
print("Sales tax for Kayak: $\(calculateTax(products[0]))")
print("Total value of stock: $\(calculateStockValue(products))")
在上面的代码中，我们定义了一个元素是元祖类型的数组代表产品以及两个方法来操作它们。calculateTax方法接受一个元祖类型的参数用来计算价格的消费税，calculateStockValue方法对数组中所有的产品进行总价计算。执行代码，我们可以看见：
Sales tax for Kayak: $55.0
Total value of stock: $4059.3
设计模式要解决的问题大部分都是组件之间的紧密耦合。当一个在一个组件的内部去操作另一个组件时会产生紧密的耦合，或者，换一种说法，当你想变更一个组件而不需要去升级另一个组件才是设计模式所推崇和解决的。请看下图：
两个方法都跟元祖紧密的耦合在一起，不仅是它们定义参数的方式还是方法的内容。 当用元祖做参数的时候，元祖的大小，顺序，类型都必须完全匹配。在方法中，又用元祖的下标来获取值，这就导致更紧密的耦合。
下面你将看见当我删掉元祖中一个值会发生什么：
import Foundation
var products = [
("Kayak", 275.0, 10),
("Lifejacket", 48.95, 14),
("Soccer Ball", 19.5, 32)
]
func calculateTax(product:(String, String, Double, Int)) -> Double {
return product.2 * 0.2
}
func calculateStockValue(tuples:[(String, String, Double, Int)]) -> Double {
return tuples.reduce(0, combine: {
(total, product) -> Double in
return total + (product.2 * Double(product.3))
})
}
print("Sales tax for Kayak: $\(calculateTax(products[0]))")
print("Total value of stock: $\(calculateStockValue(products))")
我们删掉了元祖中关于产品描述的值，但是很显然我们现在跟着修改这两个方法。
理解对象模版模式
对象模版模式利用一个类或者是结构体来定义一个能够创建对象的模版。当组件需要一个对象时，它会通过指定模版的名称来请求Swift运行环境创建并且运行环境会根据需要来初始化这个对象。
第一步就是组件提供模版名称和一些要求的运行时数据请求Swift运行环境创建对象。 第二步，Swift运行环境会给要求的对象分配内存然后用模版来创建它，模版包含了用来设置对象的初始化状态的初始化方法。最后一步Swift运行环境将创建好的对象交给请求的组件。
实现对象模版模式
Product.swift
import Foundation
class Product {
var name:String
var price:Double
var stock:Int
init(name:String, description:String, price:Double, stock:Int) {
self.name = name
self.description = description
self.price = price
self.stock = stock
}
}
使用对象模版模式的好处
-
解耦
我们将代码做如下修改：
Product.swift
import Foundation
class Product {
var name:String
var description:String
var price:Double
var stock:Int
init(name:String, price:Double, stock:Int) {
self.name = name
self.price = price
self.stock = stock
}
}
main.swift
import Foundation
var products = [
Product(name: "Kayak", price: 275, stock: 10),
Product(name: "Lifejacket", price: 48.95, stock: 14),
Product(name: "Soccer Ball", price: 19.5, stock: 32)
]
func calculateTax(product:Product) -> Double {
return product.price * 0.2;
}
func calculateStockValue(productsArray:[Product]) -> Double {
return productsArray.reduce(0, combine: {(total, product) -> Double in
return total + (product.price * Double(product.stock))
})
}
我们更新了Product类将description属性删除了。最值得注意的是尽管我们修改了Product类，却对calculateTax方法和calculateStockValue方法没有任何影响。这是因为在Product类中每一个属性都是独立定义的并且这两个方法也没有操作description属性。
-
封装
用类或者结构体来定义数据模版最大的好处就是封装。封装允许数值和操作这些数值的逻辑以一个简单的方式联系起来。将数值和逻辑联系起来的话使得代码更有可读性。
Product.swift
import Foundation
class Product {
var name:String
var price:Double
var stock:Int
var stockValue:Double{
return self.price * Double(self.stock)
}
init(name:String, price:Double, stock:Int) {
self.name = name
self.price = price
self.stock = stock
}
func calculateTax(rate: Double) -> Double {
return self.price * rate
}
}
main.swift
...
func calculateStockValue(productsArray:[Product]) -> Double {
return productsArray.reduce(0, combine: {(total, product) -> Double in
return total + product.stockValue
})
}
...
这看着也许是简单的修改，但是重要的事情发生了：Product类现在有了公有描述(public presentation)和私有实现(private implementation)。
公有描述就是其他组件能够使用的API。任何组件都能设置和获取name，price和stock属性的值。公有描述也包括stockValue属性和calculateTax方法，但重要的是注意并不是指它们的实现。
阻止一个属性或者一个方法暴露它具体实现能够很容易的打破耦合，因为这样就使得其他组件的依赖变成不可能。例如我们将Proudct类中的calculateTax方法做下面的修改：
...
func calculateTax(rate: Double) -> Double {
return min(10, self.price * rate)
}
...
因为修改的内容是在Product类中，这个修改对于其他的组件来说是不可见的，所以可以看出其他组件不会对Product类的实现产生依赖。
-
进化的公有描述
Swift 中很重要的一个特型就是可以随着应用的改变你也可以进化类的公有描述。就目前来看，stock属性是一个可以设置任何Int类型值的存储属性，但是对于库存来说负数是没有任何意义的。Swift支持我们能够无缝的将存储属性修改成计算属性。
import Foundation
class Product {
var name:String
var price:Double
private var stockBackingValue:Int = 0
var stock:Int {
get {
return stockBackingValue
}
set {
stockBackingValue = max(0, newValue)
}
}
var stockValue:Double{
return self.price * Double(self.stock)
}
init(name:String, price:Double, stock:Int) {
self.name = name
self.price = price
self.stock = stock
}
func calculateTax(rate: Double) -> Double {
return min(10,self.price * rate)
}
}
我们定义了一个 stockBackingValue存储属性的变量来储存计算属性变量stock的值，stock的get方法仅仅是简单的返回stockBackingValue的值，但是set方法去用了max方法来保证当设定值是负数的时候用0来代替。
现在修改main.swift如下
main.swift
import Foundation
var products = [
Product(name: "Kayak", price: 275, stock: 10),
Product(name: "Lifejacket", price: 48.95, stock: 14),
Product(name: "Soccer Ball", price: 19.5, stock: 32)
]
func calculateTax(product:Product) -> Double {
return product.price * 0.2;
}
func calculateStockValue(productsArray:[Product]) -> Double {
return productsArray.reduce(0, combine: {(total, product) -> Double in
return total + product.stockValue
})
}
print("Sales tax for Kayak: $\(products[0].calculateTax(0.2))")
print("Total value of stock: $\(calculateStockValue(products))")
products[0].stock = -50
print("Stock Level for Kayak: \(products[0].stock)")
运行程序，得到下面结果：
Sales tax for Kayak: $10.0
Total value of stock: $4059.3
Stock Level for Kayak: 0
理解对象模版模式的陷阱
对象模版模式需要注意的陷阱就是模版的类型选择，好比当用类更合适的时候却使用了结构体。Swift的类和结构体有很多共性，但尤其注意的是结构体是值类型，类是引用类型。
