- 1.在Swift中可选(optionals)类型,用"?"表示,用于处理值缺失的情况,表示"这儿有一个值,且它等于x"或者表示"这儿没有值"
- 2.可选类型是一个包含两种情况的枚举值,None和Some,,用来表示可能有值,或可能没有值
- 2.1nil就是Optional.None,当你声明一个可选变量或者可选属性时,没有提供初始值,它的值默认为nil
- 2.2非nil就是Optional.Some
- 3.任何类型都可以明确的声明为可选类型,当声明为一个可选类型的时候,要确保用括号给"?"操作一个合适的范围.例如;声明可选整数数组,应写成"(Int[])?",如果写成"Int[]?",会报错
//定义一个可选类型:两种声明方法相等
var Optional_1:Int?//在数据类型和"?"之间没有空格
var Optional_2:Optional<Int>
- 4.
"!"用来表示强制解析,如果可选类型实例包含一个值,可以用"!"来访问这个值
//注意:如果可选类型在无值的情况下进行强制解析,会崩溃eg:print(Optional_1!)
var intNumber:Int? = 8
var result = intNumber!
print(result)
- 5.1.可以在声明可选变量时,使用"!"类替换"?"这样可选变量在使用时就不需要再加一个"!"来取值,它会自动解析
- 5.2.隐式解析可选类型和可选类型一样,都是有值和没有值(nil)两种结果
- 5.3.在赋值时有区别,隐式类型可选类型,不需要再强制解析
- 5.4.注意:隐式解析可选类型的变量没有值时,程序一样会崩溃
var IntNumber:Int! = 10
print(IntNumber)
- 6.1可选绑定:用来判断可选类型是否包含值,如果包含就把值赋给一个临时常量或者临时变量
- 6.2可选绑定可用在if和while语句中,来对可选类型的值进行判断,并把它赋值给一个常量或者变量
- 6.3如果你不确定可选类型是否有值,用可选绑定,不需要对可选类型强制解析
var intNumberTow:Int?
if var intNumber = intNumberTow{
print("可选类型有值为:",intNumber)
}else{
print("可选类型无值")
}
Swift中的结构体
- 1.1.结构体不需要包含实现文件和接口文件
- 1.2.结构体允许我们创建一个单一文件,且系统会自动生成面向其他代码的外部接口
- 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类型
//声明一个结构体
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.值类型;
该类型每个实例持有数据的副本,并且该副本对于每个实例来说都是唯一的一份,比如结构体.枚举,元组都是值类型
- 值类型的使用场景
- 3.1:当使用"=="运算符比较实例数据的时候
- 3.2:想单独复制一份示例数据的时候
- 3.3:在多线程环境下操作数据的时候
struct StructObject {
var data:Int = -2
}
var value_1 = StructObject()
//将value_1赋给value_2,就是值拷贝的过程
var value_2 = value_1
print(value_2)
//value_1的数据改变对value_2没有影响
value_1.data = 0;
print("\(value_2.data)")
- 4.引用类型
该类型的实例共享数据唯一的一份副本,比如说类就是引用类型
class Classobject {
var data:Int = -1
}
var cob1 = Classobject()
//将cob1变量的值赋给cob2,就是引用的过程
var cob2 = cob1
cob1.data = 4
print(cob2.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 Car{
//声明存储属性
var kind:String?
//声明计算属性
var number:Int{
get{//获取变量
return 10
}
set{//设置变量
print(newValue)//newValue相当于这个参数,Swift会自动给我们创建一个名为newValue的常量并且可以用于set{}中。
}
}
//构造方法
init(kind:String){
self.kind = kind
}
}
//创建实例对象
var volvo = Car(kind: "XC90")
//访问
print(volvo.kind)
class Doctor{
//类属性
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 care(){//static修饰类方法,不可以被子类重写
print(age)
}
class func dZhen() {//class修饰类方法,可以被子类重写修饰
print(age)
}
//构造方法,在构造方法中不能使用类属性
init(name:String,age:Int){
self.name = name
}
//对象方法
func shuYe(){
print("对象对方")
}
}
//继承
class nurse:Doctor{
//重写父类方法,一定要在方法前加override修饰
override class func dZhen(){
print("重写了父类方法")
}
}
nurse.dZhen()
Swift中的协议
- 1.类,结构体,枚举都可以遵循协议,并提供具体实现来完成协议定义的方法和功能
- 2.任意能够满足协议要求的类型,被称为遵循(comform)这个协议
- 3.使用"@objc"修饰的协议,其中的方法,可以声明成可选实现(用optional修饰)
//带有可选实现函数的协议
@objc protocol Men{
func cook()//做饭
func wash()//洗衣服
optional func hitDouDou()//打豆豆
}
//必须全部实现函数的协议
protocol Divid{
func lookAfterKid()
}
//要遵循某个协议,如果类在遵循协议的同时拥有父类,应将父类名放在协议之前,用逗号分割,eg:
//声明一个doc类,继承Doctor,且遵循Men和Divid协议
class doc: Doctor ,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.lookAfterKid()
doc_1.cook()
doc_1.wash()
swift中的扩展
- 1.extension + 类名或者结构体名(可以对一个类或者结构体扩展方法)
- 2.extension可以多次对一个类进行扩展,也可以给一个类扩展协议方法
- 3.扩展就是向一个已有的类,结构体,枚举添加新功能
- 4.扩展可对一个类添加新功能,但不能重写已有功能
//对一个类进行方法的扩展(添加方法)
extension doc{
//扩展一个对象方法
func say(){
print("扩展的对象方法")
}
//扩展一个类方法
class func eat() {
print("扩展的类方法")
}
}
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
}
//第二种方式
maxResult = {
a,b in
return a > b ? a: b
}
print(maxResult(a: 3, b: 5))
//第三种方式
maxResult = {
a,b in
a > b ? a: b
}
//第四种方式 苹果推荐格式
maxResult = {
(a,b)->Int in
return a > b ? a: b
}
//第五种方式 都省略 使用$表示取第几个参数
maxResult = {
$0 > $1 ? $0 : $1
}
print(maxResult(a: 3, b: 5))
