swift-基础-进阶1

属性

• 定义属性的时候，后面要加问号，因为有可能是nil
• 也可以定义的时候直接初始化，这样可以不加问号了（基本数据类型最好直接初始化，否则用到KVC的时候回崩，因为如果用问号的话，调用super.init不会给它开辟存储空间，会报找不到这个key的错误）
  • 如果在构造方法中对属性初始化了，那么在定义的时候可以不用问号或初始化，详见下面构造方法

lazy var array:[String] = {
    ["1","2","3"]
}
var name: String?
var age: Int = 0;

• （实际中很少用）重写属性的get和set方法:直接在属性后面接大括号，在里面写。注意还要定义个下划线的成员变量

var _name: String?
var name: String? {
    get{
        return _name
    }
    set{
        // newValue是系统提供的，只要重写set方法，就可以通过newValue拿到外界设置的值
        _name = newValue
    }
}

• （一般用的比较多的是这个）在属性调完自己的set方法后，会调用didSet方法，我们在这个方法里处理数据就可以了

var name: String? {
    didSet{
        print("didSet")
    }
}

• （了解）另外，还有willSet方法，在即将实现set方法的时候调用。用法类似。
• 计算属性：区别于上面的存储属性，它不具备存储功能，对应OC的readOnly

var age: Int?{
    get{
        return 10
    }
}

• 示例

@IBOutlet weak var tableView: UITableView!

属性的懒加载

• 在定义的前面加个lazy，并且初始化，即是懒加载
  • 注意后面必须加圆括号，意思是只要获取array，就会执行这个闭包来获取array，执行闭包后面需要加圆括号

lazy var array:[String] = {
    ()->[String]
    in
    return ["1","2","3"]
}()

• 简写，如果闭包没有形参，那么in和in之前的可以省略

lazy var array:[String] = {
    return ["1","2","3"]
}()

• 注意点：懒加载必须用var，不能用let（用let表示常量，必须有初始值，懒加载的意思是后面再赋值，常量不能后面再赋值）
• 懒加载的另一种写法：用函数 （如果懒加载非常复杂，会采用这个方式）
  • 这里调用函数加上self是因为懒加载要保证函数调用者没有被释放（可以理解为固定写法）
  • 这个写法说明闭包即是函数，函数即是闭包

lazy var array:[String] = self.loadArray()
func loadArray() -> [String]
{
    return ["1","2","3"]
}

• 一些示例

    private lazy var popoverAnimate = {

        return PopoverAnimate()

    }()
    // 简写

    private lazy var popoverAnimate = PopoverAnimate()
    private lazy var previewLayer: AVCaptureVideoPreviewLayer = AVCaptureVideoPreviewLayer(session: self.session)

类的构造方法

• 在Swift中。如果重写父类的方法，要加上override修饰。比如这里重写Person类的init方法

var name: String?
var age: Int = 3
override init() {
    name = "lhj"
    age = 3
}

• 注意swift中支持方法的重载，只要方法的参数个数或者数据类型不同，那么系统就认为是两个方法，此时不需要override
• Swift规定，一个对象创建出来，它的所有属性必须有值。因此，如果其属性不是可选，且没有初始化，那么重写它的init方法的时候必须给他的属性赋值
• 自定义带参数的构造方法:为了区分参数和属性，属性前一般要带上self
  • Swift中self一般就用于这两个地方：闭包和这里

init(name: String, age: Int){
    self.name = name
    self.age = age
    super.init()
    // 注意：Swift语法规定，一定要初始化完当前类之后才能初始化父类，也就是不能把super.init()写在前面
    // 注意：不一定是调用super.init(),需要调用当前类设计的构造方法。比如UIViewController是super.init(nibName: nil, bundleL nul),点进去看注释会发现是指定的构造方法（designated）
    // 调用完super.init()之后才能调用对象方法
    setupUI()
}

• 注意，只要自定义了构造方法，系统自带的构造方法就会失效。（也就是说如果自定义了构造方法，那么就只能用自定义的了，除非再重写系统的构造方法）

// 最简单的重写系统的构造方法
override.init(){
    super.init()
}

构造方法前的修饰符convenience

• 如果构造方法前面没有convenience，代表是一个初始化构造方法（指定构造方法）

• 如果有convenience，代表是一个便利构造方法

• 两者区别：指定构造方法中必须对所有的未初始化的并且非可选属性进行初始化,而便利构造方法不用，因为它依赖于指定构造方法（在内部会调用指定构造方法）

• 给系统的类添加构造方法，一般都是便利的，因为不知道它有多少属性要初始化

convenience init(imageName: String, backgroundImage: String)

    {

        self.init()

        setImage(UIImage(named:"tabbar_compose_icon_add"), forState: UIControlState.Normal)

        setImage(UIImage(named: "tabbar_compose_icon_add_highlighted"), forState: UIControlState.Highlighted)

        setBackgroundImage(UIImage(named:"tabbar_compose_button"), forState: UIControlState.Normal)

        setBackgroundImage(UIImage(named:"tabbar_compose_button_highlighted"), forState: UIControlState.Highlighted)

        sizeToFit()

    }

