在Swift 3或4中：

import Foundation

protocol P {
    static func f() -> Self
    static func g() -> Self
}

extension P {
    static func f() -> Self {
        return g()
    }
}

extension Data: P {
    static func g() -> Data {
        return self.init()
    }
}

或者，您可以使用最终子类替换您的类：

import Foundation

protocol P {
    static func f() -> Self
    static func g() -> Self
}

extension P {
    static func f() -> Self {
        return g()
    }
}

import Foundation

final class MyData: NSData {}
extension MyData: P {
    static func g() -> Self {
        return self.init()
    }
}

如果NSData是那些不能轻易子类化的类簇之一（您将看到一个带有__CFRequireConcreteImplementation的stacktrace），您可能必须为真实的的NSData创建一个最终的类 Package 器，而不是使用子类。

您需要在NSData扩展中覆盖f（）。
基本的问题是（我认为）当编译器在协议扩展中编译f时，它不知道Self是什么，并且我认为它假设它必须是它所应用的类的确切类型。对于NSData，情况可能不是这样，因为你可能有它的子类。

这对我很有效。

protocol P {
    static func foo()->Self
}

class C {
    required init() {}
}
extension C: P {
    static func foo() -> Self {
        return self.init()
    }
}

let c = C()
let c2 = C.foo()
print(c.dynamicType, c2.dynamicType) // C C

好吧，我看到你笔记了，所以我做了更新

protocol P {
    static func foo()->Self
    static func bar()->Self
}
extension P {
    static func foo() -> Self { // Method 'f()' in non-final class 'NSData' must return `Self` to conform to protocol 'P'
        return bar()
    }
}
// the class C must be final ...
final class C {
}
// otherwise the compiler can not decide the type of Self in 
extension C: P {
    static func bar() -> Self {
        return self.init()
    }
}

let c = C()
let c2 = C.foo()
print(c.dynamicType, c2.dynamicType) // C C

对于NSData，如果您想做同样的事情，麻烦的是将NSData声明为final。

从Swift 2.1开始，我可以通过只让结构体（或'final'类）符合协议来避免这个错误。目前，你可以限制协议实现为引用类型（“classes-only”），但我还没有看到对值类型的类似限制。
在这个特殊的例子中，我认为委托模式是合适的。如果合适的话，你可以把f的默认实现移到一个协议扩展中，并让子类实现覆盖一个委托属性。

protocol P {
    static var delegate : (() -> Self)?;
}

extension P {
    static func f() -> Self {
        // Use delegate if available, or use default implementation
    }
}

extension NSData : P {
    static var delegate : (() -> NSData)? = subImplementation;

    func subImplementation() -> NSData {
        // Some NSData-specific implementation
    }
}

您也可以使用相关的型别来解决这个问题。

protocol P {
    associatedtype Entity
    static func f() -> Entity
    static func g() -> Entity
}

extension P {
    static func f() -> Entity {
        return g()
    }
}

extension Data: P {
    static func g() -> Data {
        return self.init()
    }
}

您不需要在实现中指定Entity，因为编译器将从您的返回类型推断它。

我也有同样的问题，你发现了吗？
这是我提出的另一种处理特殊情况的方法。也许你可以考虑定义一个需要初始化程序的协议，而不是使用需要返回Self的静态函数的协议。
就像这样：

protocol SomeProtocol {
    init(someParameter: Int)
}

不要忘记用关键字required标记初始化器实现。

class SomeClass: SomeProtocol {
    required init(someParameter: Int) {

    }
}

希望这能有所帮助。