介绍与基础语法,学习笔记一

近年铺面没什么项目弄,Swift越来越多人用了,就和好把以前用OC写的体系用Swift语言写下,小小记录下。

简介

  • Swift 语言由苹果公司在 2016 年推出,用来撰写 OS X 和 iOS 应用程序
  • 2014 年,在 Apple WWDC 发布
    • 几家开心,几家愁
    • 愁者:只学Object-C的人
    • 欢腾者:之前做过java/python/js语言的人

壹 、获取有个别控件的最大Y坐标:

OC中是:

CGRectGetMaxX(某某控件.frame)

而Swift中是:

某某控件.frame.maxY

历史

  • 二〇〇九 年 7 月,苹果开发者工具部门主管 Chris Lattner 伊始初阶 Swift编制程序语言的设计工作
  • 用一年时光,实现核心架构
  • Swift 大致历经 4 年的开发期,二〇一六 年 6 月公布
  • 克里斯·拉特纳什么人?LLVM 项目标关键倡导者与小编之一Clang
    编写翻译器的撰稿人苹果公司『开发者工具』部门的主办领导Xcode、Instruments等编写翻译器团队Swift的绝超过51%基础架构均由他1位成功评价:大神中的大神牛逼中的牛逼

② 、符号运算:

斯维夫特的符号运算不算OC那么的包容,得转成同体系型的才行,举个例子,当你用Int类型的数加Float类型的数,如下例子

let numOne = 11;
let numTwo = 1.1;
let total = numOne + numTwo;

它肯定给您报 Binary operator ‘+’ cannot be applied to operands of type
‘Int’ and
‘Double’
,因为numOne是Int类型,而numTwo是Double类型。这么些时候你一旦想获得double类型的多寡,那么您只要把numOne转为double类型就足以了。
OC中是:

total = (Double)numOne + numTwo;

但Swift中是:

total = Double(numOne) + numTwo;

特点

  • 特点
    • 从它的语法中能看到Objective-C、JavaScript、C#、Python等语言的黑影
    • 语法简单、代码简洁、使用方便
    • 可与Objective-C混合使用
    • 提供了就如 Java
      的名字空间(namespace)、泛型、运算对象重载(operator
      overloading)
  • 为何设计斯维夫特语言
    • 让动用开发更简便、更快、更地西泮
    • 担保最后使用拥有更好的品质

叁 、模型的创导:

创建NSObject类型的swift文件,代码大概如下:

import UIKit

class SCInquireDataModel: NSObject {

    var testStr = String();

    override init() {//不可缺少的
        super.init()
    }
}

一初步作者忘了写 override
init(),平昔报错,提醒的又是些一无可取的,后边才察觉忘记实现这些方法。

重要性

  • 苹果近日在大力推广斯威夫特
  • 印度孟买理法大学的公开课近日也是接纳Swift在授课.因为今后斯威夫特必将代替OC
  • 题外话:大家同学去面试,面试官问是还是不是会斯威夫特,借使会,我们下个品种一向用斯威夫特来写.你能够教大家Swift.
  • 民用建议:
    • 先驾驭斯威夫特最中央的语法
    • 高档/特殊的机能随着学习的尖锐再浓密钻研
    • 纯属不要浮躁
      • Swift并不难
      • 可是语法和OC分化极度非常大
      • 比方是八个听一听,听不懂尽管了的心态.一定是学倒霉的
      • 一经想要学习,就信以为真听讲,好好演练

四 、懒加载的贯彻:

使用:lazy var xxx:type = {}(),例子如下

/** 懒加载*/
    lazy var firstLabel:UILabel = {
        let tempLabel = UILabel(frame: CGRect(x: 10, y: 5, width: kScreenWidth/3, height: 50));
        tempLabel.numberOfLines = 0;
        tempLabel.font = UIFont.systemFont(ofSize: 13);
        self.addSubview(tempLabel);
        return tempLabel;
    }()

能源网站

  • Playground是什么?
    • 从Xcode6伊始产出(Swift起始出现)
    • 翻译为:操场/游乐场
    • 对此学习斯威夫特基本语法万分便宜
      • 所见即所得
      • 语法本性产生变更时,能够高速查看.
  • 斯维夫特最中央的语法变化
    • 导入框架 import UIKit
    • 概念标识符时,必须表明该标识符是变量依旧常量
      • 扬言标识符的格式:变量/常量关键字 名称 : 数据类型
    • 语句截至时不要求加;
      • 要是同一行有七个语句,则依旧要求加
      • 不过不提出一行多条语句
    • Swift中的打字与印刷语句:print

⑤ 、容易宏的完毕:

1.创建Swift文件,选择iOS->Source->Swift File

2.将Foundation改为UIKit
3.装置宏定义

有关宏定义的想掌握越来越多的可以看swift下促成宏定义及DEBUG中使用自定义Logswift中的宏定义

哪些是常量和变量

  • 在Swift中规定:在概念八个标识符时必须明确表明该标识符是八个常量照旧变量
  • 应用let来定义常量,定义之后不得以修改
  • 动用var来定义变量,定义之后方可修改

⑥ 、UITableView纯代码落成:

1.懒加载创造UITableView

 //懒加载
    lazy var dataTableView = { () -> UITableView in
        let tempTableView = UITableView(frame: self.view.bounds, style: UITableViewStyle.plain);
        tempTableView.delegate = self;
        tempTableView.dataSource = self;
        tempTableView.rowHeight = 60;
        self.view.addSubview(tempTableView);

        let view = UIView();
        tempTableView.tableFooterView = view;
        tempTableView.register(UITableViewCell.self, forCellReuseIdentifier: "cell");

        return tempTableView;
    }()

2.兑现UITableViewDataSource代理协议

    /**
     UITableViewDataSource
     */
    func numberOfSections(in tableView: UITableView) -> Int {
        return 1;
    }
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return 5;
    }
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell:UITableViewCell = tableView.dequeueReusableCell(withIdentifier: "cell")!;
        cell.textLabel?.text = String(indexPath.row);
        return cell;
    }

因为是想开哪,就写到哪,所以有点乱,前几天方今就写到那,后边继续查找!!!

变量的中坚选用

import UIKitlet a : Int = 10// 错误写法,当一个字段定义为常量时是不可以修改的// a = 20var b : Int = 20// 因为b定义为变量,因此是可以修改的b = 30

