Swift(2)

可选类型(?)

隐式解析可选类型(!)

结构体

类

协议

扩展

闭包

demo截图.png

import Foundation

//MARK:--------------------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>
var intNumber : Int? = 100
// 打印出来以后是一个Optional类型的值
print(intNumber)
// 如果要取到100，必须对可选类型强制解析
print(intNumber!)

// 4. "!"：用来强制解析，如果可选类型实例包含一个值，可以用"!"来访问这个值
// 注意：可选类型分为有值和没值，如果可选类型的变量没值时对其强制解包，程序就会崩溃，如下面的程序：
/*
var Number : Int?
print(Number!)
*/

/*
   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("可选类型无值")
}
//MARK:----------------------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 + 结构体名字 + {结构体实现}

struct Frame
{
    // 存储属性 就是类或结构体里定义的变量(或常量）
    var x : Float
    var y : Float
    var width : Float
    var height : Float
    
    // 计算属性 除存储属性外,类、结构体和枚举可以定义计算属性.计算属性不直接存储值,而是提供一个getter和一个可选的setter,来间接获取和设置其他属性或变量的值
    // get方法 ：在属性类型后面添加{},使用get关键字声明和实现get方法
    // set方法 ：同上
    // set方法不可以单独出现，必须搭配着get方法才可以出现，但是get方法可以单独出现
    var centerX : Float {
        get{
            return x + width / 2
        }
    }
    var centerY : Float {
        get{
            return y + height / 2
        }
    }
    // 结构体属性  只能通过结构体去调用
    static var myStruct = "我是一个结构体属性"
    // 结构体中可以声明和实现成员方法即函数
    func sayHI()
    {
        print("你好，我是一个方法")
    }
    // 结构体的类方法：方法前用static修饰，只能由结构体调用
    static func sayHello()
    {
        print("hello")
        // 结构体类方法中只能调用结构体属性
        print(self.myStruct)
    }
    // 结构体自带有初始化方法，但是也可以重写
    init(x newX : Float, y newY : Float, width newWidth : Float, height newHeight : Float)
    {
        x = newX
        y = newY
        width = newWidth
        height = newHeight
    }
}
// 调用结构体属性（因为是结构体属性，所以只能由结构体调用，不能由对象调用）
print(Frame.myStruct)
// 调用结构体的类方法
Frame.sayHello()

// 结构体有自带的构造体方法和初始化方法
// 以下这两种创建对象的方式没区别
var frame : Frame = Frame(x: 10, y: 10, width: 100, height: 100)
var frame1 : Frame = Frame.init(x: 10, y: 10, width: 100, height: 100)
print(frame.centerX)
// 调用Frame结构体的成员方法
frame1.sayHI()

//MARK:-----------------------Swift中的类-----------------------
// 类是人们构建代码所用的一种通用且灵活的构造体。我们可以使用与结构体完全相同的语法规则来为类定义属性（常量、变量）和添加方法
/*
 1. swift中，类和结构体有很多共同点
    1.1 定义属性，用于存储值
    1.2 定义方法，用于提供功能
    1.3 定义构造器，用于提供初始化值
    1.4 遵循协议，用来对某个类提供标准功能
    1.5 通过扩展，用来增加默认实现的功能
 2. 与结构体相比，又有其他附加功能
    2.1 继承，允许一类继承另一个类的特征
    2.2 类型转换允许在运行时检查和解释一个类实例的类型
    2.3 引用计数：允许对一个类多次引用
*/
// 值类型：该类型的每个实例持有数据的副本，并且该副本对于每个实例来说是独一无二的一份，比如结构体（struct）、枚举（enum）、元组（tuple）都是值类型
/*
值类型的使用场景：
    当使用"=="运算符比较数据的时候
    想单独复制一份实例数据的时候
    在多线程环境下操作数据的时候
*/
/*
// 创建一个StructObject结构体变量
struct StructObject
{
    var data : Int = -1
}
var a = StructObject()
// b是a的拷贝
var b = a
// 更改a的数据，b的不受影响
a.data = 42
print("\(a.data), \(b.data)")
*/

