调用 Swift 协议扩展方法而不是子类中实现的方法

Question

我遇到了以下代码（Swift 3.1）中解释的问题：

protocol MyProtocol {
    func methodA()
    func methodB()
}

extension MyProtocol {
    func methodA() {
        print("Default methodA")
    }

    func methodB() {
        methodA()
    }
}

// Test 1
class BaseClass: MyProtocol {

}

class SubClass: BaseClass {
    func methodA() {
        print("SubClass methodA")
    }
}


let object1 = SubClass()
object1.methodB()
//

// Test 2
class JustClass: MyProtocol {
    func methodA() {
        print("JustClass methodA")
    }
}

let object2 = JustClass()
object2.methodB()
//
// Output
// Default methodA
// JustClass methodA

所以我希望 "SubClass methodA" 文本应该在object1.methodB() 调用之后打印。但是由于某种原因，调用了来自协议扩展的methodA() 的默认实现。但是object2.methodB()call 可以正常工作。

这是协议方法调度中的另一个 Swift 错误，还是我遗漏了一些东西并且代码可以正常工作？

Answer 1

一位朋友与我分享的一个非常简短的答案是：

只有声明一致性的类才能获得协议见证表

意味着具有该功能的子类对协议见证表的设置方式没有影响。

协议见证只是协议、它的扩展以及实现它的具体类之间的契约。

Answer 2

这就是协议当前调度方法的方式。

协议见证表（请参阅this WWDC talk 了解更多信息）用于在协议类型实例上调用时动态调度协议要求的实现。它实际上只是一个函数实现的列表，以调用给定的符合类型的协议的每个要求。

每种声明其符合协议的类型都有自己的协议见证表。你会注意到我说的是“声明它的一致性”，而不仅仅是“符合”。 BaseClass 获得自己的协议见证表以符合 MyProtocol。然而SubClass 确实没有获得自己的表以符合MyProtocol - 相反，它只是依赖BaseClass 的。如果您将
: MyProtocol 移至SubClass 的定义，它将拥有自己的 PWT。

所以我们在这里只需要考虑BaseClass 的 PWT 是什么样子的。好吧，它没有提供协议要求methodA() 或methodB() 的实现——因此它依赖于协议扩展中的实现。这意味着符合MyProtocol 的BaseClass 的PWT 只包含到扩展方法的映射。

因此，当扩展 methodB() 方法被调用并调用 methodA() 时，它会通过 PWT 动态调度该调用（因为它是在协议类型的实例上调用的；即 self） .因此，当 SubClass 实例发生这种情况时，我们将通过 BaseClass 的 PWT。所以我们最终调用了methodA() 的扩展实现，而不管SubClass 提供了它的实现。

现在让我们考虑JustClass 的 PWT。它提供了methodA() 的实现，因此其PWT 与MyProtocol 的一致性具有那个 实现作为methodA() 的映射，以及methodB() 的扩展实现。因此，当 methodA() 通过其 PWT 动态分派时，我们最终会进入 其 实现。

正如我所说的in this Q&A，这种子类没有为它们的超类所遵循的协议获取自己的 PWT 的行为确实有点令人惊讶，并且一直是filed as a bug。正如 Swift 团队成员 Jordan Rose 在错误报告的 cmets 中所说，其背后的原因是

[...] 子类不会提供新成员来满足一致性。这很重要，因为可以将协议添加到一个模块中的基类和另一个模块中创建的子类中。

因此，如果这是这种行为，那么已经编译的子类将缺少任何来自超类一致性的 PWT，这些 PWT 是事后添加到另一个模块中的，这将是有问题的。

---

正如其他人已经说过的，在这种情况下，一种解决方案是让BaseClass 提供自己的methodA() 实现。此方法现在将位于 BaseClass 的 PWT 中，而不是扩展方法中。

当然，因为我们在这里处理类，所以它不仅仅是BaseClass 对所列方法的实现——而是thunk然后通过类的 vtable（类实现多态性的机制）动态调度。因此，对于SubClass 实例，我们最终将调用它对methodA() 的覆盖。

Answer 3

在您的代码中，

let object1 = SubClass()
object1.methodB()

您从SubClass 的实例调用了方法B，但SubClass 没有任何名为methodB 的方法。但是它的超类BaseClass 符合MyProtocol，它有一个methodB 方法B。

因此，它将从MyProtocal 调用methodB。因此它将执行extesion MyProtocol中的methodA。

要达到您的期望，您需要在BaseClass 中实现methodA 并在SubClass 中覆盖它，如以下代码

class BaseClass: MyProtocol {
    func methodA() {
        print("BaseClass methodA")
    }
}

class SubClass: BaseClass {
    override func methodA() {
        print("SubClass methodA")
    }
}

现在，输出将变为

//Output
//SubClass methodA
//JustClass methodA

虽然该方法可以达到您的期望，但我不确定这种代码结构是否值得推荐。

Answer 4

好吧，我认为子类方法 A 不是多态的，因为您不能在其上放置 override 关键字，因为该类不知道该方法是在协议的扩展中实现的，因此不允许您覆盖它。扩展方法可能会在运行时踩到您的实现，就像 2 个确切的类别方法在目标 C 中以未定义的行为相互胜过对方。您可以通过在模型中添加另一层并在类中实现方法而不是在类中实现方法来修复此行为协议扩展，从而从中获得多态行为。缺点是你不能在这一层留下未实现的方法，因为没有对抽象类的原生支持（这实际上是你试图用协议扩展做的事情）

protocol MyProtocol {
    func methodA()
    func methodB()
}

class MyProtocolClass: MyProtocol {
    func methodA() {
        print("Default methodA")
    }

    func methodB() {
        methodA()
    }
}

// Test 1
class BaseClass: MyProtocolClass {

}

class SubClass: BaseClass {
    override func methodA() {
        print("SubClass methodA")
    }
}


let object1 = SubClass()
object1.methodB()
//

// Test 2
class JustClass: MyProtocolClass {
    override func methodA() {
        print("JustClass methodA")
    }
}

let object2 = JustClass()
object2.methodB()
//
// Output
// SubClass methodA
// JustClass methodA

这里也有相关答案：Swift Protocol Extensions overriding