一 swift中的三大特性(重载;继承;多态)
1 继承
—-> 1.1 举个例子来说明 : 创建一个Person类,并且再创建一个老师和学生类,同时老师和学生类都继承Person类
//创建一个类
class Person {
var name = ""
var age = 0
//函数
func runing() {
print("人在跑步")
}
func study() {
print("人在学习")
}
}—-> 1.2 学生类 :
//继承
class Student : Person {
var sno : Int = 0
//重写父类的方法
override func study() {
print("学生在敲代码")
}
override init() {
super.init(name: "", age: 20)
}
}—-> 1.3 继承于Person的老师类
class Teacher: Person {
//重写: 子类对父类的方法不满意,重写进行实现
override func study() {
print("老师在备课")
}
}—-> 1.4 创建各自的对象并且调用方法
//创建对象
let stu = Student()
stu.sno = 110
stu.name = "xaiofeng"
stu.age = 19
stu.runing()
stu.study()
let tea = Teacher()
tea.study()
2 重载
—-> 2.1 重载条件 : 1> 参数的类型不同 2> 参数的个数不同 (满足其一就可以)
class MathTool {
func sum(num1 : Int, num2 : Int) ->Int {
return num1 + num2
}
func sum(num1 : Int, num2 : Int, num3 : Int) ->Int {
return num1 + num2 + num3
}
func sum(num1 : Int, num2 : Int, num3 : Int, num4 : Int) ->Int {
return num1 + num2 + num3 + num4
}
}
let mathTool = MathTool()
—-> 2.2 解读重载 : 在OC中我们是不能定义完全相同的方法名,即使参数不同也是不能定义的,但是在swift中可以,但是必须满足条件,并且满足其一就可以.由上面的代码我们可以看出: 参数类型相同;函数名称相同;仅仅不同的是参数的个数,这也是满足条件的.
3 多态
—-> 3.1 条件 : 1> 一定有继承 2> 一定有方法的重写 3> 一定是父类的指针指向子类的对象
func studentInNight(p : Person) {
p.study()
}
studentInNight(stu)
studentInNight(tea)4 补充(重写)
—-> 4.1 重写原因 : 子类对父类方法不满意,不能实现需求,子类通过重写方法来实现
—-> 4.2 重写的关键字 : override(必须要在函数的前面加上这个关键字)
—-> 4.3 特殊例子 : 创建一个不继承NSObject的类,设计构造方法,不需要加上override关键字
class Person {
var name = ""
var age = 0
//函数
func runing() {
print("人在跑步")
}
func study() {
print("人在学习")
}
//如果该类继承了NSObject,那么就必须在init前面加上override,因为init是父类的方法,这样做事属于重写
init() {
}
//设计构造方法
init(name : String, age : Int) {
self.name = name
self.age = age
}
}二 swift中的循环引用
1 Swift和OC一样,采用自动引用计数来管理内容
—-> 1.1 当有一个强引用指向某一个动向时,该对象的引用计数会自动+1
—-> 1.2 当该强引用消失时,引用计数会自动-1
—-> 1.3 当引用计数为0时,该对象会被销毁
—-> 1.4 在通常情况下,ARC是会自动帮助我们管理内存的
2 简单循环引用实例 : 直接创建一个Person类
class Person {
var name = ""
deinit {
print("Person-----deinit")
}
}
//创建类对应的对象
var person : Person? = Person()—-> 2.1 用图解析 不打印原因
—-> 2.2 解决这种原因 : 让person指向空
2 实例 : Person有一本书,书有一个主人(owner)
//定义两个类
class Person {
var name = ""
// person有一本书
var book : Book?
deinit {
print("Person-----deinit")
}
}
class Book {
var price = 0.0
//书有一个主人
var owner : Person?
deinit {
print("Book -- deinit")
}
}
//创建类对应的对象
var person : Person? = Person()
var book : Book? = Book()—-> 2.1 deinit并不会打印出结果
—-> 2.2 循环引用示意图:
—-> 2.3 此时你会发现计算将person = nil;book = nil都指向空,都不能解决问题,如下示意图
—-> 2.4 解决问题 : 让互相指向的其中一个指针变成弱指针就可以
—-> 2.5 需要写入的代码(满足其中一个就可以)
weak var book : Book?
unowned var book : Book = Book()三 swift中的可选链
1 可选链的概念
—-> 1.1 它的可选性体现于请求或调用的目标当前可能为空（nil）
—-> 1.1.1 如果可选的目标有值，那么调用就会成功；
—-> 1.1.2 如果选择的目标为空（nil），则这种调用将返回空（nil）
—-> 1.2 多次调用被链接在一起形成一个链，如果任何一个节点为空（nil）将导致整个链失效。
2 可选链的使用
—-> 2.1 在可选类型后面放一个问号，可以定义一个可选链。
—-> 2.2 这一点很像在可选值后面放一个叹号来强制拆得其封包内的值
—–> 2.2.1 它们的主要的区别在于当可选值为空时可选链即刻失败
—–> 2.2.2 然而一般的强制解析将会引发运行时错误。因为可选链的结果可能为nil,可能有值.因此它的返回值是一个可选类型.
—–> 2.2.3 可以通过判断返回是否有值来判断是否调用成功 : 1> 有值,说明调用成功 2> 为nil,说明调用失败
3 例子 : 人有一只狗,狗有一个玩具(toy),玩具有一个价格(price)
class Person {
var name = ""
var dog : Dog?
}
class Dog {
var name = ""
var toy : Toy?
}
class Toy {
var price : Double = 0.0 {
didSet {
print(price)
}
}
//玩具有一个具体行为
func rotating() {
print("玩具在转圈")
}
}
//创建对象
let person : Person = Person()
person.name = "xiaofeng"
let dog : Dog = Dog()
dog.name = "bigYellowDog"
let toy : Toy = Toy()
toy.price = 1.0
//让对象之间产生关系
person.dog = dog
dog.toy = toy—-> 3.1 需求一 : 给玩具赋值一个新值
第一种方式 :
person.dog!.toy!.price = 50.0解析一 : 该方法也是可以赋值的,但是比较危险,因为并不能确定dog!和toy!一定有值,如果强制解包,返回的是nil,就会造成程序崩溃
第二种方式 : (推荐使用可选链–>比较安全)
person.dog?.toy?.price = 50.0解析二 : 1.每一个可选进行判断,判断是否有值,如果有其中一个没有值,那么整个表达式返回一个nil 2.如果所有的可选类型都有值,那么整个表达式返回对应的类型,就可以给类型进行赋值
3.2 需求二 : 取出狗对象玩具的价格
第一种方法 :
let price = person.dog!.toy!.price解析一 : 该方法不安全,很有可能什么都去不到,返回一个nil,程序会崩溃
第二种方式 : (推荐使用可选链–>比较安全)
let price1 = person.dog?.toy?.price
print(price1)解析二 : 1.判断所有的可选类型是否有值,如果有其中一个没有值,那么整个可选链返回一个nil 2.如果可选类型都有值,那么返回一个具体的值
3.3 需求三 : 调用方法
第一种 : (也是可以实现的,但是比较麻烦)
person.dog!.toy!.rotating()
if let dog = person.dog {
if let toy = dog.toy {
toy.rotating()
}
}第二种 : 一句代码搞定
person.dog?.toy?.rotating()解析二 : 1.如果可选类型中有一个没有值,那么该方法就不会执行 2.反之,如果可选类型都有值,那么就会执行该方法
四 协议
1 协议的格式 : 协议的定义方式与类，结构体，枚举的定义都非常相似
protocol SomeProtocol {
// 协议方法
}2 遵守协议的格式
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 类的内容
// 实现协议中的方法
}3 协议的具体代码
—-> 3.1 定义协议
//定义协议
protocol CrazySportProtocol {
func jumping()
func jumpingSan()
}—-> 3.2 协议之间的继承关系
//协议之间的继承
protocol SportProtool : CrazySportProtocol {
func playBasketball()
func playFootball()
}—-> 3.3 准守协议和实现协议中的方法(默认遵守了协议,就必须实现协议中的方法)
//创建类遵守协议
class Person : SportProtool {
//遵守了协议就必须实现协议中的方法
func jumping() {
print("蹦极")
}
func jumpingSan() {
print("跳伞")
}
func playBasketball() {
print("打篮球")
}
func playFootball() {
print("踢足球")
}
}—-> 3.4 创建对象调用方法
//创建对象调用方法
var person = Person()
person.jumpingSan()
person.jumping()
person.playBasketball()
person.playFootball()—-> 3.5 代理在协议中的实现
//定义协议
protocol BuyTicketDelegate : class {
func buyTicketing()
}
//创建类
class Person {
var name = ""
//设置代理
weak var delegate : BuyTicketDelegate?
func goToBeiJing() {
//使用代理调用对应的方法
// delegate?.buyTicketing()
print("坐火车去北京")
}
}
//定义一个类,并且遵守协议
class YellowCattle : BuyTicketDelegate {
//将人设置里面的属性
var vipPerson : Person?
//实现协议中的方法
func buyTicketing() {
print("黄牛帮你买了一张票")
}
}
//创建对象
let person = Person()
person.name = "xiaofeng"
//创建黄牛对象
let huangniu = YellowCattle()
huangniu.vipPerson = person
//将黄牛设置为代理
person.delegate = huangniu
person.goToBeiJing()—-> 3.6 协议方法的可选择性(在swift中是没有协议可选择实现的,但是我们可以通过oc的方法来达到可选择实现的目的)
//将上objc和optional就代表了可以选择的实现
@objc
protocol SportsProtocol {
optional func jumping()
optional func jumpingSan()
}
class Person1 : SportsProtocol {
@objc func jumping() {
print("蹦极")
}
}
let p = Person1()
p.jumping()五 闭包
1 闭包简介
—-> 1.1 闭包和OC中的block非常相似
—-> —–OC中的block是匿名的函数
—–>—–Swift中的闭包是一个特殊的函数
—–>—–block和闭包都经常用于回调
2 block的使用
—-> 2.1 block的用法回顾
定义网络请求类 :
@interface HttpTool : NSObject
- (void)loadRequest:(void (^)())callBackBlock;
@end
@implementation HttpTool
- (void)loadRequest:(void (^)())callBackBlock
{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
NSLog(@"加载网络数据:%@", [NSThread currentThread]);
dispatch_async(dispatch_get_main_queue(), ^{
callBackBlock();
});
});
}
@end进行网络请求,请求到数据后利用block进行回调
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
[self.httpTool loadRequest:^{
NSLog(@"主线程中,将数据回调.%@", [NSThread currentThread]);
}];
}block写法总结:
block的写法:
类型:
返回值(^block的名称)(block的参数)
值:
^(参数列表) {
// 执行的代码
};3 闭包代替block使用
定义网络请求的类
class HttpTool: NSObject {
func loadRequest(callBack : ()->()){
dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
print("加载数据", [NSThread.currentThread()])
dispatch_async(dispatch_get_main_queue(), { () -> Void in
callBack()
})
}
}
}进行网络请求,请求到数据后利用闭包进行回调
override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
// 网络请求
httpTool.loadRequest ({ () -> () in
print("回到主线程", NSThread.currentThread());
})
}闭包写法总结:
闭包的写法:
类型:(形参列表)->(返回值)
技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值
值:
{
(形参) -> 返回值类型 in
// 执行代码
}4 闭包的简写
—-> 4.1 如果闭包没有参数,没有返回值.in和in之前的内容可以省略
httpTool.loadRequest({
print("回到主线程", NSThread.currentThread());
})—-> 4.2 尾随闭包写法:如果闭包是函数的最后一个参数,则可以将闭包写在()后面;如果函数只有一个参数,并且这个参数是闭包,那么()可以不写
httpTool.loadRequest() {
print("回到主线程", NSThread.currentThread());
}
// 开发中建议该写法
httpTool.loadRequest {
print("回到主线程", NSThread.currentThread());
}六 懒加载
1 OC中有懒加载,而在swift中也存在懒加载.苹果希望我们对所有的对象只有在使用的时候才真在的加到内存中,这样能大大的减少了内存的消耗.
2 懒加载格式
lazy var 变量: 类型 = { 创建变量代码 }()3 具体实例
—-> 3.1 懒加载写法一:(不推荐)
lazy var names : [String] = {
return ["xiaofeng", "it", "nb"]
}()
lazy var btn : UIButton = {
let tempBtn = UIButton()
tempBtn.setTitle("按钮", forState: .Normal)
return tempBtn
}()—-> 3.2 懒加载写法二 : (推荐)
lazy var button : UIButton = UIButton()七 访问权限(下面只介绍概念)
1 private : 只能在当前文件中访问,不能在其他文件中访问
2 internal : 内部的,修饰整个项目,在整个项目中都可以进行访问,并且默认情况下修饰就是internal
3 public : 是可以跨框架访问
八 异常处理
1 try : 手动处理异常,并且获取在调用方法过程中到底产生了怎么样的异常
2 try? : 自己不处理异常,让系统帮助我们处理
系统如何处理:
扫一扫
1246
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
