Swift 笔记3

一.三大特性

• 封装
• 继承
  1.重写父类方法 需要加上 override
• 多态
  1.必须要有继承
  2.必须要有重写
  3.必须是父类指针指向子类对象
• (重载)
  1.参数类型不同
  2.参数个数不同

二.自动引用计数

• 当有一个强引用指向某个对象时,该对象的引用计数会自动 + 1
• 当强引用消失时,引用计数会自动 - 1
• 当引用计数为0时,该对象会被销毁

循环引用 的解决

    1.weak       和OC中的 __weak一样 是弱引用  当指向的对象销毁时,会自动指向nil
    2.unowned    和OC中的 __unsefe_unretained   当对象销毁时依然指向原来的位置(容易引起野指针)

三.可选链

• 如果可选的目标有值,就调用成功
• 如果没有值,则调用返回空nil

   // OC对象结构体的成员属性不能直接赋值
   titleLabel?.frame.origin.x = 0

四.协议 protocol

• 定义协议和遵守协议

// 1.定义协议
protocol SportProtocol { 
     func playBasketball() 
     func playFootball()
}
// 2.遵守协议
// 注意:默认情况下在swift中所有的协议方法都是必须实现的,如果不实现,则编译器会报错
class Person : SportProtocol { 
     var name : String? var age : Int = 0
   // 实现协议中的方法 
     func playBasketball() { 
         print("人在打篮球") 
     }
     func playFootball() { 
         print("人在踢足球") 
    }
}

• 协议之间的继承

protocol CrazySportProtocol {      
      func jumping()
}
protocol SportProtocol : CrazySportProtocol {
     func playBasketball()   
     func playFootball()
}

• 协议中方法的可选 需加 @objc 和 optional 关键字

// 1.定义协议
@objc
protocol SportProtocol {
    func playBasketball()
    optional func playFootball()
}
// 2.遵守协议
class Person : SportProtocol {
    var name : String?
    var age : Int = 0
    // 实现协议中的方法
    @objc func playBasketball() {
        print("人在打篮球")
    }
}

• 代理协议

1.定义协议属性 用 weak 且协议后面需 : class 才不会报错
protocol BuyTicketProtocol : class {
    func buyTicket()}class Person {    // 1.定义协议属性
    weak var delegate : BuyTicketProtocol
    func goToHeFei(){
        delegate?.buyTicketing()
        print("去北京")
    }
}class Huangniu: BuyTicketDelegate {
    func buyTicketing() {
        print("买票")
    }
}
//代理对象
//设置代理时 没有self   需要先 let 创建代理对象  然后再 设置代理 = 代理对象
let h = Huangniu()
let p = Person()
p.delegate = h
p.goToHeFei()    

五.闭包 (类似OC中的Block)

• block的写法:

    类型:    返回值(^block的名称)(block的参数)
    值:
    ^(参数列表) {
        // 执行的代码
    };

• 闭包的写法:

    类型:(形参列表)->(返回值)
    技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值
    值:
    {
        (形参) -> 返回值类型 in
        // 执行代码
    }

• 闭包的循环引用

/*
 需要用到self的地方:
     1.如果某一个方法中,有局部变量和成员变量产生歧义,可以使用self进行区分
     2.如果在闭包中使用到当前对象的方法或者属性,都需要加self
 */

// 解决方案一:
        weak var weakself : ViewController? = self
        httpTool?.loadData({ (jsonData) -> () in
        weakself?.view.backgroundColor = UIColor.redColor()
        })
// 解决方案二:(推荐)
        httpTool?.loadData({[weak self] (jsonData) -> () in            self?.view.backgroundColor = UIColor.redColor()
        })

六.懒加载

• 格式
  lazy var 变量: 类型 = { 创建变量代码 }()
• 懒加载的使用

// 懒加载的本质是,在第一次使用的时候执行闭包,将闭包的返回值赋值给属性
// lazy的作用是只会赋值一次
    lazy var array : [String] = {
        return ["why", "lmj", "lnj"]
    }()
     lazy var btn : UIButton = {
        let tempBtn = UIButton()
        tempBtn.setTitle("按钮", forState: .Normal)
        return tempBtn
    }()

七.常见注释

• 单行注释
  // 注释内容
• 多行注释

/* 
(与OC不同  可以多行嵌套多行注释) 
*/

• 文档注释
  // 注释内容
• 分组注释
  // MARK:-

八.访问权限

• Swift 中的访问控制模型基于模块和源文件这两个概念
• private : 修饰源文件,在当前源文件中可以访问
• internal : 内部的,修饰整个项目,在整个项目中都可以进行访问,并且默认修饰的就是internal
• public : 修饰整个项目,可以跨框架使用
  (在class 和 func前面加)

九.处理异常 (三种方式)

// 3.异常的处理三种方式
// 3.1.try方式,需要手动处理异常do {
    let result = try readFileContent("abc")} catch {
    print(error)}
// 3.2.try?方式,不处理异常,如果出现了异常,则返回一个nil.没有异常,则返回对应的值
// 最终返回结果为一个可选类型let result = try? readFileContent("abc")
// 3.3.try!方法,告诉系统该方法没有异常.
// 注意:如果出现了异常,则程序会崩溃
    let result = try! readFileContent("abc")

示例
// 1.定义异常enum FileReadError : ErrorType {
    case FileISNull
    case FileNotFound
}
// 2.改进方法,让方法抛出异常
func readFileContent(filePath : String) throws -> String {
    // 1.filePath为""
    if filePath == "" {
        throw FileReadError.FileISNull
    }
    // 2.filepath有值,但是没有对应的文件  
    if filePath != "/User/Desktop/123.plist" {        throw FileReadError.FileISNull    }    // 3.取出其中的内容    return "123"}

十.桥接

• OC调用swift

1.直接写入一个头文件:  项目名字-Swift.h      
#import "项目名字-Swift.h"

2.在swift中 添加public关键字 在class和func前面
 (还是以OC格式书写)

• swift调用OC

1.建立桥接文件  Bridge.h  里面放 .h头文件
2.在项目中Build Settings 配置文件  搜索bird  
然后将Bridge.h路径存入(类似PCH文件)