重写initWithFrame

    // 通过代码创建时调用

    // Swift规定，只要重写了initWithFrame方法，那么必须也重写initWithCoder

    override init(frame: CGRect) {

        super.init(frame: frame)

        setup()

    }

    

    // 通过xib创建时调用

    required init?(coder aDecoder: NSCoder) {

        // 系统对initWithCoder的默认实现会报一个致命错误

        // 因为Swift不推荐一个控件又通过xib又通过代码来创建

        fatalError("init(coder:) has not been implemented")

        // 当然也可以不管系统推荐，自己来

        setup()

    }

字典转模型：用KVC

• 注意：在构造方法中调用KVC必须先调用super.init()。因为只有调用这个，系统才会为属性分配存储空间

init(dict:[String : AnyObject]){
    super.init()
    setValuesForKeysWithDictionary(dict)
}

• MJExtension还没有Swift版，所以用KVC字典转模型，但是如果不一一对应key，会崩
• Swift解决了这个问题：只要你重写下面这个方法即可，它还会把没找到的key给你列出来

override func setValue(value: AnyObject?, forUndefinedKey key: String) {
}

快速打印属性

• OC中是用description属性
• Swift中是重写description属性(是个计算性的属性)
• 如果是计算型属性，get可以省略
• 重写完之后，外界直接打印这个类就可以打印出各个属性了。print(Person)

override var description: String{
    get{
        return "name = \(name),age = \(age)"
    }
}
// 简写后

override var description: String{
    return "name = \(name),age = \(age)"
}

• 如果这个类有几十个属性，一个个写还是烦，可以用下面这个方法

let array = ["name","age"]
override var description: String{
    let dict = dictionaryWithValuesForKeys(array)
    return "\(dict)"
}

完整的模型实例

class UserAccount: NSObject {

    

    // MARK: - 属性

    var access_token: String?

    var expires_in: Int = 0

    var uid: String?

    var user: User?    

    // 缓存account。类方法中需要调用的属性前必须加static

    private static var account: UserAccount?

    private static let filePath = "userAccount.plist".cachesDir()

    

    // MARK: - 创建方法

    init(dict: [String: AnyObject]) {

        super.init()

        self.setValuesForKeysWithDictionary(dict)

    }

    // 如果有模型属性（模型套模型），那么在这里拦截setValue方法，转模型
    override func setValue(value: AnyObject?, forKey key: String) {

        if key == "user" {

            user = User(dict: value as! [String: AnyObject])

            return

        }

        super.setValue(value, forKey: key)

    }

    // 当KVC发现没有对应的key时就会调用

    override func setValue(value: AnyObject?, forUndefinedKey key: String) {

        

    }

    

    // 外界直接打印此类的对象即可查看对象的各个属性

    override var description: String{

        let array = ["access_token","expires_in","uid"]

        let dict = dictionaryWithValuesForKeys(array)

        return "\(dict)"

    }

    
    // 用于从沙盒加载保存的模型数据

    required init?(coder aDecoder: NSCoder) {

        self.access_token = aDecoder.decodeObjectForKey("access_token") as? String

        self.expires_in = aDecoder.decodeIntegerForKey("expires_in")

        self.uid = aDecoder.decodeObjectForKey("uid") as? String

    }

    

    // MARK: - 外部控制方法

    func saveAccount() -> Bool {

        // 对象方法中要调用静态属性，需要用类来获取

        KSLog(UserAccount.filePath)

        

        return NSKeyedArchiver.archiveRootObject(self, toFile: UserAccount.filePath)

    }

    

    class func loadAccount() -> UserAccount? {

        

        if account != nil {

            KSLog("从缓存中成功获取账号")

            return account

        }

        

        // 没有缓存的account，则尝试去读取

        account = NSKeyedUnarchiver.unarchiveObjectWithFile(filePath) as? UserAccount

        KSLog("尝试从沙盒加载账号")

        return account

    }

    

    class func isLogin() -> Bool {

        return UserAccount.loadAccount() != nil

    }

}

// 遵循NSCoding，用于保存模型数据到沙盒

extension UserAccount: NSCoding

{

    // MARK: - NSCoding

    func encodeWithCoder(aCoder: NSCoder) {

        aCoder.encodeObject(access_token, forKey: "access_token")

        aCoder.encodeInteger(expires_in, forKey: "expires_in")

        aCoder.encodeObject(uid, forKey: "uid")

    }

}

单例

• 一般写法见视频
• 独有写法：
  • 这么写也是懒加载的。但是懒加载别用这个，用上面的
  • 这么写的意思是定义一个常量并且初始化赋值成功，但是因为是常量，因此只能赋值一次
  • 因此注意要用let，let本身线程安全的

    // 需要一些初始化就这么写
    static let shareInstance: NetworTool = {

        let instance = NetworTool()

        return instance

    }()
    // 简写

    static let shareInstance: NetworTool = NetworTool()
// 外界调用

NetworTool.shareInstance