泛型编程

认知泛型 Generics
泛型是一种参数化类型的机制（类型站位符），为算法和类型的实现提供了：
更高的复用性
更强的安全型
更好的性能

泛型支持包括：函数、类、结构、枚举

//泛型类型
class Stack<T> {
    
    var items = [T]()
    
    func push(item: T) {
        items.append(item)
    }
    
    func pop() -> T {
        return items.removeLast()
    }
}

var stack1=Stack<Int>()  //将占位符T换成Int
stack1.push(10)
stack1.push(20)

var s2 = Stack<String>()  //使用String版本的函数
s2.push("Hello")
s2.push("World")
print(s2.dynamicType)  //将打印出泛型函数实例s2的动态类型，即Stack<String>

//泛型函数
func swap<T>(inout first:T, inout second:T){
    let temp=first
    first=second
    second=temp
}

var data1=100.87
var data2=200.22
swap(&data1, &data2) //泛型函数会根据参数的类型进行自动类型推断

//继承一个泛型类时，替换类型必须要和基类一样（这里都是T）
class ExStack<T> : Stack<T> {
        //...
}

//这里基类的占位符是U，子类的是T，这样不可以
class ExStack2<T> : Stack<U> {
        //...
}

//基类明确使用Int，子类用占位符这种情况是可以的
class ExStack3<T> : Stack<Int> {
        //...
}

//基类明确使用Int，子类不使用泛型也是可以的
class ExStack4 : Stack<Int> {
        //...
}

//总结：基类的占位符要么来自子类相同的站位符，要么在继承时先确定好占位符的具体类型。

类型参数实例化
“泛型类型的实例化”即用实际类型替换占位符。泛型类型参数实例化的过程可以采用自动类型推断
Swift采用编译时泛型模型，即在编译时进行泛型类型的实例化，产生新的类型吗或函数码。
如果类型参数是值类型，泛型实例化会为不同的值类型生成不同的类型码（尺寸不同）。
如果类型参数是引用类型，泛型实例化会为所有不同的引用类型生成同一份类型吗（因为引用类型都是相同等尺寸的指针）

协议的关联类型
通过typealias可以为protocol定义一到多个关联类型。
在实现协议时，可将关联类型设置为泛型参数（或自动类型推断）
协议的关联类型可以看作是支持“泛型版的协议”。

protocol Container {
    typealias ItemType //关联类型，也是一个占位符，自己命名
    
    func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType { get }
}

class Stack<T>: Container {
    
    typealias ItemType=T //ItemType是Container 里面的占位符
    
    var items = [T]()
    
    func push(item: T) {
        items.append(item)
    }
    
    func pop() -> T {
        return items.removeLast()
    }
    
    func append(item: T) {
        self.push(item)
    }
    
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> T {
        return items[i]
    }
}

泛型约束
类型约束为泛型类型参数提供了更多的功能约定
Swift要求显示的类型约束，编译器在泛型类型参数实例化时会检查约束的有效性。
泛型类型约束支持两类约束
基类约束
协议约束

//协议约束：Comparable用来约束占位符T必须支持可比较大小，即可以使用>或<符号
//如果将Comparable换成一个类，就叫基类约束， 内部只可以实现基类所支持的函数
func max<T:Comparable>(array:[T])-> T {
      var value = array[0]
      for index in 1..<array.count {
            if array[index] > value {
                value = array[index]
            }
       }
       return value
}

Where子句约束：指定关联类型必须符合某种协议、或者和其他关联类型相等。

//用where关键字，将T.ItemType约束成支持相等符号的实例
func find<T:Container where T.ItemType: Equatable>(sequence :T, item:T.ItemType)->Bool{ 
    
    for index in 0..<sequence.count{
        
        if(sequence[index]==item){
            return true
        }
    }
    return false
}

函数类型与闭包

**函数类型 **
函数类型定义：（参数类型1，参数类型2，...）->返回值类型

函数类型是一种引用类型，类似于函数指针。可以将函数类型应用于任何使用类型的地方：变量、参数、返回值。

函数类型实例化支持：
全局函数
嵌套函数
成员函数（实例方法 与 静态方法）

