本片文字主要介绍: 结构体 类 协议 扩展 闭包

结构体

//  声明结构体的格式: struct + 结构体名字 + {声明成员变量等}

struct Frame {
    // 存储属性: 仅仅做存储值的作用
    var x : Float
    var y : Float
    var width : Float
    var height : Float
    // 计算属性: 通过计算获取自己的值
    // 设置属性的get和set方法
    // 属性里面的set方法不能单独存在,必须有一个同属性的get方法存在之后才可以写set
    var centerX : Float {
        get{
            return x + width / 2
        }
        set{
            self.centerX = newValue
        }
    }
    
    var centerY : Float {
        get{
            return y + height / 2
        }
        set{
            self.centerY = newValue
        }
    }
    // 在Swift的结构体里面可以创建一个init方法  x外部参数名 newX内部参数名
    init(x newX : Float, y newY : Float, width newWidth : Float, height newHeight : Float) {
        self.x = newX
        self.y = newY
        self.width = newWidth
        self.height = newHeight
    }
    
    // Swift的结构体内可以任意创建函数
    // 如果需要在函数里面修改属性值的话,需要在函数前面添加mutating关键字修持
    mutating func haha() {
        self.x = 100
    }
    
    // 结构体属性 
    // 结构体属性是不能在普通的函数里面去调用的
    static var name : String? = nil
    // 结构体函数
    // 结构体函数里不能调用普通的属性
    // 结构体函数里可以调用结构体属性
    // 结构体函数里可以调用一些本结构体存在的函数
    static func sayName() {
        self.name = "我是一个frame"
        print(self.name)
    }
}
// 调用方法一
let frame : Frame = Frame.init(x: 10, y: 20, width: 30, height: 40)
print(frame.centerX, frame.centerY)
// 调用方法二
let frame1 : Frame = Frame(x: 100, y: 100, width: 100, height: 100)
print(frame1.centerX, frame1.centerY)

// 调用结构体函数, 必须要通过结构体去调用
Frame.sayName()

类

/ 类的格式: class(关键字) + 类名 { 类的实现 }
class Person {
    // 在类里面创建一个属性的时候,必须有初值,如果不想设置初值,那么就设置成可选类型
    var name : String? = nil
    var age : Int? = nil
    
    // private 表示的是私有属性
    private var gender : String? = nil
    
    // static 修饰的属性表示类属性
    static var county : String? = nil
    
    // 初始化方法
    init(name newName : String, age newAge : Int){
        self.name = newName
        self.age = newAge
    }
    
    // 实例方法里面不能直接调用类属性
    // 实例方法可以直接对实例对象进行修改赋值
    // 在函数声明之前添加一个private 表示私有方法
    private func sayHi() {
        self.gender = "女"
        print(self.gender)
    }
    
    // static修饰的是类方法 
    // static修饰的类方法是不可以被子类重写的
    static func sayHello() {
        self.county = "中国"
        print(self.county)
    }
    // class修饰的也是类方法
    // class修饰的类方法可以被子类重写
    class func sayNihao() {
        self.county = "china"
        print(self.county)
    }
}

// 赋值调用
let person : Person = Person.init(name: "八戒", age: 30)
//let person : Person = Person(name: "八戒", age: 30)
print(person.name,person.age)

person.sayHi()

Person.sayHello()
Person.sayNihao()

// 继承
class Student: Person {
    
    // 如果子类想重写父类的方法,需要加override修饰
    override init(name newName: String, age newAge: Int) {
        super.init(name: newName, age: newAge)
    }
    
//    self.sayHhi() // 不能调用父类私有方法
    // 重写类方法
    override class func sayNihao() {
        
    }
}

协议

// 格式 protocol(关键字) + 协议名字
// Swift协议里的方法必须实现
protocol myDelegate {
    // 协议方法前面添加mutating修持的关键字之后, 可以修改结构体里面的参数,
    mutating func hehehe()
}

// 如果有需要可选实现的协议,在最前面添加 @objc 修饰,内部的方法用optional修饰可选实现的方法,其他的不变 (OC的协议)
@objc protocol newDelegate {
    optional func lalala()
}


// 如果一个类即有父类, 也遵守了某个协议, 那么格式是: class + 类名:父类, 协议名
class Teacher : Person, myDelegate, newDelegate{
    func hehehe(){
    
    }
}
// 如果没有父类,可直接遵守协议
class newClass : myDelegate {
    func hehehe() {
        
    }
}

// 结构体可以遵守协议 但是结构体只能遵守Swift的协议
struct newStruct : myDelegate {
    var name : String
    mutating func hehehe() {
        self.name = "asd"
    }
}

扩展

// extension + 类名/结构体名 可以对一个类和结构体扩展方法
 // extension可以多次对一个类进行扩展,也可以给一个类扩展协议方法

// 给类扩展一个新方法
extension Person {
    func eat() {
        print("吃饭")
    }
    // extension不可以添加新的属性
//    var height : Float? = nil
}
// 调用
person.eat()

枚举

enum time {
    case spring
    case summer
    case autumn
    case winter
}
// 使用枚举的时候,初次给变量赋值,必须使用 枚举名.case名
var timer = time.autumn
// 第二次使用的时候 可以直接通过 .case名 使用
timer = .spring

// switch 搭配枚举使用
// switch 的value 要填一个枚举类型的实例变量
// case .枚举的case名字
switch timer {
case .spring:
    print("春天")
case .summer:
    print("夏天")
case .autumn:
    print("秋天")
case .winter:
    print("冬天")
}

闭包

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

// 第一种写法 闭包表达式的写法
newPassValue = { (a : Int, b : Int) -> Int in
    return a > b ? a : b
}

// 第二种写法 苹果推荐的写法
newPassValue = { (a , b) -> Int in
    return a > b ? a : b
}

// 第三种写法 $0:第一个参数 $1:第二个参数 以此类推
newPassValue = {
    $0 > $1 ? $0 : $1
}

// 第四种写法
newPassValue = { (a, b) in
    return a > b ? a : b
}

// 第五种写法
newPassValue = { (a, b) in
    a > b ? a : b
}

print(newPassValue(a: 3,b: 8))