Swift 懒加载 / getter & setter / 构造函数 / 析构函数 / 单例

懒加载

lazy var demoView: UIView = {

    let v = UIView(frame: CGRectMake(10, 10, 100, 100))
    v.backgroundColor = UIColor.redColor()

    return v
}()

• 格式：

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

• 懒加载的写法本质上是定义并执行一个闭包

import UIKit

class ViewController: UIViewController {

    // 只有外界访问到listData的时候才会去执行闭包, 然后将闭包的返回值赋值给listData
    // 注意: 一定要记住闭包后面需要写上(), 代表执行闭包
    lazy var listData: [String]? = {
        ()->[String]
        in
        print("---")
        return ["a", "b", "why"]
    }()
    
    // 开发中这样写
    lazy var listData2: [String]? = {
        print("---")
        return ["a", "b", "why"]
        }()
    
    lazy var listData3: [String]? = self.test()
    func test() -> [String]
    {
        print("+++")
        return ["a", "b", "why1"]
    }
    
    override func touchesBegan(touches: Set, withEvent event: UIEvent?) {
        print(listData3)
        print(listData3)
        print(listData3)
        print(listData3)
    }
}

自定义 Person 类

class Person: NSObject {

    var name: String?
    var age: Int?
}

• 定义类

// 1、Person.swift
class Person: NSObject {

    // Swift中要求在创建一个类时必须给这个类中所有的属性进行初始化
    // 如果不能在创建对象时给这个类中所有的属性进行初始化, 那么这些属性必须是可选的
    // 如果已经在构造方法中对所有的属性进行了初始化, 那么这些属性就可以不是可选类型
    // 在给某一个类指定属性的数据类型时, 如果该属性是对象类型, 那么可以指定为可选类型
    // 如果该属性不是对象类型而是基本数据类型, 那么建议直接赋值为0
    var name: String?
    // 如果属性是基本数据类型, 并且是可选类型, 系统不会自动分配存储空间
    var age: Int = 0
    
  //    var name: String
  //    var age: Int
  
    // Person()
    override init() {
        // 注意: 在构造方法中必须先初始化本类再初始化父类
        name = "me"
        age = 30
        // 当我们重写一个类的构造方法时, 系统内部会悄悄咪咪的帮我们调用super.init()
        super.init()
        
    }

    // 自定义构造方法
    init(name: String, age: Int)
    {
        self.name = name
        self.age = age
   //        以下这一句代码, 能不写就不写
   //        super.init()
    }
    
    init(dict: [String: AnyObject])
    {
        // 注意:Swift中如果想在构造方法中使用KVC转换模型, 必须先调用 super.init()
        // 调用 super.init()的目的主要是为了给对象分配存储空间
        super.init()
        setValuesForKeysWithDictionary(dict)
    }

    // Swift中打印对象会调用下面这个属性
    override var description: String {
   //        return "name = \(name), age = \(age)"
        let property = ["name", "age"]
        let dict = dictionaryWithValuesForKeys(property)
        return "\(dict)"
    }
}

// 2、viewController.swift
 import UIKit
 class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // 注意: Swift开发中一般情况下不用导入头像文件, 因为只要所有的文件都在一个命名空间中那么就可以直接使用
        // 默认情况下一个项目的命名空间就是项目名称, 而在同一个项目下的所有文件都在同一个命名空间中
        
  //        let p = Person()
  //        let p = Person(name: "me", age: 50)
        
        // 如果自定义一个类, 并且没有重写构造方法, 那么系统会提供默认的构造方法
        // 如果自定义一个类, 并且自定义了构造方法, 那么系统不会提供默认的构造方法
  //        let p = Person(name: "me", age: 50)
  //        let p = Person()
        
        let p = Person()
        print(p)
    
        print(self)
    }
}

getter & setter

var _name: String?

var name: String? {
    get {
        return _name
    }
    set {
        _name = newValue
    }
}

• 在 Swift 中以上形式的 getter & setter 很少用

didSet

• 在 OC 中，我们通常希望在给某一个变量赋值之后，去做一些额外的操作
• 最经典的应用就是在自定义 Cell 的时候，通过模型的设置方法完成 Cell 的填充

var length: Int? {
    didSet {
        timeStr = String(format: "%02d:%02d:%02d", arguments: [length! / 3600, (length! % 3600) / 60, length! % 60])
    }
}
var timeStr: String?

计算型属性

var title: String {
    get {
        return "Mr " + (name ?? "")
    }
}

• 只实现 getter 方法的属性被称为计算型属性，等同于 OC 中的 ReadOnly 属性
• 计算型属性本身不占用内存空间
• 不可以给计算型属性设置数值
• 计算型属性可以使用以下代码简写

var title: String {
    return "Mr " + (name ?? "")
}

构造函数

init(dict: [NSObject: AnyObject]) {
    name = dict["name"] as? String
    age = dict["age"] as? Int
}

析构函数

deinit {
    print("88")
}

单例

Swift 单例

import UIKit

class NetworkTools: NSObject {
//    func == -
//    class func == +
    /*
    static var onceToken: dispatch_once_t = 0;
    static var _instance: NetworkTools?
    
    class func shareNetworkTools() -> NetworkTools {
        print(onceToken)
        dispatch_once(&NetworkTools.onceToken, {
            _instance = NetworkTools()
        })
        return _instance!
    }
    */
    
    /*
    static let _instance: NetworkTools =  NetworkTools()
    class func shareNetworkTools() -> NetworkTools {
        return _instance
    }
    override init() {
        print("++++++")
    }
    */
    
    // 如果在Swift中编写单例, 推荐使用如下写法
    // 而且苹果有统一的命名规范, 但凡是单例统一是用shareInstance
    static let shareInstance: NetworkTools =  NetworkTools()
}

OC 单例

// 1. .h文件
#import 

@interface NetworkTools : NSObject

+ (instancetype)shareNetworkTools;
@end

// 2. .m文件
#import "NetworkTools.h"

@implementation NetworkTools

+ (instancetype)shareNetworkTools
{
    static NetworkTools *_instance;
    // onceToken默认等于0, 只要执行一次之后就不等于0了, 原理是通过判断onceToken是否等于0决定是否需要执行block
    static dispatch_once_t onceToken;
    NSLog(@"%ld", onceToken);
    dispatch_once(&onceToken, ^{
        _instance = [[NetworkTools alloc] init];
    });
    return _instance;
}
@end