常量和变量的采用注意:

  • 注意:

    • 在实际使用进程中,建议先定义常量,假设急需修改再修改为变量
    • 是指向的靶子不可以再展开修改.可是足以因此指针获得对象后,修改对象内部的属性

     // 注意:声明为常量不可以修改的意思是指针不可以再指向其他对象.但是可以通过指针拿到对象,修改其中的属性 // view : UIView = [[UIView alloc] init]; // Swift对象中不需要* var view : UIView = UIView() view = UIView() let view1 : UIView = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100)) view1.backgroundColor = UIColor.redColor() // 枚举类型的用法:类型.枚举的值 let btn : UIButton = UIButton(type: UIButtonType.Custom) btn.backgroundColor = UIColor.blueColor() btn.setTitle("按钮", forState: UIControlState.Normal) btn.frame = CGRect(x: 20, y: 20, width: 60, height: 30) view1.addSubview
    

斯威夫特类型的介绍

  • 斯维夫特中的数据类型也有:整型/浮点型/对象类型/结构体类型等等

  • 先精晓整型和浮点型

  • 整型

    • 有符号
      • Int8 : 有符号8位整型
      • Int16 : 有符号16位整型
      • Int32 : 有符号32位整型
      • Int64 : 有符号64位整型
      • Int : 和平台相关(暗许,也正是OC的NSInteger)
    • 无符号
      • UInt8 : 无符号8位整型
      • UInt16 : 无符号16位整型
      • UInt32 : 无符号32位整型
      • UInt64 : 无符号64位整型
      • UInt : 和平台相关(常用,相当于OC的NSUInteger)
  • 浮点型

    • Float : 三13位浮点型
    • Double : 64浮点型

    // 定义一个Int类型的变量m,并且赋值为10var m : Int = 10// 定义一个Double类型的常量n,并且赋值为3.14let n : Double = 3.14
    

斯威夫特中的类型推导

  • Swift是强类型的语言

  • 斯维夫特中其余三个标识符都有拨云见日的项目

  • 注意:

    • 假定定义1个标识符时有平素实行赋值,那么标识符前边的档次能够省略.
    • 因为Swift有档次推导,会自动依据前边的赋值来决定后边的标识符的数据类型
    • 能够经过option+鼠标左键来查看变量的数据类型

     // 定义变量时没有指定明确的类型,但是因为赋值给i一个20.20为整型.因此i为整型 var i = 20 // 错误写法:如果之后赋值给i一个浮点型数值,则会报错 // i = 30.5 // 正确写法 var j = 3.33 j = 6.66
    

斯维夫特中挑荆州运算

  • 斯威夫特中在拓展着力运算时必须有限匡助项目一致,不然会出错

    • 如出一辙档次之间才方可拓展览演出算
    • 因为Swift中从未隐式转换
  • 数据类型的转载

    • Int类型转成Double类型:Double
    • Double类型转成Int类型:Int

     let a = 10 let b = 3.14 // 错误写法 // let c = a + b // let c = a * b // 正确写法 let c = Double + b let d = a + Int
    

一. 支行的介绍

  • 支行即if/switch/三目运算符等判断语句
  • 通过分支语句能够决定程序的实行流程

二. if分支语句

  • 和OC中if语句有自然的分别

    • 看清句可以不加()
    • 在Swift的判断句中必须有拨云见日的真伪
      • 不再有非0即真
      • 必须有醒目标Bool值
      • Bool有八个取值:false/true

     // 演练一: let a = 10 // 错误写法: //if a { // print //} // 正确写法 if a > 9 { print } // 演练二: let score = 87 if score < 60 { print } else if score <= 70 { print } else if score <= 80 { print } else if score <= 90 { print } else { print } // 演练三: // 这个是可选类型,因为只有声明成可选类型后,才可以判断是否为空 // 可选类型会在后续讲解,可先了解即可 let view : UIView? = UIView() // 判断如果view有值,则设置背景 // 错误写法 //if view { // view.backgroundColor = UIColor.redColor() //} if view != nil { view!.backgroundColor = UIColor.redColor() }
    

三. 三目运算符

  • Swift 中的 三目 运算保持了和 OC 一致的风骨

    var a = 10var b = 50var result = a > b ? a : bprintln
    

四.guard的使用

  • guard是斯威夫特2.0新增的语法

  • 它与if语句十分接近,它设计的目标是拉长程序的可读性

  • guard语句必须带有else语句,它的语法如下:

    • 当规则表明式为true时候跳过else语句中的内容,执行语句组内容

     guard 条件表达式 else { // 条换语句 break } 语句组
    
  • 例子

     var age = 18 func online(age : Int) -> Void { guard age >= 18 else { print return } print } online
    

四.switch分支

switch的介绍
  • Switch作为挑选结构中必不可少的言辞也被投入到了斯威夫特中
  • 假若有过编制程序经验的人对Switch语句都不会觉得素不相识
  • 但苹果对Switch举办了大大的增强,使其全部别样语言中并未的特色
switch的粗略利用
  • 焦点用法和OC用法一致

  • 区别之处:

    • switch后方可不跟()
    • case后得以不跟break(默许会有break)
  • 例子:

     let sex = 0 switch sex { case 0 : print case 1 : print default : print }
    
  • 大约利用补充:

    • 一个case判断中,能够判明七个值
    • 八个值以,隔开

     let sex = 0 switch sex { case 0, 1: print default: print }
    
  • 简短利用补充:

    • 假诺愿意出现以前的case穿透,则足以动用主要字fallthrough

     let sex = 0 switch sex { case 0: fallthrough case 1: print default: print }
    
Switch援助各个数据类型
  • 浮点型的switch判断

     let f = 3.14 switch f { case 3.14: print default: print }
    
  • 支撑字符串类型

    • 字符串的选拔后边会详细讲解

     let m = 5 let n = 10 var result = 0 let opration = "+" switch opration { case "+": result = m + n case "-": result = m - n case "*": result = m * n case "/": result = m / n default: result = 0 } print
    
switch协助区间判断
  • 什么是距离?

    • 常备大家指的是数字区间:010,100200
  • swift中的区间常见有三种

    • 半开半闭区间:0..<10 表示:0~9,不包括10
    • 闭区间:0…10 表示:0~10

     let score = 88 switch score { case 0..<60: print case 60..<80: print case 80..<90: print case 90..<100: print default: print }
    

  • 在付出中不时会必要循环
  • 大规模的巡回有:for/while/do while.
  • 此间大家只介绍for/while,因为for/while最普遍

for循环的写法

  • 最健康写法

     // 传统写法 for var i = 0; i < 10; i++ { print }
    
  • 区间for循环

     for i in 0..<10 { print } for i in 0...10 { print }
    
  • 越发写法

    - 如果在for循环中不需要用到下标i for _ in 0..<10 { print }
    

while和do while循环

  • while循环

    • while的论断句必须有不错的真假,没有非0即真
    • while前面包车型客车()能够简单

     var a = 0 while a < 10 { a++ }
    
  • do while循环

    • 选择repeat关键字来替代了do

     let b = 0 repeat { print b++ } while b < 20
    

  • 字符串在任何的付出中利用都是非凡频仍的
  • OC和Swift中字符串的分化
    • 在OC中字符串类型时NSString,在斯威夫特中字符串类型是String
    • OC中字符串@””,斯维夫特中字符串””
  • 使用 String 的原因String 是一个结构体,品质更高NSString 是一个
    OC 对象,质量略差String 帮忙直接遍历Swift 提供了 String
    NSString 之间的无缝转换

字符的概念

  • 概念不可变字符串

     let str = "hello Objective-C"
    
  • 概念可变字符串

     var str = "hello Swift"
    

字符串的选拔

收获字符串的长短
  • 拿到字符集合,再拿走集合的count属性

     let count = str.characters.count
    
遍历字符串
 // 字符串遍历 var str = "Hello, Swift" for c in str.characters { print }
字符串拼接
  • 三个字符串的拼凑

     let str1 = "Hello" let str2 = "World" let str3 = str1 + str2
    
  • 字符串和其它数据类型的拼凑

     let name = "why" let age = 18 let info = "my name is \, age is \"
    
  • 字符串的格式化

    • 譬如说时间:03:04

     let min = 3 let second = 4 let time = String(format: "%02d:%02d", arguments: [min, second])
    
字符串的截取
  • 斯威夫特中提供了独特的截取情势

    • 该方式要命艰辛
    • Index成立较为麻烦
  • 回顾的办法是将String转成NSString来利用

    • 在标识符后加:as NSString即可

     let myStr = "www.baidu.com" var subStr = (myStr as NSString).substringFromIndex subStr = (myStr as NSString).substringToIndex subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))
    
  • swift截取格局

     // 1.定义字符串 let str = "www.baidu.com" // 2.截取开始位置 let fromIndex = str.startIndex.advancedBy let header = str.substringFromIndex(fromIndex) // 3.截取结束位置 let toIndex = str.endIndex.advancedBy let footer = str.substringToIndex // 4.截取中间的字符串 let range = Range(start: str.startIndex.advancedBy, end: str.endIndex.advancedBy let middle = str.substringWithRange
    

