泛型编程
泛型是一种参数化类型的机制（类型占位符），为算法和类型的实现提供了更高的复用性、更强的安全型、更好的性能。
泛型支持包括：函数、类、结构、枚举
类型参数的实例化：
“泛型类型的实例化”即用实际类型替换占位符。泛型类型参数实例化的过程可以采用自动类型推断。
Swift采用编译时泛型模型，即在编译时进行泛型类型的实例化，产生新的类型码或函数码。
如果类型参数是值类型，泛型实例化会为不同的值类型生成不同的类型码（尺寸不同）。
如果类型参数是引用类型，泛型实例化会为所有不同的引用类型生成同一份类型码（基于同等尺寸的指针）。
协议的关联类型：
通过typealias可以为protocol定义一到多个关联类型。
在实现协议时，可将关联类型设置为泛型类型参数（或自动类型推断）。
协议的关联类型可以看作是支持“泛型版的协议”。
泛型约束：
类型约束为泛型类型参数提供了更多的功能约定。
Swift 要求显式的类型约束，编译器在泛型类型参数实例化时会检查约束的有效性。
泛型类型约束支持两类约束：基类约束、协议约束。
Where子句约束：指定关联类型必须符合某种协议、或者和其他关联类型相等。
//泛型函数
func swapT(inout a:T, inout b:T)
{
var tmp = a
a = b
b = tmp
}
var a:Double = 2.0
var b:Double = 3.0
swapT(&a, &b)
struct Student {
var no:Int
}
var sa = Student(no:100)
var sb = Student(no:101)
swapT(&sa, &sb)
//泛型类型
class Stack{
var items = [T]()
func push(items:T){
items.append(item)
}
func pop() ->T{
return items.removeLast()
}
}
var stack1 = Stack()
stack1.push(10)
stack1.push(20)
stack1.push(30)
函数类型与闭包
函数类型：
定义：(参数类型1,参数类型2,...)->返回值类型
函数类型是一种引用类型，类似于函数指针。可以将函数类型应用于任何使用类型的地方：变量、参数、返回值。
函数类型实例化支持：全局函数、嵌套函数、成员函数（实例方法与静态方法）
func addString(s1:String, sSex s2:String, sAge s3:String)->String{
return "Name is" + s1 + "and sex is" +s2+"and age is" + s3
}
var addSome:(String,String,String)->String = addString
let anotheraddSome = addString
闭包：
一对花括号“{}”包裹着的代码块就是一个闭包。
闭包表达式语法：
{ (parameters) -> returnType in
statements
}
闭包可以定义参数和返回值。
参数：常量、变量、inout、可变参数、元组类型。
in关键字：表示闭包的参数和返回值类型定义已经完成。
数组sort函数对字符串数组进行排序：
let names = ["Lily", "Anna", "Duty", "Poly", "Gray"]
func compareName(s1:String, s2:String) -> Bool {
return s1 < s2
}
var sortedArray = names.sort(compareName)
sortedArray = names.sort({(s1:String,s2:String)->Bool in return s1 < s2})
用for in遍历，打印元素值
var arrayValue = "array value:"
for index in sortedArray{
arrayValue += (index+",")
}
print(arrayValue)
简化后的闭包表达式：
sortedArray = names.sort(>)
使用for in循环，打印元素值
结果为：
trailing闭包
//声明一个使用闭包作为参数的函数
fun someFunction(someBag:()->()){//函数体}
//不使用trailing
someFunction({
//闭包语句
//闭包语句
//闭包语句
})
//使用trailing
someFunction(){
//如果函数只有闭包表达式一个参数，可以省略"()"
//闭包主体
}
类型扩展
扩展(extension)
扩展是向一个已有的类、结构体或枚举类型添加新的功能。
extension String {
func reverseString() -> String {
//do something if necessary
}
}
Swift中扩展可以：
（1）添加计算实例属性(computed property)和计算类属性
（2）定义实例方法和类方法
（3）提供新的构造器
（4）定义下标（subscript）
（5）定义和使用新的嵌套类型
（6）使一个遵守某个接口
扩展语法（Extension syntax）
声明扩展的关键字extension
extension SomteType {
// add sth
}
可以扩展类型时让类型遵守协议：
extension SomteType : SomeProtocol, OtherProtocol {
// do sth if necessary
}
扩展类型，添加计算属性：
// 添加长度单位属性
extension Double {
var km: Double {
return self * 1_000.0
}
var m: Double {
return self
}
var cm: Double {
return self / 100.0
}
var mm: Double {
return self / 1_000.0
}
var ft: Double {
return self / 3.28084
}
}
let oneInch = 25.4.mm
println("One inch is \(oneInch) meters")
let threeFeet = 3.ft
println("Three feet is \(threeFeet) meters")
let sum = 10.4.km + 122.5.km
内存管理
Swift中的ARC内存管理是对引用类型的管理，即对类所创建的对象采用ARC管理。而对于值类型，如整型、浮点型、布尔型、字符串、元组、集合、枚举和结构体等，是由处理器自动管理的，程序员不需要管理它们的内存。
一、引用计数
每个Swift类创建的对象都有一个内部计数器，这个计数器跟踪对象的引用次数，称为引用计数（Reference Count，简称RC）。当对象被创建的时候，引用计数为1，每次对象被引用的时候会使其引用计数加1，如果不需要的时候，对象引用断开（赋值为nil），其引用计数减1。当对象的引用计数为0的时候，对象的内存才被释放。
二、自动引用计数
举例：
class Employee {
var no : Int
var name : String
var job : String
var salary : Double
init(no : Int, name: String, job : String, salary : Double) {
self.no = no
self.name = name
self.job = job
self.salary = salary
print("员工\(name) 已经构造成功。")
}
deinit {
print("员工\(name) 已经析构成功。")
}
}
var ref1: Employee?
var ref2: Employee?
var ref3: Employee?
ref1 = Employee(no: 0001, name: "john", job :"Salesman", salary : 6600)
ref2 = ref1
ref3 = ref1
ref1 = nil
ref2 = nil
ref3 = nil
输出结果：
