Swift基础语法

作者: 越天高 | 来源:发表于2019-12-24 09:52 被阅读0次

Playground是什么?
从Xcode6开始出现(Swift开始出现)
翻译为:操场/游乐场
对于学习Swift基本语法非常方便
所见即所得(快速查看结果)
语法特性发生改变时,可以快速查看.
Swift最基本的语法变化

导入框架 import UIKit

// 1.导入框架
//#import <UIKit/UIKit.h>
import UIKit

定义标识符时，必须声明该标识符是变量还是常量
声明标识符的格式:变量/常量关键字名称 : 数据类型

2.定义一个标识符
// int a = 10;
// swift中定义标识符:必须制定该标识符是一个常量还是一个变量
// var(变量)/let(常量) 标识符的名称 : 标识符的类型 = 初始化值
var a : Int = 10;
let b : Double = 3.14;
a = 29;
// b = 3.11 错误写法
print ("nihao");

语句结束时不需要加;
如果同一行有多个语句,则依然需要加
但是不建议一行多条语句

var m : Int = 20
let n : Double = 3.44

Swift中的打印语句:print(打印的内容)

// NSLog(@"%d", a)
print(a)
print("hello world")

常量和变量

在Swift中规定:在定义一个标识符时必须明确说明该标识符是一个常量还是变量
使用let来定义常量,定义之后不可以修改
使用var来定义变量,定义之后可以修改
常量和变量的基本使用

import UIKit

let a : Int = 10
// 错误写法,当一个字段定义为常量时是不可以修改的
// a = 20

var 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(btn)

Swift中数据类型

Swift类型的介绍

Swift中的数据类型也有:整型/浮点型/对象类型/结构体类型等等
先了解整型和浮点型
整型
- 有符号
  Int8 : 有符号8位整型
  Int16 : 有符号16位整型
  Int32 : 有符号32位整型
  Int64 : 有符号64位整型
  Int : 和平台相关(默认,相当于OC的NSInteger)
- 无符号
  UInt8 : 无符号8位整型
  UInt16 : 无符号16位整型
  UInt32 : 无符号32位整型
  UInt64 : 无符号64位整型
  UInt : 和平台相关(常用,相当于OC的NSUInteger)(默认)
浮点型
Float : 32位浮点型
Double : 64浮点型(默认)

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

Swift中的类型推导

Swift是强类型的语言
Swift中任何一个标识符都有明确的类型
注意:
- 如果定义一个标识符时有直接进行赋值,那么标识符后面的类型可以省略.
- 因为Swift有类型推导,会自动根据后面的赋值来决定前面的标识符的数据类型
- 可以通过option+鼠标左键来查看变量的数据类型截屏.png

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

// 正确写法
var j = 3.33
j = 6.66

Swift中基本运算

Swift中在进行基本运算时必须保证类型一致,否则会出错
相同类型之间才可以进行运算
因为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(a) + b
let d = a + Int(b)

逻辑分支

一. 分支的介绍

分支即if/switch/三目运算符等判断语句
通过分支语句可以控制程序的执行流程

二. if分支语句

和OC中if语句有一定的区别
- 判断句可以不加()
- 在Swift的判断句中必须有明确的真假
  - 不再有非0即真
  - 必须有明确的Bool值
  - Bool有两个取值:false/true

// 演练一:
let a = 10

// 错误写法:
//if a {
//    print("a")
//}

// 正确写法
if a > 9 {
   print(a)
}

// 演练二:
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 = 10
var b = 50

var result = a > b ? a : b
println(result)

四.guard的使用

guard是Swift2.0新增的语法
guard必须用在函数内部
它与if语句非常类似，它设计的目的是提高程序的可读性
guard语句必须带有else语句，它的语法如下：
- 当条件表达式为true时候跳过else语句中的内容，执行语句组内容，并且{}中必须跟上 return、break、continue和throw
- 条件表达式为false时候执行else语句中的内容，跳转语句一般是return、break、continue和throw

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

// 1.guard必须用在函数

let myAge = 20

func online(age:Int)
{
    guard age >= 18 else {
        print("未成年不能上网")
        return
    }
    let forgetStr = "没带身分证"
    
    guard forgetStr == "没带身分证" else {
        print("回家拿身份证")
        return
    }
    print("可以上网")
}

四.switch分支

switch的介绍

Switch作为选择结构中必不可少的语句也被加入到了Swift中
只要有过编程经验的人对Switch语句都不会感到陌生
但苹果对Switch进行了大大的增强，使其拥有其他语言中没有的特性

