Swift中"?"和"!"
- 1.在swift中可选（optionals）类型，用"?"表示，用于处理值缺失的情况，表示“这儿有一个值，且它等于x”或者表示“这儿没有值”
- 2.可选类型是一个包含两种情况的枚举值––None和Some，用来表示 可能有值 或 可能没有值。
- 2.1 nil 就是 Optional.None,当你声明一个可选变量或者可选属性的时候，没有提供初始值，它的值默认为nil
- 2.2 非nil 就是Optional.Some
- 3.任何类型都可以明确的声明为可选类型，当声明一个可选类型的时候，要确保用括号给"?"操作符一个合适的范围。例如：声明可选整数数组，应该写成"(Int[])?"，如果写成“Int[]?”,就会报错
//定义一个可选类型：以下两种声明方式是相等的
var Optional_1:Int?//在数据类型和"?"之间没有空格
var Optional_2:Optional
- 4."!"：用来表示强制解析，如果可选类型实例包含一个值，可以用"?"来访问这个值
//注意：如果可选类型在无值的情况下进行强制解析，会导致崩溃
var intNumber:Int? = 8
var result = intNumber!
print(result)
- 5.1 你可以在声明可选变量时，使用"!"来替换"?"，这样可选变量在使用时就不需要再加一个"!"来取值了，他会自动解析
- 5.2 隐式解析可选类型好人可选类型一样，都是有值和没有值(nil)两种结果
- 5.3 区别是赋值时，隐式解析可选类型不需要再强制解析
- 5.4 注意：隐式解析可选类型的变量没有值时，程序一样会崩溃
var IntNumberOne:Int! = 10
print(IntNumberOne)
- 6.1 可选绑定：用来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者临时变量。
- 6.2 可选绑定可以用在if 和 while 语句中来对可选类型的值进行判断，并把它赋给一个常量或者变量
- 6.3 如果你不确定可选类型是否有值，用可选绑定，不需要对可选类型强制解析
var intNumberTwo:Int?
if var intNumberThree = intNumberTwo{
print("可选类型有值 = \(intNumberThree)")
}else{
print("可选类型无值")
}
Swift中的结构体
- 1.1 结构体不需要实现文件和接口文件
- 1.2 结构体允许我们创建一个单一文件，且系统会自动生成该结构体用于面向其他代码的外部接口
- 2.结构体总是通过被复制的方式在代码中传递，因此，原本结构的值是不可修改的
- 3.结构体的应用
- 3.1 在代码中，可以使用结构体定义你的自定义数据类型
- 3.2 按照通用的准则，当符合一条或者多条以下条件下时，请考虑构建结构体
- 3.2.1 结构体的主要目的是用来封装少量相关简单数据
- 3.2.2 有理由预计一个结构体实例在赋值或者传递时，封装的数据将会被拷贝而不是引用
- 3.2.3 任何结构体中存储的值类型属性，也将会被拷贝，而不是被引用
- 3.2.4 结构体不需要去继承另一个已存在类型的属性或者行为
- 4.例如：
- 4.1 几何形状的大小，封装一个width属性和height属性，两者均为Double类型
- 4.2 一定范围的路径，封装一个Start属性和length属性，两者均为Int类型
- 4.3 三维坐标系内的一点，x,y,z属性，三者均为Double类型
//声明一个结构体
struct pointOf3D {
//声明结构体变量的属性（存储属性）
var X:Double
var Y:Double
var Z:Double
}
var point:pointOf3D = pointOf3D(X: 10, Y: 11, Z: 12)
//声明一个结构体
struct Rect {
var point:(x:Int,y:Int) = (0,0)
var size:(w:Int,h:Int) = (0,0)
//成员方法
func getSize(){
print(size)
}
//类方法：用static修饰
static func sayHello(){
print("hello")
}
}
var rect2:Rect = Rect(point: (10,10), size: (50,50))
//调用成员方法
rect2.getSize()
//调用类方法(类方法用类名直接调用，在结构体里用结构体调用)
Rect.sayHello()
Swift中的类
- 1.1 定义属性，用于存储值
- 1.2 定义方法，用于提供功能
- 1.3 定义构造器，用于提供初始化值
- 1.4 遵循协议，用来对某个类提供标准功能
- 1.5 通过扩展，用来增加默认实现的功能
- 2.与结构体相比，又有其他附加功能
- 2.1 继承允许一类继承另一个类的特征
- 2.2 类型转换允许在允许时检查和解释一个类实现的类型
- 2.3 引用计数:允许对一个类多次引用
//定义一个雷：使用class修饰类
class Person{
var name:String?
var gender:String?
var age:Int?
}
- 3.1 该类型的每个实例持有数据的副本，并且该副本对于每个实例来说都是唯一的一份，比如结构体，枚举，元组都是值类型
- 3.2 值类型的使用场景
- 3.2.1 当使用“==”运算符比较实例数据的时候
- 3.2.2 想单独赋值一份实例数据的时候
- 3.2.3 在多线程环境下操作数据的时候
struct StructObject {
var data:Int = -1
}
var value_1 = StructObject()
//将value_1的值赋给value_2，就是一个拷贝的过程
var value_2 = value_1
print(value_2)
//value_1的数据改变，而value_2没有改变
value_1.data = 1
print("\(value_1.data)...\(value_2.data)")
- 4.引用类型
该类型的实例共享数据唯一的一份副本。比如说类（class）就是引用类型
class ClassObject {
var data:Int = -1
}
var cob_1 = ClassObject()
//将cob_1变量的值赋给cob_2,就是引用的过程
var cob_2 = cob_1
//将cob_1的值改变，cob_2的值也改变了
cob_1.data = 4
print("\(cob_1.data)...\(cob_2.data)")
//定义一个类
class animal{
var kind:String?
var name:String?
//类的构造方法(类似初始化方法)，与OC中的构造器不同，Swift的构造器无需返回值，他们的主要任务是保证新实例在第一次使用前完成正确的初始化
init(kind:String,name:String){
self.kind = kind
self.name = name
}
}
//创建实例对象
var lion = animal(kind: "大型猫科", name: "狮子")
//访问对象的属性
print(lion.name)
- 6.存储属性：存储属性就是类或者结构体里定义的变量（或者常量）
- 6.1 存储属性可以是变量存储属性（var修饰），也可以是常量存储属性（let修饰）
- 6.2 可以在定义存储属性的时候指定默认值
- 6.3 也可以在构造过程中设置或修改存储属性的值
- 7.计算属性：不直接存储值，而是提供一个getter 和一个可选的setter，来间接获取和设置其他属性常量或变量的值
class Docter{
//类方法
static var age:Int?
//对象方法
var name:String?
//计算属性
var Number:String{
get{
return name!
}
set(value){//这种写法表示在调用Number的set方法时，传过来的参数会赋给value
name = value//切记：set\get方法中万不能适应"self.属性"，会造成递归
}
}
//类方法：类方法中，不能使用对象属性，只能使用类属性
static func kanBing(){
print(age)
}
class func daZhen(){
print(age)
}
//构造方法：不能使用类属性
init(name:String,age:Int){
self.name = name
}
//对象方法
func shuYe(){
print("对象方法")
}
}
//继承
class nurse:Docter{
//重写父类方法，一定要在方法前加override
override class func daZhen(){
print("我是子类，重写了父类的class func daZhen()方法，用override修饰")
}
}
nurse.daZhen()
Swift中的协议
- 1.类、结构体、枚举都可以遵循协议，并提供具体实现来完成协议定义的方法和功能
- 2.任意能够满足协议要求的类型，被称为遵循（conform）这个协议
- 3.使用“@objc”修饰的协议，其中的方法，可以声明成可选实现(用optional修饰)
//带有可选实现函数的协议
@objc protocol Men{
func cook()//做饭
func wash()//洗衣服
optional func hitDouDou()//打豆豆
}
//必须全部实现函数的协议
protocol Divid{
func lookAfterKid()
}
//要遵循某个协议，如果类在遵循协议的同时拥有父类，应该将父类名放在协议之前，用逗号分隔，例如：
//声明一个doc类，继承于Docter，且遵守Men和Divid
class doc:Docter,Men,Divid {
//Men协议下的两个方法（optional修饰的方法，可实现，也可不实现）
@objc func cook() {
print("做饭")
}
@objc func wash() {
print("洗衣服")
}
//Divid写一下的一个方法，必须实现
func lookAfterKid() {
print("照顾孩子")
}
}
let doc_1:doc = doc(name: "大卫", age: 33)
doc_1.cook()
doc_1.wash()
doc_1.lookAfterKid()
Swift中的扩展
扩展（Extension）
- 1.extension + 类名或者结构体名（可以对一个类或者结构体扩展方法）
- 2.extension可以多次对一个类进行扩展，也可以一个类扩展协议方法
- 3.扩展就是向一个已有的类、结构体、枚举添加新功能
- 4.扩展可以对一个类型添加新功能，但是不能重写已有的功能
//1.对一个类进行方法的扩展（添加方法）
extension doc{
//扩展一个对象方法
func say(){
print("I Love U")
}
//扩展一个类方法
class func eat() {
print("I want to eat something")
}
}
doc_1.say()
doc.eat()//类方法用类名直接调用
//2.扩展一个 类遵循的协议 中的方法
extension doc{
@objc func Magic(){
print("变魔术")
}
}
doc_1.Magic()
Swift中的闭包
- 1.闭包：是自包含的函数代码块，可以在代码中被传递、使用
- 2.swift中的闭包，和OC中的block以及其他语言中的匿名函数类似
- 3.闭包可以捕获和存储其所在上下文中任意的常量和变量（闭合并包裹着这些常量和变量）
- 4.swift会帮你管理在捕获过程中涉及到的内存操作
- 5.格式：
{(参数名:类型)->返回值类型 in
需要执行的代码
}
- 6.例如：
let backString = {(name:String)-> String in
return name
}
- 7.in：闭包的函数体部分由关键字in引入，该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始
//求两个数的最大值（三目运算符）
//(a:Int,b:Int)->Int是maxResult的函数类型
var maxResult:((a:Int,b:Int)->Int)
//第一种方式
maxResult = {(a:Int,b:Int)->Int in
return a > b ? a : b
}
print(maxResult(a: 3, b: 5))
//第二种方式
maxResult = {
a,b in
return a > b ? a : b
}
print(maxResult(a: 3, b: 5))
//第三种方式
maxResult = {
a,b in
a > b ? a : b
}
print(maxResult(a: 3, b: 5))
//第四种方式
maxResult = {
(a,b)->Int in
return a > b ? a : b
}
print(maxResult(a: 3, b: 5))
//第五种方式
maxResult = {
$0 > $1 ? $0 : $1
}
print(maxResult(a: 3, b: 5))
