Swift ~ 方法、下标、继承

本文源自本人的学习记录整理与理解，其中参考阅读了部分优秀的博客和书籍，尽量以通俗简单的语句转述。引用到的地方如有遗漏或未能一一列举原文出处还望见谅与指出，另文章内容如有不妥之处还望指教，万分感谢。

方法

• 枚举、结构体、类都可以定义实例方法、类方法
• 实例方法：通过实例对象调用
• 类方法：通过类型调用，用static或者class关键字定义
• self: 在实例方法中代表实例对象，在类型方法中代表类型

class Person {
static var cout = 0
init() {
Person.cout += 1
}
//这里的cout 等价于self.cout、Person.self.cout、Person.cout
static func getCount() -> Int {
cout
}

}

mutating

• 结构体和枚举是值类型，默认情况下值类型属性不能被自身的实例方法修改
• 可以考虑在func关键字前加mutating可以允许这种修改行

struct Person {
 var x = 0.0, y = 0.0

mutating func run(deltX:Double, deltY:Double) {
   x += deltX
   y += deltY
}

@discardableResult

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

struct Point {
var x = 0.0, y = 0.0
@discardableResult mutating func moveX(deltaX: Double) -> Double {
      x += deltaX
      return x
   }
} 

var p = Point()
p. moveX(deltaX:10)

下标

• 使用subscript可以给任意类型(枚举、结构体、类)增加下标功能，有些地方也翻译为：下标脚本 ；subscript 的语法类似于实例方法、计算属性，本质就是方法(函数)
• subscript中定义的返回值类型决定了：

1. get方法的返回值类型
2. set方法中newValue的类型
3. subscript可以接受多个参数，并且类型任意
4. subscript可以没有set方法，但必须要有get方法；如果只有get方法时可以省略get

class Point {
var x = 0.0, y = 0.0
//index：标签
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
        }
      }     
   }
} 

var p = Point()

p[0] = 11.3
p[1] = 22.2

print(p.x)//11.3
print(p.y)//22.2
print(p[0])//11.3
print(p[1])//22.2

注意点：如果下标的返回值是枚举，就不能拿到返回的枚举直接修改其成员，需要再subscript内部实现set方法；如果下标返回值是类，就不需要如此

• 接收多个参数的下标

实例.png

继承

• 值类型(枚举、结构体)不支持集成，只有类支持继承

• 没有父类的类称之为：基类，就是说随便自定义一个类，只要没继承其他类，那这个类就是基类

• Swift并没有像OC、Java那样的规定：任何类最终都要继承自某个基类

• 子类可以重写父类的下标、方法、属性，重写必须加上override关键字

• 属性继承的内存示例

示例.png

• 重写实例方法、下标必须加override

示例.png

• 重写类型方法、下标

1. 被class 修饰的类型方法、下标，允许被子类重写
2. 被static修饰的类型方法、下标，不允许被子类重写
3. 如果父类定义方法时使用class修饰，子类重写时可以使用class也可以使用static来修饰

class示例.png

static示例.png

• 重写实例属性

1. 子类可以将父类的属性(存储、计算)，重写为计算属性
2. 相反子类不可以将父类的属性(存储、计算)，重写为存储属性
3. 只能重写var属性，不能重写let属性
4. 重写时属性名、类型要一致
5. 子类重写后的属性权限不能小于父类的权限
   5.1> 如果父类属性是只读的，那么子类重写后的属性可以是只读的、也可以是可读可写的
   5.2> 如果父类属性是可读可写的，那么子类重写后的属性也必须是可读可写的

基类Circle.png

重写属性.png

• 重写类型属性

1. 被class修饰的计算类型属性，可以被子类重写
2. 被static 修饰的类型属性(存储、计算)，不可以被子类重写

示例.png

• 属性观察器

1. 可以在子类中为父类属性(除了只读计算属性、let属性)增加属性观察器：willSet、didSet

class Circle {
   //存储属性
   var redius: Int = 1
}

class SubCircle: Circle {

   override var redius: Int {

     willSet {
         print("SubCircle willSetRedius",newValue)
     }
    didSet {
        print("SubCircle didSet Redius",newValue)
     }

   }

}

var circle = SubCircle()
circle.radius = 10

示例2.png

-final

1. 被final修饰的方法、下标、属性，禁止被重写
2. 被final修饰的类，禁止被继承

多态的实现原理

• OC : 通过Runtime的API来实现
• C++ : 虚表(虚函数表)
• Swift : 类似于C++的实现方式，也是通过一张表