类是否可以显式调用协议扩展上的方法？

Question

假设有以下协议，其中包含由扩展提供的 someFuncWithDefaultImplementation() 的默认实现。

那么 MyClass2 是否可以同时提供自己的 someFuncWithDefaultImplementation() 实现，该实现还从扩展中调用该方法的默认实现？

protocol MyProtocol : class {
    func someFuncWithDefaultImplementation()
    func someFunc()
    var  someInt:Int { get set }
}

extension MyProtocol {
    func someFuncWithDefaultImplementation() {
        someInt = 5
    }

    func someFunc() {
        someFuncWithDefaultImplementation()
    }
}

class MyClass :  MyProtocol {
    var someInt = 6
}

class MyClass2 : MyProtocol
{
    var someInt: Int = 4
    func someFuncWithDefaultImplementation()
    {
        // do some additional stuff
         /*** someFuncWithDefaultImplementation()  invoke MyProtocol extension implementation here ***/
    }
}


    let class1 = MyClass()
    class1.someFunc()

    let class2 = MyClass2()
    class2.someFunc()

Answer 1

线程中的following answer

• Calling protocol default implementation from regular method

描述了使用嵌套的虚拟类型从已经提供了自己的蓝图方法实现的类型中访问协议的默认实现。我们可以扩展此方法以允许实际使用MyClass2 实例的（蓝图）属性，但在对MyClass2 已经实现其自定义版本的默认实现的调用中（因此优先于默认版本） .

我们首先查看您的示例的轻量级版本，并为someFuncWithDefaultImplementation() 提供默认实现

protocol MyProtocol : class {
    func someFuncWithDefaultImplementation()
    var someInt: Int { get set }
}

extension MyProtocol {
    func someFuncWithDefaultImplementation() {
        print("Called default impl. Currently, someInt = \(someInt)")
        print("Mutates someInt from within default implementation (0) ...")
        someInt = 0
    }
}

我们在MyClass2的someFuncWithDefaultImplementation()的自定义实现中使用非优雅的嵌套类型解决方案，调用后者的默认实现，但在Dummy实例中存储一个引用回MyClass2例如，允许在默认实现调用中使用MyClass2 的someInt 属性（用于读取和写入），即使这是从Dummy 类型调用的。

class MyClass2 : MyProtocol
{
    var someInt: Int = 42

    func someFuncWithDefaultImplementation()
    {
        // do some additional stuff ...
        print("In MyClass2 implementation, currently someInt = \(someInt)")

        /* Dummy 'MyClass2'-capturing type used to call the default
            implementation of 'MyProtocol', but with read and write 
            access to 'MyClass2':s self:s 'someInt' instance. */
        class Dummy : MyProtocol {
            unowned let myClass2: MyClass2
            init(_ myClass2: MyClass2) { self.myClass2 = myClass2 }
            var someInt: Int {
                get { return myClass2.someInt }
                set { myClass2.someInt = newValue }
            }
        }

        // call default implementation of 'someFuncWithDefaultImplementation'
        // supplying 'self' to read/write access to self.someInt.
        Dummy(self).someFuncWithDefaultImplementation()

        print("Back in MyClass2:s implementation; now someInt = \(someInt)") 
           // 0, woah, mutated in default implementation!
    }
}

let a = MyClass2()
a.someFuncWithDefaultImplementation()
/* In MyClass2 implementation, currently someInt = 42
   Called default impl. Currently, someInt = 42
   Mutates someInt from within default implementation (0) ...
   Back in MyClass2:s implementation; now someInt = 0         */

您也可以选择在函数外部声明嵌套的Dummy，只需将其标记为private，以确保无法从外部MyClass2访问：

class MyClass2 : MyProtocol
{
    var someInt: Int = 42

    /* Dummy 'MyClass2'-capturing type used to call the default
       implementation of 'MyProtocol', but with read and write 
       access to 'MyClass2':s self:s 'someInt' instance. */
    private class Dummy : MyProtocol {
        unowned let myClass2: MyClass2
        init(_ myClass2: MyClass2) { self.myClass2 = myClass2 }
        var someInt: Int {
            get { return myClass2.someInt }
            set { myClass2.someInt = newValue }
        }
    }

    func someFuncWithDefaultImplementation()
    {
        // do some additional stuff ...
        print("In MyClass2 implementation, currently someInt = \(someInt)")

        // call default implementation of 'someFuncWithDefaultImplementation'
        // supplying 'self' to read/write access to self.someInt.
        Dummy(self).someFuncWithDefaultImplementation()

        print("Back in MyClass2:s implementation; now someInt = \(someInt)") 
           // 0, woah, mutated in default implementation!
    }
}

但是，我将重复链接答案的作者：这种方法不是很优雅。

Answer 2

仅当您也进行子类化时，请参见：

import Foundation

protocol MyProtocol : class {
    func someFuncWithDefaultImplementation()
    func someFunc()
    var  someInt:Int { get set }
}

extension MyProtocol {
    func someFuncWithDefaultImplementation() {
        someInt = 5
        print("a")
    }

    func someFunc() {
        someFuncWithDefaultImplementation()
    }
}

class MyClass :  MyProtocol {
    var someInt = 6
}

class BaseClass: MyProtocol {
    var someInt: Int = 4
}
class MyClass2 : BaseClass
{

    func someFuncWithDefaultImplementation()
    {
        // do some additional stuff
        print("b")
        (self as BaseClass).someFuncWithDefaultImplementation()
    }
}

如果您在 Playground 中添加上述内容，然后调用：

MyClass2().someFuncWithDefaultImplementation()

打印出来：

b
a

你要的是什么，看截图。