数组的牵线

  • 数组是一串有序的由同样档次成分结合的聚合
  • 数组中的集合成分是不变的,可以重新出现
  • Swift中的数组
    • swift数组类型是Array,是2个泛型集合

数组的开头化

  • 数组分成:可变数组和不足变数组

    • 选择let修饰的数组是不行变数组
    • 行使var修饰的数组是可变数组

     // 定义一个可变数组,必须初始化才能使用 var array1 : [String] = [String]() // 定义一个不可变数组 let array2 : [NSObject] = ["why", 18]
    
  • 在声多美滋(Karicare)个Array类型的时候能够使用下列的说话之一

     var stuArray1:Array<String> var stuArray2: [String]
    
  • 声称的数组必要开始展览起先化才能接纳,数组类型往往是在证明的还要开始展览初阶化的

     // 定义时直接初始化 var array = ["why", "lnj", "lmj"] // 先定义,后初始化 var array : Array<String> array = ["why", "lnj", "lmj"]
    

对数组的基本操作

 // 添加数据 array.append // 删除元素 array.removeFirst() // 修改元素 array[0] = "why" // 取值 array[1]

数组的遍历

 // 遍历数组 for i in 0..<array.count { print } // forin方式 for item in array { print } // 设置遍历的区间 for item in array[0..<2] { print } // 遍历数组的同时获取下标值 let names = ["why", "yz", "lnj", "lmj"] for (index, name) in names.enumerate() { print print }

数组的联结

 // 数组合并 // 注意:只有相同类型的数组才能合并 var array = ["why", "lmj","lnj"] var array1 = ["yz", "wsz"] var array2 = array + array1; // 不建议一个数组中存放多种类型的数据 var array3 = [2, 3, "why"] var array4 = ["yz", 23] array3 + array4

字典的介绍

  • 字典允许依据有个别键来访问成分
  • 字典是由两片段集合构成的,二个是键集合,二个是值集合
  • 键集合是不可能有重复成分的,而值集合是能够重复的,键和值是成对出现的
  • 斯威夫特中的字典
    • Swift字典类型是Dictionary,也是一个泛型集合

字典的初始化

  • 斯威夫特中的可变和不足变字典

    • 利用let修饰的数组是不行变字典
    • 行使var修饰的数组是可变字典

     // 定义一个可变字典 var dict1 : [String : NSObject] = [String : NSObject]() // 定义一个不可变字典 let dict2 = ["name" : "why", "age" : 18]
    
  • 在宣称四个Dictionary类型的时候能够应用上边包车型客车言辞之一

     var dict1: Dictionary<Int, String> var dict2: [Int: String]
    
  • 宣称的字典须要实行开端化才能动用,字典类型往往是在宣称的同时展开开首化的

     // 定时字典的同时,进行初始化 var dict = ["name" : "why", "age" : 18]
    