switch的简单使用

基本用法和OC用法一致
不同之处:
switch后可以不跟()
case后可以不跟break(默认会有break)

//基本用法
let sex = 0

switch sex {
case 0 :
    print("男")
case 1 :
    print("女")
default :
    print("其他")
}

简单使用补充:
- 一个case判断中,可以判断多个值
- 多个值以,隔开

// 2.基本用法的补充:
// 1>如果希望一个case中出现case穿透,那么可以在case语句结束后跟上fallthrough
// 2>case后面可以跟多个条件,多个条件以,分割

switch sex {
    case 1,0:
    print("正常人")
    fallthrough
    case 0:
        print("男")
    case 1:
        print("女")
default:
    print("其他")
}

Switch支持多种数据类型

浮点型的switch判断

let f = 3.14
switch f {
case 3.14:
    print("π")
default:
    print("not π")
}

支持字符串类型

字符串的使用后面会详细讲解

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(result)

switch支持区间判断

什么是区间?
通常我们指的是数字区间:0_10,100200
swift中的区间常见有两种
开区间:0..<10 表示:0~9,不包括10
闭区间:0...10 表示:0~10


let score = 92;

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循环的写法

最常规写法 (C-style for statement has been removed in Swift 3)swift3 之后不可以使用

// 传统写法
for var i = 0; i < 10; i++ {
    print(i)
}

区间for循环

for i in 0..<10 {
    print(i)
}

for i in 0...10 {
    print(i)
}

特殊写法
- 如果在for循环中不需要用到下标i

for _ in 0..<10 {
    print("hello")
}

while和do while循环

while循环
while的判断句必须有正确的真假,没有非0即真
while后面的()可以省略

var a = 0
while a < 10 {
    a++
}

do while循环
使用repeat关键字来代替了do


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

字符串的介绍

字符串在任何的开发中使用都是非常频繁的
OC和Swift中字符串的区别
在OC中字符串类型时NSString,在Swift中字符串类型是String
OC中字符串@"",Swift中字符串""
使用 String 的原因
String 是一个结构体，性能更高
NSString 是一个 OC 对象，性能略差
String 支持直接遍历
Swift 提供了 String 和 NSString 之间的无缝转换

字符串的使用

遍历字符串

// 字符串遍历
var str = "Hello, Swift"
for c in str.characters {//已过时
    print(c)
}

for c in str {
    print(c)
}

字符串拼接

两个字符串的拼接

let str1 = "Hello"
let str2 = "World"
let str3 = str1 + str2

字符串和其他数据类型的拼接

let name = "why"
let age = 18

let info = "my name is \(name), age is \(age)"

字符串的格式化
比如时间:03:04

let min = 3
let second = 4

let time = String(format: "%02d:%02d", arguments: [min, second])

字符串的截取

Swift中提供了特殊的截取方式
该方式非常麻烦
Index创建较为麻烦
-简单的方式是将String转成NSString来使用
在标识符后加:as NSString即可

let myStr = "www.520it.com"
var subStr = (myStr as NSString).substringFromIndex(4)
subStr = (myStr as NSString).substringToIndex(3)
subStr = (myStr as NSString).substringWithRange(NSRange(location: 4, length: 5))

数组

数组的介绍

数组（Array）是一串有序的由相同类型元素构成的集合
数组中的集合元素是有序的，可以重复出现
Swift中的数组
swift数组类型是Array，是一个泛型集合
数组分成:可变数组和不可变数组
使用let修饰的数组是不可变数组
使用var修饰的数组是可变数组

// 定义一个可变数组,必须初始化才能使用
var array1 : [String] = [String]()

// 定义一个不可变数组
let array2 : [NSObject] = ["why", 18]

在声明一个Array类型的时候可以使用下列的语句之一

var stuArray1:Array<String>
var stuArray2: [String]

声明的数组需要进行初始化才能使用，数组类型往往是在声明的同时进行初始化的

// 定义时直接初始化
var array = ["why", "lnj", "lmj"]

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

对数组的基本操作

// 添加数据
array.append("yz")

// 删除元素
array.removeFirst()

// 修改元素
array[0] = "why"

// 取值
array[1]

数组的遍历

// 遍历数组
for i in 0..<array.count {
    print(array[i])
}

// forin方式
for item in array {
    print(item)
}

// 设置遍历的区间
for item in array[0..<2] {
    print(item)
}

数组的合并


