Ios 面向Swift协议的扩展

试图了解Swift中面向协议的编程以及扩展如何工作以及它可以提供什么级别的可扩展性

我在操场上运行了以下代码片段

protocol ProtocolA {
    func doSomethingA()
}

protocol ProtocolB {
    func doSomethingB()
}

protocol ProtocolC {
    func doSomethingC()
}

extension ProtocolA {
    func doSomethingA() {
        print("Extension - doSomethingA")
    }
}

extension ProtocolA where Self: ProtocolB {
    func doSomethingA() {
        print("Extension - doSomethingA Self: ProtocolB")
    }
}

extension ProtocolA where Self: ProtocolC {
    func doSomethingA() {
        print("Extension - doSomethingA Self: ProtocolC")
    }
}

extension ProtocolA where Self: ProtocolB, Self: ProtocolC {
    func doSomethingA() {
        print("Extension - doSomethingA Self: ProtocolB, ProtocolC")
    }
}

extension ProtocolB {
    func doSomethingB() {
        print("Extension - doSomethingB")
    }
}

extension ProtocolC {
    func doSomethingC() {
        print("Extension - doSomethingC")
    }
}

class Implementation: ProtocolA, ProtocolB, ProtocolC {
}

let obj = Implementation()

obj.doSomethingA()

我得到的是：

Extension - doSomethingA Self: ProtocolB, ProtocolC

无论如何，我可以保证所有的扩展都能运行

理想情况下，我希望得到以下输出

Extension - doSomethingA
Extension - doSomethingA Self: ProtocolB
Extension - doSomethingA Self: ProtocolC
Extension - doSomethingA Self: ProtocolB, ProtocolC

我知道Swift会根据其类型选择最强的匹配，事实上，如果我不提供ProtocolA同时匹配ProtocolB和ProtocolC的实现，我会得到编译时错误。还有什么我可以绕过去的吗

---

谢谢。

扩展的要点是为协议方法提供默认实现

在您的示例中，编译器将决定调用最适合您的具体对象的扩展的

doSomethingA（）

方法，但仅此而已

正如您在通话中所看到的：

obj.doSomethingA（）

您正在执行一个方法调用。这将被解析并分派给一个方法调用，而不是四个

这类似于通过子类化重写方法并调用基类的方法时，只调用派生方法，而不调用基类方法。在这种情况下，如果需要，可以从子类调用

super.method（）

在您的情况下，如果希望调用多个方法，可以通过扩展为它们指定单独的名称和实现，然后创建一个实现所有协议的类，如下所示：

class A: ProtocolA, ProtocolB, ProtocolC {

   func all() {
      doSomethingA()
      doSomethingB()
      doSomethingC()
   }
}

---

这里扩展的优点是，您的

类A

不必为这三种方法提供实现。

扩展的要点是为协议方法提供默认实现

在您的示例中，编译器将决定调用最适合您的具体对象的扩展的

doSomethingA（）

方法，但仅此而已

正如您在通话中所看到的：

obj.doSomethingA（）

您正在执行一个方法调用。这将被解析并分派给一个方法调用，而不是四个

这类似于通过子类化重写方法并调用基类的方法时，只调用派生方法，而不调用基类方法。在这种情况下，如果需要，可以从子类调用

super.method（）

在您的情况下，如果希望调用多个方法，可以通过扩展为它们指定单独的名称和实现，然后创建一个实现所有协议的类，如下所示：

class A: ProtocolA, ProtocolB, ProtocolC {

   func all() {
      doSomethingA()
      doSomethingB()
      doSomethingC()
   }
}

---

这里扩展的优点是，你的

类A

不必为这三种方法提供实现。

你想让它实现这三种方法吗？@JoeBlow没错。你是说。当您在代码中键入以下内容时：

obj.doSomethingA（）

实际上您希望它运行四个不同的例程。所以，有点像你四次，三次，在一个继承链中叫“超级…”？？@JoeBow，没错，这就是我想要的东西。问题是我想提供基于协议类型的默认实现，而不是实现一个大规模的超级实现，它需要满足每一个只有少数几个子类可以使用的小情况。现在，我明白这可能是不可避免的。你想让它做这三个吗？？？@JoeBlow是的。你的意思是。当您在代码中键入以下内容时：

obj.doSomethingA（）

实际上您希望它运行四个不同的例程。所以，有点像你四次，三次，在一个继承链中叫“超级…”？？@JoeBow，没错，这就是我想要的东西。问题是我想提供基于协议类型的默认实现，而不是实现一个大规模的超级实现，这个超级实现需要满足只有少数几个子类可以使用的每一个小情况。现在，我明白这可能是不可避免的。这很公平。谢谢，很公平。谢谢