Swift学习就是这么简单(二)

继续我们的Swift学习之路~

"贵在坚持"--给自己,也给你们!

今天我们来共同学习下Swift中比较复杂的一些语法,包括:结构体,类,协议,延展,枚举以及闭包表达式~

结构体

提到结构体,最先能想到的就是OC中的Frame结构体了,下面我们就用Swift定义一个Frame,代码如下~

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

定义好之后,下面我们就可以创建一个frame了~
在Swift中,创建结构体有两种方法,代码如下~

// 方法1
var frame : Frame = Frame.init(x: 10, y: 10, width: 20, height: 20)
print(frame.centerX,frame.centerY)

// 方法2
let frame1 : Frame = Frame(x: 100, y: 100, width: 100, height: 100)
print(frame1.centerX,frame.centerY)

// 结构体函数调用
// 调用结构体函数,必须得通过这个结构体调用 (类似于OC中的类方法)
Frame.sayName()

类

Swift中类的概念与OC中相似,具体不同之处,代码详解~

// 类的格式: class 类名 {类的实现}
class Person {
    // 在类里面创建一个属性的时候,必须有初值,如果不想设置初值,那么就设置为可选类型
    var name : String? = nil
    var age : Int? = nil
    
    // private 表示是私有变量
    private var gender : String? = nil
    // static修饰的属性表示类属性
    static var country : 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.country = "china"
        print(self.country)
    }
    
    // class修饰的也是类方法
    // class修饰的类方式是可以被子类重写的
    class  func sayNihao(){
        self.country = "中国"
        print(self.country)
    }
    
}

let person : Person = Person(name: "张三", age: 18)

person.sayHi()

Person.sayHello()
Person.sayNihao()


class Student: Person {
    
    // 如果子类想重写父类的方法,需要添加override修饰
    override init(name newName: String, age newAge: Int) {
        super.init(name: newName, age: newAge)
    }
    
    // 父类用class修饰的类方法,子类可以被子类重写
    override class func sayNihao(){
        
    }
    
}

协议(protocol)

Swift协议中的方法是必须实现的,没有OC中的optional关键字,所以在Swift中,如果需要可选实现的协议,需要使用OC协议,具体方法,上代码~

// 格式: protocol 协议名字
protocol myDelegate{ // Swift协议中所有方法,都必须实现
    // 协议方法前面添加mutating修饰的关键字之后,可以修改结构体里面的参数,在类里面会自动的忽略mutating
    mutating func hehe() -> String
}

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


// 如果一个类既有父类,也遵守了某个协议,那么格式是
// class 类名 : 父类, 协议名
class Teacher : Person, myDelegate, newDelegate {
    func hehe() -> String{
        return "hehehe"
    }
}

// 结构体可以遵守协议
// 但是结构体只能遵守Swift的协议
struct Book : myDelegate{
    var name : String
    
    mutating func hehe() -> String {
        
        self.name = "abc"
        return name
    }
    
}

延展(extension)

同样的,Swift也支持延展,详见代码~

// extension 可以给一个类拓展新的协议
extension Person : myDelegate{
    func hehe() -> String {
        return "hehe"
    }
    // 注意: extension不可以添加新的属性
//    var height : Float? = nil // 爆红
    
    // 可以给一个类添加新的函数
    func newFunc(){
        
    }
}

// extension可以给一个结构体拓展新的协议
extension Frame : myDelegate{
    mutating func hehe() -> String {
        return "hehe"
    }
}

enum time{
    case spring
    case summer
    case autumn
    case winter
}

枚举

// Swift定义枚举
enum time{
    case spring
    case summer
    case autumn
    case winter
}

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


// 枚举经常与Switch搭配使用,具体看下面的例子:
// switch的value要填写一个枚举类型的实例变量
// case格式: case .枚举的case名字
switch timer{
case .spring:
    print("春天")
case .summer:
    print("夏天")
case .autumn:
    print("秋天")
case .winter:
    print("冬天")
}

闭包表达式

下面介绍下闭包表达式的五种写法,Apple官方推荐的是第二种写法,一般会用这种方法,但实际应用中也因人而异,所以还是都掌握的好~

// 闭包名 : ((参数) -> 返回值类型)
var newPassValue : ((a : Int, b : Int) -> Int)

// 写法一
newPassValue = {(a : Int, b : Int) -> Int in
    return a > b ? a : b
}

// 写法二 (Apple推荐)
newPassValue = {(a, b) -> Int in
    return a > b ? a : b
}

// 写法三
newPassValue = {
    $0 > $1 ? $0 : $1
}

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

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

希望本文能在你学习Swift的道路上,对你有所帮助~

---

我会持续更新iOS教程,喜欢就关注下啦~~~~~~~^_