// 数组合并
// 注意:只有相同类型的数组才能合并
var array = ["why", "lmj","lnj"]
var array1 = ["yz", "wsz"]
var array2 = array + array1;

// 不建议一个数组中存放多种类型的数据
var array3 = [2, 3, "why"]
var array4 = ["yz", 23]
array3 + array4

字典

字典的介绍

字典允许按照某个键来访问元素
字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合
键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的
Swift中的字典
Swift字典类型是Dictionary，也是一个泛型集合

字典的初始化

Swift中的可变和不可变字典
使用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,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name2":"xiaozhang" as AnyObject, "Tel":1900 as AnyObject]

字典的基本操作

// 添加数据
dictM["name"] = "why" as AnyObject
dictM["age"] = 18 as AnyObject
dictM["height"] = 190 as AnyObject
dict

// 删除字段
dict.removeValueForKey("height")
dict

// 修改字典
dict["name"] = "lmj"
dict

// 查询字典
dict["name"]

字典的遍历

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

// 遍历所有的键值对
for (key, value) in dict {
    print(key)
    print(value)
}

字典的合并

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

var myDict = ["name":"zhao", "age":89, "Tel":dictM] as [String : Any]

元祖

元祖的介绍

元组是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(error.0)
print(error.1)

// 写法二:
let error = (errorCode : 404, errorInfo : "Not Found")
print(error.errorCode)
print(error.errorInfo)

// 写法三:
let (errorCode, errorIno) = (404, "Not Found")
print(errorCode)
print(errorIno)

可选类型

可选类型的介绍

注意:
可选类型时swift中较理解的一个知识点
暂时先了解,多利用Xcode的提示来使用
随着学习的深入,慢慢理解其中的原理和好处
概念:
在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)
在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强类型语言)
但是开发中赋值nil,在所难免.因此推出了可选类型
可选类型的取值:
空值
有值

定义可选类型

定义一个可选类型有两种写法
最基本的写法
语法糖(常用)

// 错误写法
// 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(string)
// 结果:Optional("Hello world")\n
// 因为打印出来的是可选类型,所有会带Optional


// 演练二:取出可选类型的值
// 取出可选类型的真实值(解包)
print(string!)
// 结果:Hello world\n

// 注意:如果可选类型为nil,强制取出其中的值(解包),会出错
string = nil
print(string!) // 报错

// 正确写法:
if string != nil {
    print(string!)
}

// 简单写法:为了让在if语句中可以方便使用string
// 可选绑定
// 1> 判断name是否有值,如果没有值,则不执行{}.
// 2> 如果有值,则对可选类型进行解包,并且将解包后的值赋值给前面的常量
//if let tempName = name {
//    print(tempName)
//}
if let str = string {
    print(str)
}

真实应用场景

目的:让代码更加严谨

// 通过该方法创建的URL,可能有值,也可能没有值.
// 错误写法:如果返回值是nil时,就不能接收了
// 如果字符串中有中文,则返回值为nil,因此该方法的返回值就是一个可选类型,而使用一个NSURL类型接收是错误的
let url : NSURL = NSURL(string: "www.520it.com")

// 正确写法:使用可选类型来接收
let url : NSURL? = NSURL(string: "www.520it.com")
// 该方式利用类型推导
let url = NSURL(string: "www.520it.com")

// 通过url来创建request对象:在使用可选类型前要先进行判断是否有值
// 该语法成为可选绑定(如果url有值就解包赋值给tempURL,并且执行{})
if let tempUrl = url {
    let request = NSURLRequest(URL: tempUrl)
}

函数

函数的介绍

函数相当于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("打电话给\(phoneNum)")
}
callPhone("+86 110")

// 3.没用参数,有返回值
func readMessage() -> String {
    return "吃饭了吗?"
}
var str = readMessage()
print(str)

// 4.有参数,有返回值
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}
var result = sum(20, num2: 30)
print(result)

函数的使用注意

注意一: 外部参数和内部参数

在函数内部可以看到的参数,就是内部参数
在函数外面可以看到的参数,就是外部参数
默认情况下,从第二个参数开始,参数名称既是内部参数也是外部参数
如果第一个参数也想要有外部参数,可以设置标签:在变量名前加标签即可
如果不想要外部参数,可以在参数名称前加_

// 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(20, 20)

注意二: 默认参数

某些情况,如果没有传入具体的参数,可以使用默认参数

func makecoffee(type :String = "卡布奇诺") -> String {
    return "制作一杯\(type)咖啡。"
}

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(30, 80)

