一、 变量初始化

1. 普通变量

 let a: NSInteger = 0
// let / var  可变/不可变， a 名字，NSInteger 类型

2. 私有属性private var a: NSDate = NSDate() 在var或者let前面加private

** 1. 字典 & 数组**

 //数组初始化（加泛型）
    var optionTitleStr : [String] = [String]()
    var array : Array<String> = [String]()
    
    //字典初始化
    var dictionary : [String : Any] = [String : Any]()
    var airports: Dictionary<String , Any> = [String : Any]()

**2. 懒加载 **

1. 与oc不同，在swift中的懒加载只会加载一次，在第一次用到的时候创建，此后即使为nil，也不会再次创建

2. 关键字 lazy 加一个私有标记 private，下面的例子表示懒加载私有数组属性，数组中存放了NSValue

  private lazy var array: [NSValue] = { () -> [NSValue] in
        let _array: [NSValue] = [NSValue]()
        return _array
    }()

3. 计算属性 & 只读计算属性
1.计算属性

1. 就是变相的getter 与setter方法，不过自身不开辟空间，他指向了本类中，同类型的属性

2. 也就是说： 计算属性 A （在内部取值赋值为B），在对A操作的时候，其实是操作的B
3. 注意在写set(newValue){} 方法中，是将newValue的值赋值给B，而不是A的值
4. 其调用的时机也是对A进行读写操作的时候调用对应的get 与Set方法，只是取值赋值对象不是A （一般用于给cell 中的 model赋值的时候 调用 从而给cell的subView赋值）

   ///懒加载B
    private lazy var B: [String] = [String]()
    /// (计算属性 操作的是B)
    var A: [String] {
        get {
            return B
        }
        set (newValue) {
            B = newValue
        }
    }

2.只读计算属性

1. 了解了计算属性，那么只要在A中不写set方法就是只读计算属性

2. 只读计算属性就是在外界，不能对其写入操作，只读不写

 ///懒加载B
    private lazy var B: [String] = [String]()
    /// (计算属性 操作的是B)
    var A: [String] {
        get {
            return B
        }
 }

4.willSet && didSet

前提：
自定义一个类，类中的属性重写了willSet, didSet 方法，他们会在这个属性赋值的时候调用。

//比如这个,初始值为true，在外界赋值为false
var willSet_didSet:Bool {
        willSet (newValue){
            //willSet:系统默认新值的名字是newValue你也可以在小括号里面修改
            print("newValue == ",newValue)
            print("willSet_didSet == ",willSet_didSet)
        }
        didSet (oldValue){
            //didSet:系统默认新值的名字是oldValue你也可以在小括号里面修改
            print("oldValue == ",oldValue)
            print("willSet_didSet == ",willSet_didSet)
        }
    }
------------------------------------------------------------------------
打印的结果为：
newValue ==  false
willSet_didSet ==  true
oldValue ==  true
willSet_didSet ==  false

区别：
1.willSet：在属性将要赋值的时候调用，可以拿到外界赋予的新值
2.didSet: 在属性已经赋值后调用，可以拿到原来的值
报错问题：

`1.必须在自定义类的初始化super.init之前进行（willSet或didSet）属性的初始化`
在super.init之前进行（willSet或didSet）属性的初始化
注意：
你在super.init初始化之前的赋值，不会走willSet、didSet方法

5. 对象的创建

1. 在构造方法中必须调用super.init()进行父类属性的初始化。

2. 在调用super.init()前，必须确保自身的属性都有值
3. 因为可选类型默认是nil /0 所以可以在super.init()后面再次初始化，而必选类型不行

    var a: String?
    var b: String?
    var c: String
//
    override init() {
//必选类型必须在super.init()前初始化，Property 'self.c' not initialized at super.init call ->
//可选类型无所谓
        b = "可选类型b"
        c = "必选类型c"
        super.init()
        a = "可选类型a"
    }

5. 单利对象的创建

1. 单利比oc简单了很多

  //创建一个定时器单利
    static let displayLink: CADisplayLink = {
        let _displayLink: CADisplayLink = CADisplayLink.init(target: self, selector: #selector(displayLinkFunc))
//这里面可以设置属性
        return _displayLink
    }()
    func displayLinkFunc() {
        print("刷新啦")
    }

5. 闭包的创建

1. 定义： var/let 闭包名 = { (行参) -> 返回值 in // 代码实现 }
   2.特点

3. 闭包是什么：

待续。。。。

动态创建对象

1、NSString.self()// 或者NSString.self.init()
2、let myClass = MyClass.Type.init()
3、let myClass = MyClass.self.init()
4、let type = NSClassFromString("MyClass") as! MyClass.Type然后通过type.init()来创建对象