func add(x:Double, y:Double)->Double {
        return x+y
}

//变量compute是一个函数类型，该函数类型有两个Double参数，返回值是Double类型
var compute: (Double, Double)->Double

compute = add  //将函数add赋值给了相同函数类型变量compute，这里的add不用加（），add()表示调用函数。

let result = compute(100,200) //此时调用compute(100,200)等于调用add(100,200)

函数类型的内存图

上图compute在栈空间有一个地址，指向堆空间的内容，堆空间的内容有两个指针，一个是对象指针，如果是实例方法，这个指针指向的是实例对象的地址，如果是全局函数这个指针为0。第二个指针是函数指针，指向函数的地址。

认识闭包Closure
闭包是函数类型的实例，一段自包含的代码块，可被用于函数类型的变量、参数或返回值

三种闭包形式：
全局函数：具名函数，但不捕获任何值
嵌套函数：在函数内部嵌套定义具名函数，可捕获包含函数中的值
闭包表达式：匿名函数类型实例。不具名的代码块，可捕获上下文的值

闭包是引用类型，闭包变量拷贝具有引用语义。

闭包和函数类型实例拥有同样的内存模型。

//闭包表达式，{(first:Rectangle, second:Rectangle)->Bool in return first.width*first.length<=second.width*second.length} 就是一个函数闭包
rects.sort({(first:Rectangle, second:Rectangle)->Bool in
      return first.width*first.length<=second.width*second.length
})

闭包表达式

{ (参数1，参数2... )->返回值类型 in
     语句块
}

闭包表达式的几种简化缩写形式：
自动类型推断：省略参数类型和返回值类型。

rects.sort({ first, second in
      return first.width*first.length<=second.width*second.length
})

单表达式闭包可以省去return关键字。

rects.sort({ first, second in
   first.width*first.length<=second.width*second.length
})

使用参数缩略形式$0,$1...省略参数声明和in

rects.sort({ $0.width*$0.length<=$1.width*$1.length
})

将操作符函数自动推导为函数类型
尾随闭包：当闭包表达式为函数最后一个参数，可将其写在括号后。

//尾随闭包，如果只有一个参数，可以把（）去掉
//rects.sort()，如果有闭包参数将闭包参数放在最后
rects.sort {
      first, second in
      fitst.width*first.length<=second.width*second.length
}

自动闭包：不接受任何参数，直接返回表达式的值。允许延迟计算。

var cities = ["Beijing","Shanghai","New York", "Paris","London"]
print(cities.count)  //此时的城市数是5

let filter = { cities.removeLast() } //()->String 将闭包赋值给filter，此时还没有执行removeLast()

print(cities.count) //由于上一句并没有执行removeLast()此时的城市数还是5

print("Deleting \(filter())!") //执行了filter的闭包。 显示Deleting London!

print(cities.count) //此时的城市数是4, London被删除掉了

函数类型与闭包的变量捕获
函数类型和闭包可以捕获其所在上下文的任何值：
函数参数
局部变量
对象实例属性
全局变量
类的类型属性

//捕获实例属性
class Rectangle{
      var width = 0
      var length = 0
     
      func getComputHandler()-> ()->Int {
          return {
               return self.width*self.length //这个闭包就捕获了实例属性self.width和self.length
          }
      }
}

//捕获参数或局部变量
func addHandler(step: Int)-> ()->Int{
        var sum = 0
      return{
          sum +=step  //这里捕获了参数step和局部变量sum 
          return sum
      }
}

let addByTen = addHandler(10)

print(addByTen())  //显示结果 10
print(addByTen())  //显示结果 20
print(addByTen())  //显示结果 30

如果捕获值生存周期小于闭包对象（参数和局部变量），系统会将被捕获的值封装在一个临时对象里，然后再闭包对象上创建一个对象指针，指向该临时对象。

临时对象和闭包对象之间是强引用关系，生存周期跟随闭包对象。

扩展 Extension

