Swift学习_扩展和协议

Swift

1.扩展

扩展用于为已存在的类、结构体或枚举等类型添加新的功能

1.扩展计算型属性

extension Double{
    
    var km:Double{
        
        return self * 1_000
    }
    
    var m:Double{
        
        return self
    }
    
    var cm:Double{
        
        return self / 100.0
    }
    
    var mm:Double{
     
        return self / 1_000.0
    }
}

let oneKilometer = 1.km
print("一公里等于\(oneKilometer)米")

let tenmilimeter = 10.mm
print("10毫米等于\(tenmilimeter)米")

let aMarathon = 43.km + 195.m
print("马拉松的长度是\(aMarathon)米")

2.扩展构造函数

扩展构造函数是为一个类型（类、结构体、枚举）添加新的构造函数

struct Size{
    
    var width = 0.0, height = 0.0
}

struct Point {
    
    var x = 0.0, y = 0.0
}

struct Rect {
    
    var origin = Point()
    var size = Size()
}

let defaultRect = Rect()
let memberwiseRect = Rect(origin:Point(x:2.0,y:2.0),size:Size(width:5.0,height:5.0))


extension Rect{
    
    init(center:Point,size:Size) {
        let originX = center.x - size.width/2
        let originY = center.y - size.height/2
        self.init(origin:Point(x: originX, y: originY),size:size)
    }
}

let centerRect = Rect(center: Point(x: 4.0, y: 4.0), size: Size(width: 3.0, height: 3.0))

print("默认构造函数实例\(defaultRect)")
print("成员构造函数实例\(memberwiseRect)")
print("扩展构造函数实例\(centerRect)")

3.扩展方法

extension Int{
    
    static var num:Int = 4
    func legInt() -> Int {
        
        return self * Int.num
    }
    
    // 定义一个可变方法
    mutating func legInt1(){
        
        self = self * Int.num
    }
}

let cat = 6.legInt()
print("6只猫有\(cat)条腿")

var cat1 = 6
cat1.legInt1()
print("6只猫有\(cat1)条腿")

使用 mutating 关键字修饰方法是为了能在该方法中修改 struct 或是 enum 的变量，在设计接口的时候，也要考虑到使用者程序的扩展性。所以要多考虑使用mutating来修饰方法。

4.扩展下标

extension Int{
    
    subscript(i:Int) -> Int{
        
        var base = 1
        
        for _ in 0..

subscript（自定义下标）：在swift中，subscript可以帮助我们更方便的访问或者设置一个集合中的某个成员。

2.协议

swift中的协议用于定义方法和属性，但协议本身并不进行实现，而是由采纳该协议的类具体实现，与Objective-C不用的是，协议还可以被结构体和枚举采纳。

定义协议

protocol 协议名称{
    
    // 协议内容
}
protocol 协议名称2{
}

protocol 协议名称1:class {
    
    // 协议内容
}

采纳协议

struct 结构体名称:协议名称 {
    
    // 结构体内容
}

采纳多个协议

struct 结构体名称1:协议名称,协议名称2
{
    //结构体名称
}

class 子类名称: 父类名称,协议名称 {
    
}

协议对方法的要求

protocol Animal{
    
    // 在协议中声明实例方法
    func shout()
    // 在协议中声明类方法
    static func eat()
}

class Dog: Animal {
    
    func shout() {
        
        print("汪汪汪")
    }
    
    static func eat() {
        
        print("吃骨头")
    }
}

在协议中声明可变方法

protocol Button{
    
    mutating func toggle()
}

enum OnOffSwitch:Button {
    
    case Off,On     // 定义两个枚举值
    
    mutating func toggle() {
        
        if self == OnOffSwitch.On{
            
            self = .Off
            print("off")
        }else{
            
            self = .On
            print("on")
        }
    }
}

var lightSwitch = OnOffSwitch.Off //关
lightSwitch.toggle() //开
lightSwitch.toggle() //关
lightSwitch.toggle() //开

协议对构造函数的要求

protocol MakeFood{
    
    init()
}

class Personx {
    
    init(){
        
        print("人会做饭")
    }
}

class Cook: Personx,MakeFood {
    
    required override init() {
        
        print("厨师做的饭更好吃")
    }
}

可选协议

可选协议表示定义协议的属性和方法可以实现也可以不实现

@objc protocol Animals{
    
    @objc optional func wing()
}

class Bird: Animals {
    
    @objc func wing() {
        
        print("鸟的翅膀")
    }
}

// 这个实现方法不写也不会报错，例如下面例子
class Tiger:Animals{
    
}

let bird = Bird()
bird.wing()

协议作为类型使用

1. 作为函数、方法或构造函数中的参数类型或返回值类型

2. 作为常量、变量或属性的类型

3. 作为数组、字典或其他容器中的元素类型

protocol Name{
    
    var name:String{get}
}

struct Student:Name {
    
    var name:String
}

func contact(student:Name){
    print("要联系的学生的名字是\(student.name)")
}

let student = Student(name:"小米")
contact(student: student)
print(student.name)

---

扩展和协议结果输出

---

代码已上传至git：

--> 传送门：Swift_基本语法

附录

查看完整专栏《Swift学习》

有问题欢迎指正以及相互探讨 —— CoderSun