// 引用类型：该类型的实例共享数据唯一的一份副本（在native层面说的话，就是该类型的每个实例都指向内存中的同一个地址），比如类（class）就是引用类型

/*
// 创建一个ClassObject类
class ClassObject
{
    var data : Int = -1
}
var a = ClassObject()
// 将a变量的值赋值给b，其实是一个引用的过程
var b = a
// a的数据改变了，但是b也发生了改变
a.data = 42
print("\(a.data), \(b.data)")
*/

/*
使用值类型的情形：
   使用 == 运算符比较实例数据的时候
   单独复制一份实例数据的时候
   在多线程环境下操作数据的时候
使用引用类型（比如class）的情形：
   使用 == 运算符判断两个对象是否引用同一个对象实例的时候
   当上下文需要创建一个共享的、可变的对象时
*/

// 类的定义格式：class + 类名 + {类的实现}
class Person
{
    // 当给一个类写属性的时候，这个属性如果没有初值那就需要是可选类型
    // 存储属性
    var name : String?
    var gender : String?
    var age : Int?
    
    // 计算属性
    var width : Float {
        get{
            return 100
        }
        set{
            // set方法中的newValue表示新的值
            self.width = newValue
        }
    }
    // 此处static修饰的是类属性
    static var hooby : String? = "大播"
    // 此处static修饰的是类方法，这时类方法可以调用static修饰的类属性
    static func sayMy()
    {
        print(hooby!)
    }
    // 没用static修饰的类方法不能调用static修饰的属性
    func sayHI()
    {
        print("你好啊\(self.width)")
        name = "污唐"
    }
    // 声明类方法时，static和class都可以修饰类方法，区别在于class修饰的类方法可以被子类重写。class修饰的类方法可以调用static修饰的属性,但是class自己不能修饰属性
    class func saySaWaDiKa()
    {
        print(hooby!)
    }
    // 类的构造方法  系统没有自带，需要自己写了才能调用
    init(name newName : String, gender newGender : String, age newAge : Int)
    {
        name = newName
        gender = newGender
        age = newAge
    }
}
// 创建实例对象的两种方式（这两种方式没区别）：
var person : Person = Person.init(name: "王梁", gender: "女", age: 8)
var person1 : Person = Person(name: "鸭王", gender: "女", age: 3)
// 调用实例对象的属性
print(person.age!)
// 实例person1调用实例方法sayHI()
person1.sayHI()
// 类Person调用static修饰的类方法sayMy()
Person.sayMy()
// 类Person调用class修饰的类方法saySaWaDiKa()
Person.saySaWaDiKa()

class student : Person
{
    var number : NSString?
    
    // 重写父类的方法 ：需要添加override修饰
    override func sayHI()
    {
        print("重写方法")
    }
    // 重写父类的init构造方法
     override init(name newName : String, gender newGender : String, age newAge : Int)
    {
        super.init(name: newName, gender: newGender, age: newAge)
        name = newName
        gender = newGender
        age = newAge
    }
    // 在重新创建一个init方法的时候 还是需要super.init
    init(number newNumber : NSString)
    {
        super.init(name: "张三", gender: "男", age: 1)
        number = newNumber
    }
}
var stu1 : student = student.init(name: "小明", gender: "男", age: 9)
stu1 = student.init(number: "007")
print(stu1.name!,stu1.number!)
stu1.sayHI()

//MARK:----------------------Swift中的协议-----------------------
/*
  协议定义了一个蓝图，规定了用来实现某一特定工作或者功能所必需的方法和属性
  类、结构体或枚举类型都可以遵循协议，并提供具体实现来完成协议定义的方法和功能
  任意能够满足协议要求的类型被称为遵循(conform)这个协议
*/