// swift中随意对象,平常不利用NSObject,使用AnyObjectvar dict :
Dictionary<String, AnyObject>dict = [“name” : “why”, “age” :
18]​“`

字典的基本操作

 // 添加数据 dict["height"] = 1.88 dict["weight"] = 70.0 dict // 删除字段 dict.removeValueForKey dict // 修改字典 dict["name"] = "lmj" dict.updateValue("lmj", forKey: "name") dict // 查询字典 dict["name"]

字典的遍历

 // 遍历字典中所有的值 for value in dict.values { print } // 遍历字典中所有的键 for key in dict.keys { print } // 遍历所有的键值对 for (key, value) in dict { print print }

字典的联合

 // 字典的合并 var dict1 = ["name" : "yz", "age" : 20] var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"] // 字典不可以相加合并 for (key, value) in dict1 { dict2[key] = value }

元组的牵线

  • 元组是Swift中有意的,OC中并从未相关项目
  • 它是何许吧?
    • 它是一种数据结构,在数学中利用广泛
    • 接近于数组大概字典
    • 能够用于定义一组数据
    • 结缘元组类型的多寡足以称之为“成分”

元组的概念

  • 元组的广大写法

     // 使用元组描述一个人的信息 ("1001", "张三", 30, 90) // 给元素加上元素名称,之后可以通过元素名称访问元素 (id:"1001", name:"张三", english_score:30, chinese_score:90)
    

元组的简练利用

  • 用元组来讲述三个HTTP的错误消息

     // 元组:HTTP错误 // let array = [404, "Not Found"] // 写法一: let error = (404, "Not Found") print print // 写法二: let error = (errorCode : 404, errorInfo : "Not Found") print(error.errorCode) print(error.errorInfo) // 写法三: let (errorCode, errorIno) = (404, "Not Found") print(errorCode) print
    

可选类型的介绍

  • 注意:
    • 可选类型时swift中较通晓的多个知识点
    • 最近先精通,多采纳Xcode的升迁来采用
    • 趁着学习的中肯,稳步驾驭在那之中的规律和好处
  • 概念:
    • 在OC开发中,假如2个变量暂停不采取,能够赋值为0或然赋值为空
    • 在swift开发中,nil也是贰个例外的类型.因为和忠实的品类不合营是不能赋值的(swift是强类型语言)
    • 只是付出中赋值nil,在所难免.由此推出了可选类型
  • 可选类型的取值:
    • 空值
    • 有值

概念可选类型

  • 概念1个可选类型有三种写法

    • 最宗旨的写法
    • 语法糖

     // 错误写法 // let string : String = nil // 正确写法: // 注意:name的类型是一个可选类型,但是该可选类型中可以存放字符串. // 写法一:定义可选类型 let name : Optional<String> = nil // 写法二:定义可选类型,语法糖 let name : String? = nil
    

可选类型的选择

 // 演练一:给可选类型赋值 // 定义可选类型 var string : Optional<String> = nil // 给可选类型赋值 // 错误写法:因此该可选类型中只能存放字符串 string = 123 // 正确写法: string = "Hello world" // 打印结果 print // 结果:Optional("Hello world")\n // 因为打印出来的是可选类型,所有会带Optional // 演练二:取出可选类型的值 // 取出可选类型的真实值 print // 结果:Hello world\n // 注意:如果可选类型为nil,强制取出其中的值,会出错 string = nil print // 报错 // 正确写法: if string != nil { print } // 简单写法:为了让在if语句中可以方便使用string // 可选绑定 if let str = string { print }

实事求是应用场景

  • 目标:让代码越发小心

     // 通过该方法创建的URL,可能有值,也可能没有值. // 错误写法:如果返回值是nil时,就不能接收了 // 如果字符串中有中文,则返回值为nil,因此该方法的返回值就是一个可选类型,而使用一个NSURL类型接收是错误的 let url : NSURL = NSURL(string: "www.baidu.com") // 正确写法:使用可选类型来接收 let url : NSURL? = NSURL(string: "www.baidu.com") // 该方式利用类型推导 let url = NSURL(string: "www.baidu.com") // 通过url来创建request对象:在使用可选类型前要先进行判断是否有值 // 该语法成为可选绑定(如果url有值就解包赋值给tempURL,并且执行{}) if let tempUrl = url { let request = NSURLRequest(URL: tempUrl) }
    

广大的品类转化符号

  • is : 用于判断三个实例是还是不是是某一种档次
  • as : 将实例转成某一连串型

例子

 // 1.定义数组 let array : [AnyObject] = [12, "why", 1.88] // 2.取出数组中的第一个元素 let objc = array.first! // 3.判断第一个元素是否是一个Int类型 if objc is Int { print } else { print } // 4.将objc转成真正的类型来使用 // 4.1.as? 将AnyObject转成可选类型,通过判断可选类型是否有值,来决定是否转化成功了 let age = objc as? Int print // 结果:Optional // 4.2.as! 将AnyObject转成具体的类型,但是注意:如果不是该类型,那么程序会崩溃 let age1 = objc as! Int print // 结果:12

函数的介绍

  • 函数也正是OC中的方法

  • 函数的格式如下

     func 函数名 -> 返回值类型 { 代码块 return 返回值 }
    
  • func是主要字,七个参数列表之间能够用逗号分隔,也足以没有参数

  • 行使箭头“->”指向重返值类型

  • 假诺函数没有重回值,再次回到值为Void.并且“-> 重回值类型”部分能够简简单单

大规模的函数类型

 // 1.没有参数,没用返回值 func about() -> Void { print("iphone6s plus") } // 调用函数 about() // 简单写法 // 如果没用返回值,Void可以写成() func about1() -> () { print("iphone6s plus") } // 如果没有返回值,后面的内容可以都不写 func about2() { print("iphone6s plus") } about2() // 2.有参数,没用返回值 func callPhone(phoneNum : String) { print("打电话给\") } callPhone("+86 110") // 3.没用参数,有返回值 func readMessage() -> String { return "吃饭了吗?" } var str = readMessage() print // 4.有参数,有返回值 func sum(num1 : Int, num2 : Int) -> Int { return num1 + num2 } var result = sum(20, num2: 30) print // 5.有多个返回值的函数 let nums = [1, 3, 4, 8, 22, 23] func getNumCount(nums : [Int]) -> (oddCount : Int, evenCount : Int) { var oddCount = 0 var evenCount = 0 for num in nums { if num % 2 == 0 { oddCount++ } else { evenCount++ } } return (oddCount, evenCount) } let result = getNumCount result.oddCount result.evenCount

函数的运用注意

  • 只顾一: 外部参数和当中参数

    • 在函数内部能够看看的参数,正是内部参数
    • 在函数外面能够见到的参数,正是表面参数
    • 默许情况下,从第①个参数开端,参数名称既是里面参数也是外表参数
    • 倘使第一个参数也想要有外部参数,能够安装标签:在变量名前加标签即可
    • 假诺不想要外部参数,能够在参数名称前加_

     // num1和a是外部参数的名称 func ride(num1 num1 : Int, a num2 : Int, b num3 : Int) -> Int { return num1 * num2 * num3 } var result1 = ride(num1: 20, a: 4, b: 5) // 方法的重载:方法名称相同,但是参数不同,可以称之为方法的重载 func ride(num1: Int, _ num2 :Int) -> Int { return num1 * num2 } var result2 = ride
    
  • 小心二: 默许参数

    • 好几情形,假如没有传到具体的参数,可以采纳私下认可参数

     func makecoffee(type :String = "卡布奇诺") -> String { return "制作一杯\咖啡。" } let coffee1 = makecoffee let coffee2 = makecoffee()
    
  • 留意三: 可变参数

    • swift中等学校函授数的参数个数能够转移,它还行不鲜明数量的输入类型参数
    • 它们必须具有同样的档次
    • 笔者们能够透过在参数类型名背后插足的办法来提醒那是可变参数

     func sum(numbers:Double...) -> Double { var total: Double = 0 for number in numbers { total += number } return total } sum(100.0, 20, 30) sum
    
  • 瞩目四: 引用类型

    • 暗中同意情状下,函数的参数是值传递.如若想更改外界的变量,则需求传递变量的地址
    • 必须是变量,因为必要在其间改变其值
    • 斯维夫特提供的inout关键字就足以兑现
    • 对照下列多少个函数

     // 函数一:值传递 func swap(var a : Int, var b : Int) { let temp = a; a = b; b = temp print, b:\ } var a = 10 var b = 20 swap print, b:\ // 函数二:指针的传递 func swap1(inout a : Int, inout b : Int) { let temp = a a = b b = temp print, b:\ } swap1(&a, b: &b) print, b:\
    
  • 函数的嵌套使用

    • swift中等学校函授数能够嵌套使用
    • 即函数中蕴藏函数,但是不引进该写法

     // 函数的嵌套 let value = 55 func test() { func demo() { print("demo \ } print demo() } demo() // 错误 test() // 执行函数会先打印'test',再打印'demo'
    

函数的品种

  • 函数类型的概念

    • 各样函数都有属于本身的项目,由函数的参数类型和重临类型组成
      • 本条例子中定义了多少个不难的数学函数:addTwoInts 和
        multiplyTwoInts
      • 那多少个函数都不翼而飞八个 Int 类型, 重临1个方便的Int值
      • 这多个函数的品类是 -> Int

     // 定义两个函数 func addTwoInts(a : Int, b : Int) -> Int { return a + b } func multiplyTwoInt(a : Int, b : Int) -> Int { return a * b }
    
  • 抽取三个函数的项目,并且选用

     // 定义函数的类型 var mathFunction :  -> Int = addTwoInts // 使用函数的名称 mathFunction // 给函数的标识符赋值其他值 mathFunction = multiplyTwoInt // 使用函数的名称 mathFunction
    
  • 函数作为艺术的参数

     // 3.将函数的类型作为方法的参数 func printResult(a : Int, b : Int, calculateMethod :  -> Int) { print(calculateMethod } printResult(10, b: 20, calculateMethod: addTwoInts) printResult(10, b: 20, calculateMethod: multiplyTwoInt)
    
  • 函数作为艺术的再次回到值

     // 1.定义两个函数 func stepForward(num : Int) -> Int { return num + 1 } func stepBackward(num : Int) -> Int { return num - 1 } // 2.定义一个变量,希望该变量经过计算得到0 var num = -4 // 3.定义获取哪一个函数 func getOprationMethod(num : Int) ->  -> Int { return num <= 0 ? stepForward : stepBackward } // 4.for玄幻进行操作 while num != 0 { let oprationMethod = getOprationMethod num = oprationMethod print }
    

枚举类型的牵线

  • 概念介绍

    • 枚举定义了3个通用项指标一组有关的值,使你能够在你的代码中以3个有惊无险的主意来使用那几个值。
    • 在 C/OC 语言中枚举钦命相关称号为一组整型值
    • Swift中的枚举特别灵活,不必给每三个枚举成员提供二个值.也能够提供一个值是字符串,3个字符,或是一个整型值或浮点值
  • 枚举类型的语法

    • 接纳enum关键词并且把它们的整套定义放在一对大括号内

     enum SomeEnumeration { // enumeration definition goes here }
    

枚举类型的定义

  • 以下是指南针多少个趋势的一个事例

    • case关键词评释新的一条陈灏员值将被定义
    • 不像 C 和 Objective-C 一样,Swift的枚举成员在被创设时不会被给予多个暗许的整数值
    • 在位置的CompassPoints例子中,North,South,East和韦斯特不是隐式的等于0,1,2和3

     enum CompassPoint { case North case South case East case West }
    
  • 概念方式二:三个成员值可以现身在同一行上

     enum Planet { case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune }
    

给枚举类型赋值

  • 枚举类型赋值能够是字符串/字符/整型/浮点型

    • 注意借使有给枚举类型赋值,则必须在枚举类型后边肯定表达实际的体系

     // 1.枚举类型的赋值 enum CompassPoint : Int { case North = 1 case South = 2 case East = 3 case West = 4 } enum Planet { case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune } // 2.枚举类型的使用 let p = Planet(rawValue: 3) if let p = p { switch p { case .Mercury: print("Mercury") case .Venus: print case .Earth: print("Mercury") case .Mars: print case .Jupiter: print("Jupiter") case .Saturn: print case .Uranus: print case .Neptune: print("Neptune") } }
    

结构体的牵线

  • 概念介绍

    • 结构体是由一多重具有同等体系或分裂品种的多寡整合的数据集合
    • 结构体指的是一种数据结构
    • 结构体是值类型,在章程中传送时是值传递
  • 组织的定义格式

     struct 结构体名称 { // 属性和方法 }
    

何以供给结构体?

  • 先来看多少个事例
    • 我们要总结平面坐标里有个别点距点Center的距离是或不是低于200
    • 算起来相当的粗略,勾股定理就消除了:
      • 里面sqrt用来计算n的平方根
      • pow用来总计x的n次方

 let centerX : Double = 100 let centerY : Double = 100 func inRange(x : Double, y : Double) -> Bool { let disX = x - centerX let disY = y - centerX let dis = sqrt(pow + pow return dis < 200 } let x : Double = 100 let y : Double = 1000 inRange
  • 问题

    • 可是这么有贰个不足,当大家须要比较很八个点和Center的距离的时候,那一个数字并无法强烈报告大家它们代表的职分的意义,甚至大家都心有余而力不足掌握它们代表二个数字。
    • 若果大家得以像这么来相比较地方:
      • 对待数字,它们看起来就会直观的多
      • 而那,正是我们要求自定义struct类型最直接的原故

     inRange(location1) inRange
    
  • 动用结构进行革新

     // 初始化结构体 struct Location { var x : Double var y : Double } // 创建结构体 let location = Location(x: 90, y: 90) // 优化刚才的方法 func inRange(location : Location) -> Bool { let disX = location.x - centerX let disY = location.y - centerY let dis = sqrt(pow + pow return dis < 200 } inRange
    

结构体的进步

  • 扩大构造函数

    • 默许景况下制造Location时选取Location(x: x值, y: y值)
    • 但是为了让大家在应用结构体时尤其的灵活,swift仍可以对构造函数实行扩展
    • 扩充的专注点
      • 在壮大的构造函数中务必确认保证成员变量是有值的
      • 扩张的布局函数会覆盖原有的构造函数

     struct Location { var x : Double var y : Double init(x : Double, y : Double) { self.x = x self.y = y } init(xyString : String) { let strs = xyString.componentsSeparatedByString x = Double(strs.first!)! y = Double(strs.last!)! } } let location = Location(x: 100, y: 100) let location1 = Location(xyString: "100,100")
    
  • 为结构体扩大方法

    • 为了让结构体使用特别灵活,swift的结构体中能够扩充方法
    • 事例:为了Location结构体扩张四个法子
      • 向水平方向移动的点子
      • 向垂直方向移动的法门

     struct Location { var x : Double var y : Double init(x : Double, y : Double) { self.x = x self.y = y } init(xyString : String) { let strs = xyString.componentsSeparatedByString x = Double(strs.first!)! y = Double(strs.last!)! } mutating func moveH(x : Double) { self.x += x } mutating func moveV(y : Double) { self.y += y } }
    
  • 注意:

    • 假若大家利用的Location不是温馨定义的,不过我们照例希望在温馨的体系里扩张Location的操作
    • Swift也能帮大家完毕,那一个机制,叫做extension

     extension Location { mutating func moveH(x : Double) { self.x += x } mutating func moveV(y : Double) { self.y += y } }
    

主要内容

  • 类的牵线和定义
  • 类的天性
  • 类的构造函数

一. 类的介绍和定义

  • 斯威夫特也是一门面向对象开发的言语

  • 面向对象的底蕴是类,类发生了目的

  • 在斯威夫特中怎么样定义类呢?

    • class是斯维夫特中的关键字,用于定义类

     class 类名 : SuperClass { // 定义属性和方法 }
    
  • 注意:

    • 概念的类,能够没有父类.那么该类是rootClass
    • 一般说来状态下,定义类时.继承自NSObject(非OC的NSObject)

二. 如何定义类的习性

类的本性介绍
  • 斯威夫特中类的品质有种种
    • 积存属性:存款和储蓄实例的常量和变量
    • 总括属性:通过某种格局总结出来的品质
    • 类属性:与成套类自个儿有关的性格
积存属性
  • 存款和储蓄属性是最简单易行的习性,它当作类实例的一有的,用于存款和储蓄常量和变量

  • 能够给存款和储蓄属性提供三个暗中认可值,也能够在开端化方法中对其进展初步化

  • 上边是储存属性的写法

    • age和name都以储存属性,用来记录该学生的年华和人名
    • chineseScore和mathScore也是储存属性,用来记录该学生的语文分数和数学分数

     class Student : NSObject { // 定义属性 // 存储属性 var age : Int = 0 var name : String? var chineseScore : Double = 0.0 var mathScore : Double = 0.0 } // 创建学生对象 let stu = Student() // 给存储属性赋值 stu.age = 10 stu.name = "why" stu.chineseScore = 89.0 stu.mathScore = 98.0
    
计量属性
  • 算算属性并不存款和储蓄实际的值,而是提供二个getter和叁个可选的setter来直接获取和设置任何性质

  • 算算属性一般只提供getter方法

  • 一旦只提供getter,而不提供setter,则该计算属性为只读属性,并且能够简简单单get{}

  • 下边是持筹握算属性的写法

    • averageScore是总结属性,通过chineseScore和mathScore总计而来的性质
    • 在setter方法中有一个newValue变量,是系统内定分配的

     class Student : NSObject { // 定义属性 // 存储属性 var age : Int = 0 var name : String? var chineseScore : Double = 0.0 var mathScore : Double = 0.0 // 计算属性 var averageScore : Double { get { return (chineseScore + mathScore) / 2 } // 没有意义,因为之后获取值时依然是计算得到的 // newValue是系统分配的变量名,内部存储着新值 set { self.averageScore = newValue } } } // 获取计算属性的值 print(stu.averageScore)
    
类属性
  • 类属性是与类相关联的,而不是与类的实例相关联

  • 负有的类和实例都共有一份类属性.由此在某一处修改今后,该类属性就会被改动

  • 类属性的装置和改动,要求通过类来形成

  • 下边是类属性的写法

    • 类属性使用static来修饰
    • courseCount是类属性,用来记录学生有个别许门课程

     class Student : NSObject { // 定义属性 // 存储属性 var age : Int = 0 var name : String? var chineseScore : Double = 0.0 var mathScore : Double = 0.0 // 计算属性 var averageScore : Double { get { return (chineseScore + mathScore) / 2 } // 没有意义.newValue是系统分配的变量名,内部存储着新值 set { self.averageScore = newValue } } // 类属性 static var corseCount : Int = 0 } // 设置类属性的值 Student.corseCount = 3 // 取出类属性的值 print(Student.corseCount)
    
监听属性的变更
  • 在OC中我们得以重写set方法来监听属性的变动

  • 斯维夫特中能够透过品质观望者来监听和响应属性值的变化

  • 屡见不鲜是监听存款和储蓄属性和类属性的改变.(对于总结属性,大家不供给定义属性观望者,因为大家可以在盘算属性的setter中一贯观测并响应那种值的变迁)

  • 大家经过设置以下观看措施来定义观看者

    • willSet:在属性值被贮存在此之前设置。此时新属性值作为一个常量参数被传播。该参数名私下认可为newValue,我们得以本人定义该参数名
    • didSet:在新属性值被贮存后霎时调用。与willSet相同,此时传出的是性质的旧值,暗中认可参数名为oldValue
    • willSet与didSet只有在性质第2次棉被服装置时才会调用,在初阶化时,不会去调用那几个监听方法
  • 监听的方法如下:

    • 监听age和name的变化

     class Person : NSObject { var name : String? { // 可以给newValue自定义名称 willSet { // 属性即将改变,还未改变时会调用的方法 // 在该方法中有一个默认的系统属性newValue,用于存储新值 print print } // 可以给oldValue自定义名称 didSet  { // 属性值已经改变了,会调用的方法 // 在该方法中有一个默认的系统属性oldValue,用于存储旧值 print print } } var age : Int = 0 var height : Double = 0.0 } let p : Person = Person() // 在赋值时,监听该属性的改变 // 在OC中是通过重写set方法 // 在swift中,可以给属性添加监听器 p.name = "why" //p.name = "yz"
    

构造函数的牵线

  • 构造函数类似于OC中的初步化方法:init方法
  • 暗许处境下载创制2个类时,必然会调用二个构造函数
  • 固然是平素不编写制定任何构造函数,编写翻译器也会提供三个暗许的构造函数。
  • 假诺是继续自NSObject,能够对父类的构造函数举行重写

构造函数的为主使用

构造函数的主导使用
  • 类的品质必须有值

  • 如果不是在概念时开始化值,能够在构造函数中赋值

     class Person: NSObject { var name : String var age : Int // 重写了NSObject的构造方法 override init() { name = "" age = 0 } } // 创建一个Person对象 let p = Person()
    
初阶化时给属性赋值
  • 有的是时候,大家在开创四个目的时就会给属性赋值

  • 能够自定义构造函数

  • 小心:假使自定义了构造函数,会覆盖init()方法.即不在有默许的构造函数

     class Person: NSObject { var name : String var age : Int // 自定义构造函数,会覆盖init()函数 init(name : String, age : Int) { self.name = name self.age = age } } // 创建一个Person对象 let p = Person(name: "why", age: 18)
    
字典转模型
  • 真实创制对象时,越来越多的是将字典转成模型

  • 注意:

    • 去字典中取出的是NSObject,任意类型.
    • 能够经过as!转成须要的档次,再赋值

     class Person: NSObject { var name : String var age : Int // 自定义构造函数,会覆盖init()函数 init(dict : [String : NSObject]) { name = dict["name"] as! String age = dict["age"] as! Int } } // 创建一个Person对象 let dict = ["name" : "why", "age" : 18] let p = Person(dict: dict)
    
字典转模型
  • 利用KVC字典转模型会尤其有利

  • 注意:

    • KVC并不能够确定保障会给持有的属性赋值
    • 从而属性必要有默许值
      • 骨干数据类型私下认可值设置为0
      • 对象可能协会体类型定义为可选类型即可(可选类型没有赋值前为nil)

     class Person: NSObject { // 结构体或者类的类型,必须是可选类型.因为不能保证一定会赋值 var name : String? // 基本数据类型不能是可选类型,否则KVC无法转化 var age : Int = 0 // 自定义构造函数,会覆盖init()函数 init(dict : [String : NSObject]) { // 必须先初始化对象 super.init() // 调用对象的KVC方法字典转模型 setValuesForKeysWithDictionary } } // 创建一个Person对象 let dict = ["name" : "why", "age" : 18] let p = Person(dict: dict)
    

析构函数

  • 斯维夫特 会自动释放不再必要的实例以释放财富

    • 斯威夫特 通过活动引用计数处理实例的内部存款和储蓄器管理
    • 当引用计数为0时,系统会自动调用析构函数
    • 普普通通在析构函数中释放部分能源
  • 析构函数的写法

     deinit { // 执行析构过程 }
    

示范演练

 class Person { var name : String var age : Int init(name : String, age : Int) { self.name = name self.age = age } deinit { print("Person-deinit") } } var p : Person? = Person(name: "why", age: 18) p = nil

行事机制

  • Swift和OC一样,选用电动引用计数来管理内容
    • 当有二个强引用指向某3个势头时,该目的的引用计数会自行+1
    • 当该强引用消失时,引用计数会自行-1
    • 当引用计数为0时,该目的会被销毁

循环引用

  • 在日常状态下,A奥迪Q3C是会自动扶助大家管理内部存款和储蓄器的

  • 但是在付出中大家平常会并发循环引用的难点,比如上面包车型地铁言传身教

    • Student对Book对象有3个强引用
    • 而Book对Student有叁个强引用
    • 在四个指标都针对nil时,依旧不会被灭绝,就形成了循环引用

     // 1.创建类 class Student { var book : Book? deinit { print("Student -- deinit") } } class Book { var owner : Student? deinit { print("Book -- deinit") } } // 2.创建对象 var stu : Student? = Student() var book : Book? = Book() // 3.相互引用 stu?.book = book book?.owner = stu // 4.对象置nil stu = nil book = nil
    
  • 消除方案

    • swift提供了二种缓解方案
      • weak :
        和OC中的__weak一样是四个弱引用.当指向的靶子销毁时,会自行将指针指向nil
      • unowned :
        和OC中的__unsafe_unretained.当对象销毁时还是指向原来的位置

     // 1.创建类 class Student { weak var book : Book? // unowned var book : Book = Book() deinit { print("Student -- deinit") } } class Book { var owner : Student? deinit { print("Book -- deinit") } } // 2.创建对象 var stu : Student? = Student() var book : Book? = Book() // 3.相互引用 stu?.book = book! book?.owner = stu // 4.对象置nil stu = nil book = nil
    

可选连的概念

  • 它的可选性展示于请求或调用的靶子当前可能为空
    • 一旦可选的靶子有值,那么调用就会中标;
    • 只要选拔的靶子为空,则那种调用将回来空
  • 屡次调用被链接在协同形成一个链,如若别的七个节点为空将导致整个链失效。
  • 可选链的采用
    • 在可选类型前面放二个问号,能够定义贰个可选链。
    • 这点很像在可选值前面放三个叹号来强制拆得其封包内的值
      • 它们的基本点的差别在于当可选值为空时可选链立即战败
      • 唯独一般的强制解析将会抓住运维时不当。
    • 因为可选链的结果只怕为nil,或者有值.由此它的重回值是一个可选类型.
      • 能够通过判断重临是或不是有值来判定是或不是调用成功
      • 有值,表明调用成功
      • 为nil,表达调用失利

可选链的言传身教

  • 从可选链中取值

    • 演示描述: 人有2个狗,狗有叁个玩具,玩具有价格
    • 动用代码描述上述消息

     // 1.定义类 class Person { var name : String var dog : Dog? init(name : String) { self.name = name } } class Dog { var color : UIColor var toy : Toy? init(color : UIColor) { self.color = color } func runing() { print } } class Toy { var price : Double = 0.0 } // 2.创建对象,并且设置对象之间的关系 // 2.1.创建对象 let person = Person(name: "小明") let dog = Dog(color: UIColor.yellowColor let toy = Toy() toy.price = 100.0 // 2.2.设置对象之间的关系 person.dog = dog dog.toy = toy
    
  • 需求:获取小明的大黄宠物的玩具价格取出的值为可选类型,因为可选链中有一个可选类型为nil,则赶回nil由此结果大概有值,恐怕为nil.因而是贰个可选类型

     let price = person.dog?.toy?.price print // Optional\n
    
  • 供给:给小明的大黄3个新的玩意儿

    • 一定于给可选类型赋值

     person.dog?.toy = Toy()
    
  • 须求:让小明的狗跑起来

    • 假使可选类型有值,则会履行该办法
    • 假若可选类型为nil,则该方法不会进行

     person.dog?.runing()
    

协商的格式

  • 情商的定义格局与类,结构体,枚举的概念都格外相像

     protocol SomeProtocol { // 协议方法 }
    
  • 遵循协议的格式

     class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol { // 类的内容 // 实现协议中的方法 }
    

共谋的骨干使用

  • 概念协议和严守协议

     // 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() }
    

代办设计形式

  • 商量持续用于代理设计方式

     protocol BuyTicketProtocol { func buyTicket() } class Person { // 1.定义协议属性 var delegate : BuyTicketProtocol // 2.自定义构造函数 init (delegate : BuyTicketProtocol) { self.delegate = delegate } // 3.行为 func goToBeijing() { delegate.buyTicket() } } class HuangNiu: BuyTicketProtocol { func buyTicket() { print("买了一张火车票") } } let p = Person(delegate: HuangNiu p.goToBeijing()​```
    

