Swift 方法⑧

1. 方法

枚举、结构体、类都可以定义方法，方法可分为：

• 实例方法（Instance Method）：通过实例调用
• 类方法（Type Method）：通过类调用，用static 或者class关键字定义

self关键字：

• 在实例方法中代表实例
• 在类型方法中代表类型

class Car {
    static var count = 0
    var id = 1
    
    init() {
        Car.count += 1
    }
    //类型方法
    static func getCount() -> Int {
        count //等同于 self.count / Car.count  / Car.self.count
    }
    //实例方法
    func getId() -> Int {
       id// 等同于 self.id
    }
}

mutating 关键字

• 在结构体和枚举中，默认情况下，值类型的属性不能被自身的实例方法直接修改
• 如果需要修改，则需要在func前加上关键字mutating
• 注意类中的值类型不存在这种情况，可以直接修改

struct Point {
    var x = 0.0, y = 0.0
    mutating func addValue(_ addX: Double, _ addY: Double){
        x += addX
        y += addY
    }
 }
//枚举
enum StateSwitch {
    case low, middle, heigh
    mutating func change()  -> StateSwitch{
        print("111")
        switch self {
        case .low:
            self = .middle
            
        case .middle:
            self = .heigh
        case .heigh:
            self = .low
        
        }
        return self
    }
}
var sts = StateSwitch.low
print(sts.change())//输出结果为： middle

如果不加mutating，则会报错：Left side of mutating operator isn't mutable: 'self' is immutable

@discardableResult 关键字

• 在func前面加个@discardableResult ，可以消除：函数调用后返回值未被使用的警告⚠️

subscript 关键字 - 下标

• 使用subscript可以给任意类型（枚举、结构体、类）增加下标功能，有些地方也翻译为：下标脚本
• subscript的语法类似于实例方法、计算属性，其本质就是方法（函数）
• subscript中定义的返回值类型决定了，get的返回值类型以及set方法中newValue的类型
• subscript可以接受多个参数，并且是任意类型
• subscript 可以没有set方法，但是必须要有get方法
• subscript 如果只有get方法，可以省略get
• subscript可以设置参数标签,如果定义为：subscript (index i: Int) -> Double{}，则调用时为p[index:0] = 10
• subscript 下标也可以是类方法

class Point {
    var x = 0.0 , y = 0.0
    
    subscript (index: Int) -> Double{
        set{
            if index == 0 {
                x = newValue
            }else if index == 1{
                y = newValue
            }
        }
        get{
            if index == 0 {
                return x
            }else if index == 1{
                return y
            }
            return 0
        }
    }
}
var p = Point()
p[0] = 10
p[1] = 11
print(p.x , p[1])//输出结果：10，11

结构体、类作为返回值时对比：

struct Point {
      var x = 0.0 , y = 0.0
}
class PointManager {
    var point = Point()
    subscript(index: Int) -> Point{
        set{
            point = newValue
        }
        get{
            point
        }
    }
 }
var pm = PointManager()
pm[0].x = 66
pm[1].y = 77
print("pm:",pm.point.x,pm.point.y)//输出结果：pm: 66.0 77.0
注意：

1. 如果Point是Class，则可以直接省略set，也可以直接修改对应的值
2. 但如果是结构体或枚举类型，则不可以胜率，需加上point = newValue 才可以对point进行修改

• 因为结构体、枚举是值类型，值类型在进行赋值给set、var时，都是深拷贝。pm[0]相当于调用了get方法进行了深拷贝，在对其进行修改操作时，并不会真的修改point的值，所以如果想要真正的修改point的值需加上
  set{
  point = newValue
  }
• 如果是class的话。point是存储的地址指针。所以可以对其直接操作

class Sum {
   class subscript (v1: Int , v2: Int) -> Int{
        return v1 + v2
    }
}

print(Sum[10,20])//输出结果：30