注意四: 引用类型(指针的传递)

默认情况下,函数的参数是值传递.如果想改变外面的变量,则需要传递变量的地址
必须是变量,因为需要在内部改变其值
Swift提供的inout关键字就可以实现
对比下列两个函数

// 函数一:值传递
func swap(var a : Int, var b : Int) {
    let temp = a;
    a = b;
    b = temp

    print("a:\(a), b:\(b)")
}

var a = 10
var b = 20
swap(a, b: b)
print("a:\(a), b:\(b)")

// 函数二:指针的传递
func swap1(inout a : Int, inout b : Int) {
    let temp = a
    a = b
    b = temp

    print("a:\(a), b:\(b)")
}

swap1(&a, b: &b)
print("a:\(a), b:\(b)")

函数的嵌套使用

swift中函数可以嵌套使用
即函数中包含函数,但是不推荐该写法

// 函数的嵌套
let value = 55
func test() {
    func demo() {
        print("demo \(value)")
    }

    print("test")
    demo()
}

demo() // 错误
test() // 执行函数会先打印'test',再打印'demo'

Swift中类的使用

一. 类的介绍和定义

Swift也是一门面向对象开发的语言
面向对象的基础是类,类产生了对象
在Swift中如何定义类呢?
- class是Swift中的关键字,用于定义类

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

注意:
定义的类,可以没有父类.那么该类是rootClass
通常情况下,定义类时.继承自NSObject(非OC的NSObject)

二. 如何定义类的属性

类的属性介绍

Swift中类的属性有多种
存储属性:存储实例的常量和变量
计算属性:通过某种方式计算出来的属性
类属性:与整个类自身相关的属性

存储属性

存储属性是最简单的属性，它作为类实例的一部分，用于存储常量和变量
可以给存储属性提供一个默认值，也可以在初始化方法中对其进行初始化
下面是存储属性的写法
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方法来监听属性的改变
Swift中可以通过属性观察者来监听和响应属性值的变化
通常是监听存储属性和类属性的改变.(对于计算属性，我们不需要定义属性观察者，因为我们可以在计算属性的setter中直接观察并响应这种值的变化)
我们通过设置以下观察方法来定义观察者
willSet：在属性值被存储之前设置。此时新属性值作为一个常量参数被传入。该参数名默认为newValue，我们可以自己定义该参数名
didSet：在新属性值被存储后立即调用。与willSet相同，此时传入的是属性的旧值，默认参数名为oldValue
willSet与didSet只有在属性第一次被设置时才会调用，在初始化时，不会去调用这些监听方法
监听的方式如下:
监听age和name的变化

class Person : NSObject {
    var name : String? {
        // 可以给newValue自定义名称
        willSet (new){ // 属性即将改变,还未改变时会调用的方法
            // 在该方法中有一个默认的系统属性newValue,用于存储新值
            print(name)
            print(new)
        }
        // 可以给oldValue自定义名称
        didSet (old) { // 属性值已经改变了,会调用的方法
            // 在该方法中有一个默认的系统属性oldValue,用于存储旧值
            print(name)
            print(old)
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在赋值时,监听该属性的改变
// 在OC中是通过重写set方法
// 在swift中,可以给属性添加监听器
p.name = "why"

//p.name = "yz"

类的构造函数

构造函数的介绍

构造函数类似于OC中的初始化方法:init方法
默认情况下载创建一个类时,必然会调用一个构造函数
即便是没有编写任何构造函数，编译器也会提供一个默认的构造函数。
如果是继承自NSObject,可以对父类的构造函数进行重写

构造函数的基本使用

类的属性必须有值
如果不是在定义时初始化值,可以在构造函数中赋值

class Person: NSObject {
    var name : String
    var age : Int

    // 重写了NSObject(父类)的构造方法
    override init() {
        name = ""
        age = 0
    }
}

初始化时给属性赋值

很多时候,我们在创建一个对象时就会给属性赋值
可以自定义构造函数
注意:如果自定义了构造函数,会覆盖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]) {

        let tempName = dict["name"]
         //tempName是一个AnyObject?,转成String?
        // as? 最终转成的类型是一个可选类型
        // as! 最终转成的类型是一个确定的类型
        name = dict["name"] as? String
        age = dict["age"] as! Int
    }
}

// 创建一个Person对象
let dict = ["name" : "why", "age" : 18]
let p = Person(dict: dict)

字典转模型(利用KVC转化)

