快速覆盖通用函数错误

Question

代码如下：

class Test<T> { 
    func foo<S:SequenceType where S.Generator.Element == T>(par : S){
        print("foo")
    }
}
class TestInh : Test<Int> { 
    override func foo<S:SequenceType where S.Generator.Element == Int>(par : S) { 
        print("loo")
    } 
}

它会大喊这样的错误：

repl.swift:8:19: error: method does not override any method from its superclass
    override func foo<S:SequenceType where S.Generator.Element == Int>(par : S) {
    ~~~~~~~~      ^

如何覆盖超类Test<Int> 中的方法？

===================补充========================

当涉及到代码攻击时。

class Test<T> { 
    func foo(par : T){
        print("foo")
    }
}
class TestInh : Test<Int> { 
    override func foo(par : Int) { 
        print("loo")
    } 
}

一切正常。不知道where 语句出现时发生了什么。

Answer 1

从泛型类继承非泛型类时，您应该：

• 将override 与非-泛型方法一起使用；但是
• 使用 no override 和通用的。

在这两种情况下，您仍然可以调用上述方法的super 实现。

因此，这应该有效：

class Base<T> {
    func testGeneric<S: SequenceType where S.Generator.Element == T>(sequence: S) {
        print("Base \(__FUNCTION__)(sequence: \(sequence.dynamicType))")
    }

    func testNongeneric(element: T) {
        print("Base \(__FUNCTION__)(element: \(element.dynamicType))")
    }
}

class Subclass: Base<Int> {
    func testGeneric<S: SequenceType where S.Generator.Element == Int>(sequence: S) {
        super.testGeneric(sequence)
        print("Subclass \(__FUNCTION__)(sequence: \(sequence.dynamicType))")
    }

    override func testNongeneric(element: Int) {
        super.testNongeneric(element)
        print("Subclass \(__FUNCTION__)(element: \(element.dynamicType))")
    }
}

测试：

let base = Base<Double>()
let subclass = Subclass()

base.testGeneric([])        // Prints: Base testGeneric(sequence: Array<Double>)
subclass.testGeneric([])    // Prints: Base testGeneric(sequence: Array<Int>)
                            //         Subclass testGeneric(sequence: Array<Int>)

base.testNongeneric(0)      // Prints: Base testNongeneric(element: Double)
subclass.testNongeneric(0)  // Prints: Base testNongeneric(element: Int)
                            //         Subclass testNongeneric(element: Int)

Answer 2

您收到错误的原因是func 和override func 的方法签名不同：

func foo<S:SequenceType where S.Generator.Element == T>(par : S)

不等于：

override func foo<S:SequenceType where S.Generator.Element == Int>(par : S)

如果在这种情况下继承对您很重要，那么您需要将您的子类设置为具有泛型类型声明T 的泛型实体，并修改您的override func：

class Test<T> {

  func foo<S:SequenceType where S.Generator.Element == T>(par : S) {
    print("foo")
  }
}

class TestInh<T> : Test<T> {

  override func foo<S:SequenceType where S.Generator.Element == T>(par : S) {
    print("loo")
  }
}

这应该可以解决您手头的问题。这解决的原因是方法签名现在是相同的：

func foo<S:SequenceType where S.Generator.Element == T>(par : S)

等同于：

override func foo<S:SequenceType where S.Generator.Element == T>(par : S)