// 声明协议
// protocol声明的协议，表示Swift的协议，所有的方法都必须实现
protocol myDelegate
{
    // 协议方法
    func test()
    // 使用mutating修饰的函数，可以在结构体里面修改结构体的属性
    // 在协议里面使用mutating修饰的函数，在遵守协议的时候，类里面不能使用mutating修饰。但是在结构体里面，如果要修改属性的话必须用mutating修饰方法
    mutating func change()
}
// @objc修饰的协议表示这个协议是OC的协议，可以声明可选实现的函数，在函数名前面用optional修饰，这个函数就是可选实现的了
@objc protocol newDelegate
{
    optional func newTest()
    func newChange()
}

class Teacher : Person, myDelegate, newDelegate {
    // 必须实现的方法
    func test()
    {
        name = "111"
        print("aaa")
    }
    // 必须实现的方法
    @objc func newChange()
    {
        
    }
    // 必须实现的方法
    // 协议里面使用mutating修饰的函数，在类里面就是一个普通的函数
    func change()
    {
        name = "100"
    }
    // 可选实现的方法
    @objc func newTest()
    {
        
    }
}
let teacher :Teacher = Teacher(name: "a", gender: "b", age: 111)
teacher.test()

// @objc修饰的协议 结构体不能遵循
struct myStruct : myDelegate
{
    var name : String
    // 一般不能直接修改结构体里面的属性
    func test()
    {
        
    }
    // mutating修饰的方法里可以修改结构体的属性
    mutating func change()
    {
        name = "111"
    }
}

//MARK:----------------------Swift中的扩展-----------------------
// extension + 类名(结构体名字) 可以对一个类或结构体扩展方法
// extension不能扩展属性
// extension也可以给类或结构体扩展协议方法 这个在开发的时候最有用

extension Person : myDelegate // 给Person类扩展协议
{
    // 实现协议里的方法
    func test()
    {
        
    }
    // 实现协议里的方法
    func change()
    {
        
    }
    // 给Person类扩展方法
    func eat()
    {
        
    }
}
extension Frame : myDelegate // 给Frame结构体扩展协议
{
    // 实现协议里的方法
    func test()
    {
        
    }
    // 实现协议里的方法
    func change()
    {
        
    }
    // 给Frame结构体扩展新的方法
    func play()
    {
        
    }
}

//MARK:----------------------Swift中的闭包-----------------------
/*
   * 闭包是自包含的函数代码块，可以在代码中被传递和使用。Swift中的闭包与C和Objective-C中的代码块(block)以及其他一些编程语言中的匿名函数比较相似。
   * 闭包可以捕获和存储其所在上下文中任意常量和变量的引用。这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift会为您管理在捕获过程中涉及到的所有内存操作。
   * 语法格式：
     {
        (参数) -> 返回值类型 in
        执行语句
     }
   * 注意：闭包的函数体部分由关键字in引入。该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数即将开始。
*/

// 使用闭包求两个Int型数的最大值
// 声明一个闭包
var maxValue : ((Int, Int) -> Int)

// 实现闭包的第一种方式
maxValue = {
    (a : Int, b : Int) -> Int in
    return a > b ? a :b
}
/*
   其中：
   * maxValue的类型是(Int, Int) -> Int
   * maxValue的值就是一个闭包：
      {
         (a : Int, b : Int) -> Int in
         return a > b ? a :b
      }
*/
// 第二种方式实现闭包 省略参数类型和返回值
maxValue = {
    a, b in
    return a > b ? a : b
}
// 第三种方式实现闭包 省略参数类型，省略返回值，省略return关键字
maxValue = {
    a, b in
    a > b ? a : b
}
// 第四种方式 都省略了 使用$表示取第几个参数
maxValue = {
    $0 > $1 ? $0 : $1
}
// 第五种 苹果推荐的格式
maxValue = {
    (a, b) -> Int in
    return a > b ? a : b
}
print(maxValue(3,5))