1、闭包

 //       一般形式
        {(parameters)->returnType in
            statements
        }
    let callAdd1:(Int,Int)->Int = {
        (a : Int , b : Int ) -> Int in
        return a + b
    }
    
    print("callAdd1  \(callAdd1(1,2))" )
    
    //Swift可以根据闭包上下文推断参数和返回值的类型，所以上面的例子可以简化如下
    let callAdd2:(Int,Int)->Int = {
        (a , b) in
        return a + b
    }
    print("callAdd2  \(callAdd2(1,2))" )
    
    
    //单行表达式闭包可以隐式返回，如下，省略return
    let callAdd3 : (Int ,Int) -> Int = {a , b in
        a + b
    }
    
    //如果闭包没有参数，可以直接省略“in”
    let callAdd4 : () -> String = {
        return "132"
    }
    
    //这个是既没有参数也没返回值，所以把return和in都省略了
    let callAdd5 : () -> Void = {
        print("1234455")
    }

//起别名
//也可以关键字“typealias”先声明一个闭包数据类型。类似于OC中的typedef起别名

   typealias AddBlock = (Int,Int) -> Int    
    let addBlock : AddBlock = {(a,b) in
        return a + b
    }
    
    print( "起别名 \(addBlock(1,2))" )

//尾随闭包

    func testFunction(testBlock : () -> Void){
        testBlock()
    }
    
    //正常写法
    testFunction(testBlock: {
        print("//正常写法")
    })
    
    //尾随闭包写法
    testFunction(){
        print("//尾随闭包写法")
    }
    
    //也可以把括号去掉，也是尾随闭包写法。推荐写法
    testFunction {
        print("去掉括号的尾随闭包写法")
    }

2、构造函数

class Person: NSObject {

// var name : Optional<String>
var name : String?
var age : Int = 0   

override init() {
    // 重写之后是否需要调用super.init()
    // 可以不调用,如果没有主动调用,那么系统会默认调用
}

// 自定义构造函数,初始化时直接传入名字和年龄
init(name : String, age : Int) {
    self.name = name
    self.age = age
}

// 自定义构造函数,初始化时传入的字典
init (dict : [String : AnyObject]) {
    // 从AnyObject转成String/Int类型, as!/?
    // 如果Swift转OC类型时,使用 as
    name = dict["name"] as? String
    age = dict["age"] as! Int
}
/*
init (dict : [String : AnyObject]) {
    // 从AnyObject转成String/Int类型, as!/?
    // 如果Swift转OC类型时,使用 as
    
    // 如果通过KVC字典转模型,必须先调用super.init()
    super.init()
    self.setValuesForKeys(dict)
} */

}

调用

    let dict = ["name" : "lmj", "age" : "25"]
    let p = Person(dict: dict as [String : AnyObject])
    
    print("name:\(p.name!), age:\(p.age)")

3、懒加载

懒加载的介绍

swift中也有懒加载的方式
(苹果的设计思想:希望所有的对象在使用时才真正加载到内存中)
和OC不同的是swift有专门的关键字来实现懒加载
lazy关键字可以用于定义某一个属性懒加载

懒加载的使用

格式
lazy var 变量: 类型 = { 创建变量代码 }()

// 1>数据用到时再加载
// 2>数据只会加载

lazy var names : [String] = {
    // () -> [String] in
    
    print("加载数据")
    return ["wh", "y", "lj", "nj"]
}()

override func viewDidLoad() {
    super.viewDidLoad()
    
    print(names)  //加载数据   ["wh", "y", "lj", "nj"]
    print(names)  //["wh", "y", "lj", "nj"]
    print(names)  //["wh", "y", "lj", "nj"]
    
}