说道中方法的可选

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

闭包的介绍

  • 闭包和OC中的block万分相似
    • OC中的block是匿名的函数
    • 斯维夫特中的闭包是三个非常的函数
    • block和闭包都常常用来回调
  • 只顾:闭包和block一样,第一遍使用时只怕不习惯它的语法,能够先依照使用简便的闭包,随着学习的深透,渐渐通晓其心灵手巧的接纳方法.

闭包的行使

block的用法回看
  • 概念网络请求的类

     @interface HttpTool : NSObject - loadRequest:callBackBlock; @end @implementation HttpTool - loadRequest:callBackBlock { dispatch_async(dispatch_get_global_queue, ^{ NSLog(@"加载网络数据:%@", [NSThread currentThread]); dispatch_async(dispatch_get_main_queue(), ^{ callBackBlock; } @end
    
  • 展开网络请求,请求到数量后使用block进行回调

     - touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event { [self.httpTool loadRequest:^{ NSLog(@"主线程中,将数据回调.%@", [NSThread currentThread]); }]; }
    
  • block写法计算:

    block的写法:类型:返回值(^block的名称)值:^ { // 执行的代码};
    
选拔闭包代替block
  • 概念网络请求的类

     class HttpTool: NSObject { func loadRequest(callBack : { dispatch_async(dispatch_get_global_queue { () -> 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 // 执行代码 }
    
闭包的简写
  • 假设闭包没有参数,没有回到值.in和in以前的剧情能够简简单单

     httpTool.loadRequest({ print("回到主线程", NSThread.currentThread
    
  • 尾随闭包写法:

    • 假诺闭包是函数的末尾1个参数,则能够将闭包写在()后边
    • 尽管函数唯有四个参数,并且这一个参数是闭包,那么()能够不写

     httpTool.loadRequest() { print("回到主线程", NSThread.currentThread; } // 开发中建议该写法 httpTool.loadRequest { print("回到主线程", NSThread.currentThread; }
    

闭包的大循环引用

  • 一经在HttpTool中有对闭包实行强引用,则会形成巡回引用

  • 填补:在Swift中检测一个指标是还是不是销毁,可以兑现指标的deinit函数

     // 析构函数(相当于OC中dealloc方法) deinit { print("ViewController----deinit") }
    
  • 巡回引用的

    • 该兑现是为着产生循环引用,而发生的巡回引用

     class HttpTool: NSObject { // 定义属性,来强引用传入的闭包 var callBack : )? func loadRequest(callBack : { dispatch_async(dispatch_get_global_queue { () -> Void in print("加载数据", [NSThread.currentThread dispatch_async(dispatch_get_main_queue -> Void in callBack } self.callBack = callBack } }
    
  • swift中国化学工业进出口总公司解循环引用的方法

  • 方案一:

    • 使用weak,对近来控制器选拔弱引用
    • 只是因为self或者有值也说不定没有值,由此weakSelf是3个可选类型,在真正使用时得以对其挟持解包(该处强制解包没有反常态,因为控制器一定期存款在,不然不也许调用所在函数)

     // 解决方案一: weak var weakSelf = self httpTool.loadData { print("加载数据完成,更新界面:", NSThread.currentThread weakSelf!.view.backgroundColor = UIColor.redColor() }
    
  • 方案二:

    • 和方案一项目,只是书写格局越来越简明
    • 能够写在闭包中,并且在闭包中用到的self皆以弱引用

     httpTool.loadData {[weak self] () -> () in print("加载数据完成,更新界面:", NSThread.currentThread self!.view.backgroundColor = UIColor.redColor() }
    
  • 方案三:

    • 运用主要字unowned
    • 从表现上的话 unowned 更像OC中的 unsafe_unretained
    • unowned
      代表:尽管它原本引用的靶子被保释了,如故会维持对被已经刑释了的目的的八个”无效的” 引用,它无法是 Optional 值,也不会被指向 nil

     httpTool.loadData {[unowned self] () -> () in print("加载数据完成,更新界面:", NSThread.currentThread self.view.backgroundColor = UIColor.redColor() }
    

懒加载的牵线

  • swift中也有懒加载的办法
    • (苹果的宏图思想:希望拥有的目的在行使时才真的加载到内部存款和储蓄器中)
  • 和OC区别的是swift有特别的重要字来落到实处懒加载
  • lazy关键字能够用来定义某贰天性能懒加载

懒加载的运用

  • 格式

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

     // 懒加载的本质是,在第一次使用的时候执行闭包,将闭包的返回值赋值给属性 // lazy的作用是只会赋值一次 lazy var array : [String] = { () -> [String] in return ["why", "lmj", "lnj"] }()
    

单行注释

  • Swift 中的注释与C 语言的注明相当相似。

  • 单行注释以双正斜杠作为开场标记

     // 注释内容
    

多行注释

  • 其初叶标记为单个正斜杠后跟随1个星号

  • 停下标记为1个星号后紧跟着单个正斜杠

     /* 这是一个, 多行注释 */
    
  • 和与 C 语言多行注释差别,斯维夫特的多行注释能够嵌套在其余的多行注释之中

     /* 这是第一个多行注释的开头 /* 这是第二个被嵌套的多行注释 */ 这是第一个多行注释的结尾 */
    

文档注释

  • 斯威夫特中添Gavin档注释较为简单

  • 行使能够为艺术或许性质添加文档注释

     /// 打电话给某人 func callPhone(phoneNum : String) { print("打电话给\") }
    

分组注释

  • swift中不可能再接纳 #pragma mark -

  • 若是打算对代码进行分组能够行使 // MARK:-方式

     // MARK:-
    

swift中的访问权限

  • Swift 中的访问控制模型基于模块和源文件那五个概念

    - internal : 在本模块中都可以进行访问- private : 在当前源文件中可以访问- public : 在其他模块中可以访问
    

万分的牵线

  • 一旦我们在编制程序,就必定要面对错误处理的问题。
  • 斯维夫特在规划的时候就尽大概让大家显著感知错误,显然处理错误
    • 譬如:只有采纳Optional才能处理空值;
  • 什么样描述二个张冠李戴?
    • 在斯维夫特里,任何2个遵守ErrorType
      protocol的项目,都能够用来描述失实。
    • ErrorType是一个空的protocol,它唯一的功力,就是告诉Swift编译器,有个别项目用来代表1个谬误。
    • 常备,我们使用二个enum来定义种种不当的大概

很是的以身作则

  • 比方大家想要读取四个文书中的内容,依据OC的逻辑我们能够那样来模拟

    • 当大家调用方法获得结果为nil时,你并不可能鲜明毕竟参数了怎么着错误得到了nil

     func readFileContent(filePath : String) -> String? { // 1.filePath为"" if filePath == "" { return nil } // 2.filepath有值,但是没有对应的文件 if filePath != "/User/Desktop/123.plist" { return nil } // 3.取出其中的内容 return "123" } readFileContent
    
  • 应用十三分对上述办法实行改革

     // 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" }
    
  • 拍卖非凡有三种方法

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

Swift调⽤用OC

  1. 创建桥接⽂文件—> .h
  2. 在桥接⽂文件中程导弹⼊入头⽂文件
  3. 计划桥接⽂文件: 项目->buildSettings —> bridging —> 配置

OC调⽤用Swift

  • 项⽬目名字无法随便起
  • Swift中的类/属性/⽅方法必须使⽤用public修饰
  • 导⼊项目名称-Swift.h