美文网首页
进阶17 Swift2

进阶17 Swift2

作者: 轩洛 | 来源:发表于2016-07-19 23:00 被阅读0次

    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<Int>
    • 4."!"：用来表示强制解析，如果可选类型实例包含一个值，可以用"?"来访问这个值
      //注意：如果可选类型在无值的情况下进行强制解析，会导致崩溃
    var intNumber:Int? = 8
var result = intNumber!
print(result)
    • 5.自动解析（隐式解析）
     - 5.1 你可以在声明可选变量时，使用"!"来替换"?"，这样可选变量在使用时就不需要再加一个"!"来取值了，他会自动解析
 - 5.2 隐式解析可选类型好人可选类型一样，都是有值和没有值(nil)两种结果
 - 5.3 区别是赋值时，隐式解析可选类型不需要再强制解析
 - 5.4 注意：隐式解析可选类型的变量没有值时，程序一样会崩溃

    var IntNumberOne:Int! = 10
print(IntNumberOne)
    • 6.可选绑定
    • 6.1 可选绑定：用来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者临时变量。
    • 6.2 可选绑定可以用在if 和 while 语句中来对可选类型的值进行判断，并把它赋给一个常量或者变量
    • 6.3 如果你不确定可选类型是否有值，用可选绑定，不需要对可选类型强制解析
    var intNumberTwo:Int?
if var intNumberThree = intNumberTwo{
    print("可选类型有值 = \(intNumberThree)")
}else{
    print("可选类型无值")
}

    Swift中的结构体

    • 1.与 C 和 OC 不同的是：
     - 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.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.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)")
    • 5.类的定义和构造方法
    //定义一个类
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))

    相关文章

      网友评论

          本文标题：进阶17 Swift2

          本文链接：https://www.haomeiwen.com/subject/zhqvjttx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|进阶17 Swift2 |投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！