扩展支持为现有类型增加功能（可以没有源代码），支持一下类型：类、结构、枚举、协议
除了不能增加实例存储属性和析构器外(因为扩展不能改变原来内的内存模型)，使用扩展可以增加：
计算属性（实例属性和类型属性）
类型存储属性
方法（实例化方法和类型方法）
初始化器
下标
为类型实现协议
内嵌类型

class Rectangle:Shape {
      var x:Int
      var y:Int
      var length:Int
      var width:Int

      init(x:Int, y:Int, length:Int, width:Int) {
        self.x = x
        self.y = y
        self.length = length
        self.width = width
       }
}

//对Rectangle类增加一个扩展
extension Rectangle {
      static var max = 100

     //增加了一个实例计算属性
      var area: Int {
            return self.length*self.width
      }
       
       //增加了一个方法
    func moveTo(x:Int, _ y:Int) {
         self.x = x
         self.y = y
    }
  
      //增加了一个新的便捷初始化器
    convenience init(x1:Int, y1:Int, x2:Int, y2:Int){
        let l = abs(x2 - x1)
        let w = abs(y2 - y1)
    }
}

使用扩展的注意点
扩展不可以增加实例存储属性，但可以增加类型的存储属性。换言之，扩展不能更改实例对象的内存模型。
扩展只能增加便捷初始化器，不能增加指定初始化器。
扩展中添加新的方法，但不可以override基类方法。
结构和枚举的扩展，如果实例方法更改self，需要声明mutating

协议与扩展
扩展实现协议：在为类型实现扩展时，增加实现某些协议。
实现过程中必须实现协议的所有成员。
也可以添加实现非协议的成员。

//定义协议
protocol Drawable {
        var discription: String{
            get
        }
        func draw()
}

//扩展实现协议,必须实现Drawable里的所有成员
extension Rectangle:Drawable{
      var discription:String{
          return"x=\(x), y=\(y), length=\(length), width=\(width)"
      }
      func draw() {
            print(self.discription)
      }
      //自己增加的非协议的成员实现
      func erase() {
            print("erase")
      }
 }

扩展协议类型：可以扩展协议来提供方法和属性的默认实现。
协议扩展内的成员都必须提供默认实现，可以调用原协议内的成员
所有遵守协议的类型自动继承这些默认实现，但可以提供自己独特的实现
扩展协议时，也可以添加where子句约束