利用KVC字典转模型会更加方便
注意:
- KVC并不能保证会给所有的属性赋值
- 因此属性需要有默认值
  基本数据类型默认值设置为0
  对象或者结构体类型定义为可选类型即可(可选类型没有赋值前为nil)

class Person: NSObject {
    // 结构体或者类的类型,必须是可选类型.因为不能保证一定会赋值
    var name : String?

    // 基本数据类型不能是可选类型,否则KVC无法转化
    var age : Int = 0

    // 自定义构造函数,会覆盖init()函数
    init(dict : [String : NSObject]) {
        // 必须先初始化对象
        super.init()
        // 调用对象的KVC方法字典转模型
        setValuesForKeysWithDictionary(dict)
    }
}

// 创建一个Person对象
let dict = ["name" : "why", "age" : 18]
let p = Person(dict: dict)

闭包

闭包的介绍

闭包和OC中的block非常相似
OC中的block是匿名的函数
Swift中的闭包是一个特殊的函数
block和闭包都经常用于回调
注意:闭包和block一样,第一次使用时可能不习惯它的语法,可以先按照使用简单的闭包,随着学习的深入,慢慢掌握其灵活的运用方法.

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的参数)

    值:
    ^(参数列表) {
        // 执行的代码
    };

使用闭包代替block

定义网络请求的类

class HttpTool: NSObject {

 func loadData(callBack:@escaping (_ name:String)->(Void))
    {
       DispatchQueue.global(qos: .default).async
        {
            //处理耗时操作的代码块...
            print(Thread.current)
            
            //操作完成，调用主线程来刷新界面
            DispatchQueue.main.async
            {
                callBack("jsonData");
            }
        }
        
    }}
}

进行网络请求,请求到数据后利用闭包进行回调

  override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
        // 网络请求
        httpTool.loadRequest ({ () -> () in
            print("回到主线程", NSThread.currentThread());
        })
    }

闭包写法总结:


闭包的写法:
    类型:(形参列表)->(返回值)
    技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值

    值:
    {
        (形参) -> 返回值类型 in
        // 执行代码
    }

闭包的简写

如果闭包没有参数,没有返回值.in和in之前的内容可以省略

httpTool.loadRequest({
        print("回到主线程", NSThread.currentThread());
    })

尾随闭包写法:
如果闭包是函数的最后一个参数,则可以将闭包写在()后面
如果函数只有一个参数,并且这个参数是闭包,那么()可以不写

    httpTool.loadRequest() {
        print("回到主线程", NSThread.currentThread());
    }

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

swift中解决循环引用的方式

方案一:
使用weak,对当前控制器使用弱引用
但是因为self可能有值也可能没有值,因此weakSelf是一个可选类型,在真正使用时可以对其强制解包(该处强制解包没有问题,因为控制器一定存在,否则无法调用所在函数)

    // 解决方案一:
    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基础语法

常量和变量

常量和变量的使用注意:

Swift中数据类型

Swift类型的介绍

Swift中的类型推导

Swift中基本运算

逻辑分支

一. 分支的介绍

二. if分支语句

三. 三目运算符

四.guard的使用

四.switch分支

switch的介绍

switch的简单使用

Switch支持多种数据类型

支持字符串类型

switch支持区间判断

循环的介绍

for循环的写法

while和do while循环

字符串的介绍

字符串的使用

遍历字符串

字符串拼接

字符串的截取

数组

数组的介绍

对数组的基本操作

数组的遍历

数组的合并

字典

字典的介绍

字典的初始化

字典的基本操作

字典的遍历

字典的合并

元祖

元祖的介绍

元祖的定义

元祖的简单使用

可选类型

可选类型的介绍

定义可选类型

可选类型的使用

真实应用场景

函数

函数的介绍

常见的函数类型

函数的使用注意

注意一: 外部参数和内部参数

注意二: 默认参数

注意三: 可变参数

注意四: 引用类型(指针的传递)

函数的嵌套使用

Swift中类的使用

一. 类的介绍和定义

二. 如何定义类的属性

类的属性介绍

存储属性

计算属性

类属性

监听属性的改变

类的构造函数

构造函数的介绍

构造函数的基本使用

初始化时给属性赋值

字典转模型(初始化时传入字典)

字典转模型(利用KVC转化)

闭包

闭包的介绍

block的用法回顾

使用闭包代替block

闭包的简写

swift中解决循环引用的方式

懒加载

懒加载的介绍

懒加载的使用

相关文章

网友评论