水落鱼梁浅,天寒梦泽深<水跃鱼>
可选变量:
一. 在Swift中可选类型(Optionals),用 " ? " 号表示, 用于处理值缺失的情况. 表示"该处有一个值, 切它等于X", 或者表示"该处没有值"
二. 可选类型是一个包含两种情况的枚举值: None 和 Some , 用来表示可能有值(Some) 或可能没有值(None)
2.1 nil 就是Optional.None, 当你声明一个可选变量, 或者可选属性的时候, 没有提供初始化值, 它的值默认为 nil
2.2 非nil 就是Optional.Some
三. 任何类型都可以明确的声明为可选类型, 当声明一个可选类型的时候, 要确保用括号给" ? " 操作符一个合适的范围. 例如: 声明可选整数数组, 格式为: (Int[])?, 如果写成"Int[]?", 就会报错
定义一个可选类型: 两种方式
var Optional_1:Int? //注意: 在数据类型和" ? "号之间没有空格
var Optional_2:Optional<Int> // 这里表明关键字可选类型
四: " ! " 号, 用来表示强制解析, 如果可选类型实例包含一个值, 可以用" ! "号来访问这个值.
注意: 如果可选类型在没有赋值的情况下, 进行强制解析, 会导致崩溃
var intNumber:Int? = 8
var result1 = intNumber // 打印结果Optional(8)
var result2 = intNumber! // 打印结果直接是 8
print(result1, result2
五. 自动解析(隐式解析)
5.1 你可以在声明可选变量时, 使用 " ! " 号来替换 " ? ", 这样可选变量在使用时, 就不需要在加一个 " ! "进行解析了, 它会自动解析.
5.2 隐式解析可选类型和可选类型一样, 都是有值和没有值(nil)两种结果.
5.3 区别在于赋值/取值时, 隐式解析可选类型不需要再强制解析
5.4 注意: 隐式解析可选类型的变量没有值时, 程序一样会崩溃
var IntNumberOne:Int! = 10
print(IntNumberOne)
六. 可选绑定
6.1 可选绑定: 用来判断, 可选类型是否包含值, 如果包含就把值赋给一个临时常量/临时变量
6.2:可选绑定可以用在 if 和 while 语句中来对可选类型的值进行判断, 并把他赋给一个常量或者变量
6.3 如果你不确定类型是否有值, 用可选绑定, 不需要对可选类型强制解析
var intNumberTow:Int?
if var intNumberThree = intNumberTow
{
print("可选类型有值 = ",intNumberThree)
}else
{
print("可选类型没有值")
}```
--------------------
结构体:
-------
>一: 与 C 和 OC 不同的是:
1.1: 结构体不需要包含实现文件和接口文件
1.2: 结构体允许我们创建一个单一文件, 且系统会自动生成该结构体面向其他代码的外部接口
> 二: 结构体总是通过被复制的方式在代码中传递, 因此, 该结构体原本的值是不可修改的
>三: 结构体的应用
3.1: 在代码中可以使用结构体定义你的自定义类型数据
3.2: 按照通用的准则, 当符合一条或者多条以下条件时候, 请考虑构建结构体
>> 3.2.1: 结构体的主要目的是用来封装少量相关简单数据
3.2.2: 有足够的理由预计一个结构体实例在赋值或者传递时, 封装的数据将会被拷贝而不是应用
3.2.3: 任何结构体中存储的值类型属性, 也将会被拷贝, 而不是被应用
3.2.4: 结构体不需要继承另一个已经存在类型的属性或者行为
> 四: 举例:
4.1: 几何形状大小, 封装一个 width 属性和 height 属性,两者均为 Double 类型
4.2: 一定范围的路径, 封装一个 Start 属性和 Length 属性, 两者均为 Int 类型
4.3: 三维坐标系内的一点, X, Y, Z, 三者均为 Double 类型
``` code
// 声明一个结构体
struct piontOf3D
{
// 声明结构体变量的属性 (存储属性)
var X : Double
var Y : Double
var Z : Double
}
// 创建结构体实例
var D3:piontOf3D = piontOf3D.init(X: 1, Y: 1, Z: 1)
// 声明一个结构体
struct Rect
{
var ponit : (x : Int , y : Int) = (0 , 0)
var size :(w :Int , h : Int ) = (0 , 0)
// 成员方法
func getSize()
{
print(size)
}
// 类方法 : 用 Static 修饰
static func sayHellon ()
{
print("你好, 我是结构体类方法")
}
}
var rect2 : Rect = Rect.init(ponit: (x: 10, y: 10), size: (w: 20, h: 20))
// 调用成员方法
rect2.getSize()
// 调用类方法 (用结构体名调用)
Rect.sayHellon()
类:
一 : swift 中类和结构体有很多共同点
1.1: 定义属性, 用于存储值
1.2: 定义方法, 用于提供功能
1.3: 定义构造器, 用于提供初始化值
1.4: 遵循协议, 用来对某个类提供标准功能
1.5: 通过扩展, 用来增加默认实现的功能
二 : 与结构体 相比又有其他附加功能
2.1: 继承允许一个类继承另一个类的特征
2.2: 类型转换允许在运行时检查和解释一个类实例的类型
2.3: 引用计数: 允许对一个类多次引用
三 : 存储属性: 存储属性就是类或者结构体里定义的变量 (或者变量) (OC 中的一个类中引用另一个类)
3.1: 存储属性可以是变量存储属性(var 修饰), 也可以是常量存储属性(let 修饰)
3.2: 可以在定义存储属性的时候指定默认值
3.3: 也可以在构造过程中设置或者修改存储属性的值
四: 计算属性 不直接存储值, 而是提供一个 getter 和一个可选的 setter, 来间接获取和设置其他属性常量或者变量的值
// 声明一个类
class Car
{
// 声明存储属性
var kind : String?
// 声明计算属性
var number : Int
{
get
{
return 10
}
set
{
print(newValue) // 相当于这个传入参数
}
}
// 构造方法
init (kind : String)
{
self.kind = kind
}
}
// 创建实例对象
var volvo = Car (kind: "BMW")
// 访问
print(volvo.kind,volvo.number)
// 声明类属性
class Docter
{
// 类属性只能类方法调用
static var name : String?
// 声明类方法 static 修饰 子类不可以重写 类方法中只能使用类属性 不能使用对象属性
static func sayBybeBybe ()
{
print(name)
}
// 子类可以重写的类方法
class func sayNoByble()
{
print(name)
}
// 对象方法
func sayGoodBybe()
{
print("我就是实例方法")
}
var age : Int?
var Number : Int{
get
{
return age!
}
set (value)// 这种写法表示在调用的 Number的 set 方法时, 传过来参数赋给 value
{
age = value // 切记: set\get 方法中不能使用"self.名称 ", 会造成递归
}
}
// 构造方法中不能使用类属性
}
var DaPeng : Docter = Docter()
DaPeng.sayGoodBybe()
// 继承
class nurse: Docter
{
override class func sayNoByble()
{
print("重写了父类的方法, 使用 override 修饰")
}
}
值类型与引用类型:
一:值类型:
该类型的每一个实例持有数据的副本, 并且该副本对于每一个实例来说都是唯一的一份, 比如结构体, 枚举, 元组都是值类类型
二: 值类型使用场景
2.1: 当使用"==" 运算符比较实例数据的时候
2.2: 当想单独赋值一份实例数据的时候
2.3: 在多线程环境下操作数据的时候
三: 引用类型(如同 OC 中的指针指向同一内存)
该类型的实例共享数据唯一的一份副本, 比如说(class)类就是引用类型
值类型:
struct StructObject
{
var data : Int = 1
}
var value_1 : StructObject = StructObject()
// 将 value_1 的值赋给 value2, 就是一个拷贝的过程
var value_2 = value_1
print(value_2)
// 这里只能改变 value_1 的值 不能改变 value_2 的值 这些都是值类型
value_1.data = 0
print("值引用都是副本\(value_1.data)************\(value_2.data)")
引用类型:
class ClassObjecct
{
var data : Int = -1
}
var cob_1 = ClassObjecct()
// 将 cob_1的值赋给 cob_2, 就是引用的过程
var cob_2 = cob_1
cob_1.data = 4
print("引用类型, 改一个全部改了",cob_1.data, cob_2.data)
var cob_3 = ClassObjecct()
print(cob_3.data)
协议:
- 1: 协议定义了一个蓝图,规定了用来实现某一特定工作或者功能所必需的方法和属性
- 2: 类, 结构体, 枚举都可以遵守协议, 并提供具体实现来完成协议定义的方法和功能
- 3: 任意能够满足协议要求的类型, 被称为(conform)这个协议
- 4: 使用"@objc"修饰的协议, 其中的方法, 可以声明成可选实现(用 optional 修饰)
注意1:
- 使用@objc修饰的协议表示 OC 的协议
- @objc修饰的协议
不可用在结构体里面遵守 - 使用@objc修饰的协议里可以声明可选实现的函数(用
optional修饰函数) - 在实现这个函数的时候,在函数前面要加
@objc修饰
注意2:
- 使用
mutating修饰的函数可以在结构体里面修改结构体的属性 - 协议里面使用mutating修饰的函数,在遵守协议的时候可以不使用mutating修饰,在类里没有影响,在结构体力面,就不能修改属性的值了.
- 但是如果实现协议里没有mutating修饰的函数的时候,却用了mutating修饰,结果是在结构体重新声明了一个函数,此函数和协议无关系
// 带有可选实现函数的协议
@objc protocol MenDelegate
{
func cook()
func wash()
optional func hitJJ()
}
// 必须实现的 函数协议
protocol DividDelegate
{
func lookKid()
}```
- 要遵循某个协议, 如果类在遵循协议的同时拥有父类, 应该将父类名放在协议之前, 用逗号隔开
```code
# doc 继承于 Docter类 遵守 MenDelegate,DividDelegate协议
class doc: Docter,MenDelegate,DividDelegate
{
#实现协议方法
@objc func cook() {
print("做饭的女人")
}
@objc func wash() {
print("洗衣服的女人")
}
func lookKid() {
print("照顾孩子")
}
}
// 创建实例 并调用类的实例方法
var doc1 : doc = doc()
doc1.cook()
doc1.lookKid()
doc1.wash()
延展:
1: Extension + 类名或者结构体名 (可以给一个类或者结构体扩展方法)
2: Extension 可以多次对一个类进行扩展, 也可以给一个类扩展协议方法
3: 扩展就是向一个已有的类, 结构体, 枚举添加新功能
4: 扩展可以对一个类型添加新的功能, 但是不能重写已有的方法
// 给 doc 类扩展方法
extension doc
{
// 实例方法
func say()
{
print("i-LOVE-u")
}
// 扩展类方法
class func eat()
{
print("i-WANT-u")
}
}
doc.eat()
doc1.say()
// 扩展一个 类 遵循协议中的方法
@objc protocol Magic
{
func magic ()
}
extension doc : Magic
{
@objc func magic()
{
print("我会变魔术")
}
}
var docc : doc = doc()
docc.magic()
// 给协议新添加方法并实现 遵循这个协议的实例可以调用这个方法
// 扩展一个 类遵循协议 中的方法
extension MenDelegate
{
func magic()
{
print("12345678")
}
}
class stu : MenDelegate
{
@objc func wash() {
}
@objc func cook() {
}
}
var sutt : stu = stu()
sutt.magic()
闭包:
1: 闭包: 是自包含的函数代码块, 可以再代码中被传递, 使用
2: Swift 中的闭包和 OC 中的 Block 以及其他语言中的匿名函数类似
3: 闭包可以捕获和存储其所在上下文中任意的常量和变量 (闭包并包裹着这些常量和变量)
4: Swift 会帮你管理在捕获过程中涉及到的内存操作
5: 格式: {(参数名 : 类型) ->返回值类型 in 需要执行的代码 }
6: let backString = {(name : String) -> String in return name }
7: 闭包的函数体部分由关键字 in 引入, 该关键字表示闭包的参数和返回值类型定义已经完成, 闭包函数体即将开始
代码举例:
// 求两个数的最大值
// (a : Int , b : Int ) -> Int是表示maxReult的函数类型
var maxReult : ((a : Int , b : Int ) -> Int )
// 第一种方式
maxReult = {(a : Int , b : Int ) -> Int in
return a > b ? a : b
}
// 第二种方式
maxReult = { a , b -> Int in return a > b ? a : b }
// 第三种方式
maxReult = { a , b in a > b ? a : b }
// 第四种方式 (官方推荐)
maxReult = {( a , b) -> Int in return a > b ? a : b }
// 第五种方式
maxReult = { $0 > $1 ? $0 : $1 }
print(maxReult(a: 3,b: 5))
网友评论