//扩展协议类型
extension Drawable{
      //默认实现
      func encode()( {
            print("Drawable.encode")
            print(self.discription)
      }
}

使用扩展的建议
使用场景
适合在没有源代码的情况下，向已经封装的类中添加方法或属性。
为一个类在某些特殊场景下增加功能。
对于复杂的大型文件分割实现。

添加扩展
自己创建的类
系统的类
第三方库

内存管理

ARC是Swift默认的内存管理机制，其针对堆上的对象，由编译器自动生成操作引用计数的指令（retain或release）来管理对象的引用计数增加或减少。程序员无法手工控制。
哪些类型的对象受ARC管理：类class、闭包closure（存放在堆上的对象）
哪些对象不受ARC管理：基础数值类型，结构struct、枚举enum、元组tuple

关于Auto Release
Swift原生对象不支持autorelease消息，也就没有必要使用Autorelease Pool来管理内存峰值。

如果Swift调用Objective-C函数返回autorelease对象，那么如果出现内存峰值过高的风险，仍然需要使用Autorelease Pool来管理

Autorelease Pool在Swift中使用尾随闭包形式实现。

func useObjecAutoreleaseObject(){
        if let filepath = NSBundle.mainBundle().pathForResource("2015",ofType:"jpg") {
      for _ in 0..<5 {
            autoreleasepool {//在闭包内调用autoreleasepool，每当
                  for _ in 0..<1000 {
                        let data = NSData.dataWithContentsOfMappedFile(filepath)
                  }
            }
      }
}          

循环引用于内存泄漏
对象间的循环引用会造成ARC引用计数无法释放被引用的任何一个对象，从而造成内存泄漏。

//假设有一个Computer类，其中有个属性是Monitor类的实例。有一个Monitor类，其中有一个属性是Computer类的实例
var imac:Computer?
var screen:Monitor?
imac = Computer(name:"Jason's iMac")
screen = Monitor(no:29)

//造成循环引用
imac!.display = screen
screen!.device = imac

imac = nil
screen = nil //由于循环引用，这样并不能释放内存

循环引用的内存图

解决循环引用造成的内存泄漏有三种方式：
1.在合适的地方，手动将循环引用解除。

var imac:Computer?
var screen:Monitor?
imac = Computer(name:"Jason's iMac")
screen = Monitor(no:29)

imac!.display = screen
screen!.device = imac

imac!.display = nil //手动的释放了实例imac!中的引用
imac = nil
screen = nil //由于之前手动的释放了一边的引用，所以这里可以释放内存

2.如果允许对象引用为nil，可将引用声明为弱引用（weak）

 class Monitor{
      var no:Int
      weak var device:Computer? //设置成弱引用，弱引用使用时将不再让ARC计数加一，并且这个值可以为nil，如果Computer的实例提前释放的话
      init(no:Int) {
            self.no = no
            print("Monitor init")
      }
      deinit{
            print("Monitor deinit")
      }
}

弱引用内存图

3.如果不允许对象引用为nil，可将对象声明为无主引用（unowned）

class Monitor{
      var no:Int
      unowned var device:Computer //设置无主引用，使用时将不再让ARC计数加一，但是无主引用不可为nil，如果Computer的实例提前释放，将还会指向原来的地址，要确保不要访问，不然会抛出异常
      init(no:Int) {
            self.no = no
            print("Monitor init")
      }
      deinit{
            print("Monitor deinit")
      }
}

无主引用的内存模型

弱引用在对象被释放后，ARC会将引用设置为nil。无主引用在对象被释放后，ARC不会设置nil，访问时会抛运行时错误（空悬指针）。

闭包的内存管理
如果闭包满足以下两个条件，将产生循环引用，造成内存泄露：
1.闭包内使用实例成员，会捕获self，产生“从闭包对象->self的引用”。
2.将闭包对象设置为self的属性，产生“从self->闭包对象的引用”。

class Employee {
        var name:String
        var printer:(()->())? //设置一个闭包属性

        init(name:String) {
            self.name = name
            self.printer = { //初始化闭包值的时候又将self.name捕获了。之后又将这个捕获值赋值给了self里的属性printer，从而形成了循环引用
                  print("name: \(self.name)")
            }
            print("Employee init")
        }
}

闭包属性循环引用内存图

解决闭包产生的循环引用有以下方式：
1.手工解决循环引用

var employee:Employee?

employee?.printer = nil  //手动断开循环指针
employee = nil

2.在捕获列表中指定[weak self]弱引用

class Employee {
        var name:String
        var printer:(()->())? 

        init(name:String) {
            self.name = name
            self.printer = { 
                 [weak self] in //指定了弱引用，只有在闭包里面的捕获列表才可以这么设置                
                 print("name: \(self!.name)")
            }
            print("Employee init")
        }
}

weak self循环引用内存图

3.在捕获列表中指定[unowned self]无主引用

class Employee {
        var name:String
        var printer:(()->())? 

        init(name:String) {
            self.name = name
            self.printer = { 
                 [unowned self] in //指定了无主引用，只有在闭包里面的捕获列表才可以这么设置                
                 print("name: \(self.name)")
            }
            print("Employee init")
        }
}

unowned self循环引用内存图

Weak-Strong Dance
对象在弱引用或无主引用期间，随时“有可能”被释放，从而导致引用为nil，或者抛运行时错误。

为了避免在弱引用使用期间，对象被释放可能导致nil的问题，可以使用Weak-Strong Dance来解决，其核心是延长对象生存周期，确保对象不被释放，有两种方式：
1.将弱引用临时转换为“强引用局部变量”。

{ [weak self] in
  if let strongSelf = self {
      strongSelf.process("first process")
      usleep(500)
      strongSelf.process("second process")
  }
}

2.使用withExtendedLifetime函数来延长弱引用对象生存周期。

{ [weak self] in
   withExtendedLifetime(self) {
      self?.process("first process")
      usleep(500)
      self?.process("second process")
  }
}