swift中重写泛型函数错误

代码如下：

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")
    } 
}

类测试{
func-foo（标准杆：S）{
打印（“foo”）
}
}
类TestInh:Test{
重写func-foo（par:S）{
打印（“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) {
    ~~~~~~~~      ^

repl.swift:8:19:错误：方法不重写其超类中的任何方法
覆盖func-foo（部分：S）{
~~~~~~~~      ^

如何在super class

Test

中重写该方法

============================其他=======================

当涉及到代码爆炸时

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

类测试{
func-foo（标准杆：T）{
打印（“foo”）
}
}
类TestInh:Test{
重写func-foo（par:Int）{
打印（“loo”）
} 
}

---

一切正常。不知道在

语句出现的位置发生了什么。
收到错误的原因是
函数和
重写函数的方法签名不同：

func-foo（标准杆）

不同于：

override func-foo（部分）

在这种情况下，如果继承对您很重要，那么您需要使子类成为泛型实体，泛型类型声明为
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）{
打印（“foo”）
}
}
类测试：测试{
覆盖func-foo（部分：S）{
打印（“loo”）
}
}

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

func-foo（标准杆）

同：

重写func-foo（par:S）
从泛型类继承非泛型类时，应：


对非泛型方法使用
override
；但是
使用no
覆盖
，覆盖通用代码

在这两种情况下，您仍然可以调用所述方法的
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))")
    }
}

类基{
func testGeneric（序列：S）{
打印（“基本\（\uuu函数\）（序列：\（序列.动态类型）））
}
func testNongeneric（元素：T）{
打印（“基本\（\uuuu函数\）（元素：\（元素.动态类型）））
}
}
类子类：Base{
func testGeneric（序列：S）{
super.testGeneric（序列）
打印（“子类\（\uuu函数\）（序列：\（序列.动态类型）））
}
重写func testNongeneric（元素：Int）{
super.testNongeneric（元素）
打印（“子类\（\uuuu函数\）（元素：\（元素.动态类型）））
}
}

测试：

let base=base（）
设subclass=subclass（）
base.testGeneric（[]）//打印：base-testGeneric（序列：数组）
testGeneric（[]）//Prints:Base testGeneric（序列：数组）
//子类testGeneric（序列：数组）
base.testNongeneric（0）//打印：base-testNongeneric（元素：Double）
subclass.testNongeneric（0）//Prints:Base testNongeneric（元素：Int）
//子类testNongeneric（元素：Int）
为什么这两个函数不同？我已将
T
指定为
Int
。此外，如果
T
与
Int
不同，无论我是否指定，为什么第二段代码可以正常工作？您已将
T
指定为
Int
类型，但这不会改变方法符号的事实自然数本身不同。
其中S.Generator.Element==T
！=
其中S.Generator.Element==Int
。以便编译器“查看”签名的覆盖必须是相同的。你能解释我最后一条评论中的第二个问题吗？我听说两个函数签名是不同的。但是下面的代码是编译的！！！这真的让我很困惑。即使指定了T，它们的签名也应该被认为是不同的！最后的语句为我澄清了这一点。为什么swift编译器没有检测到泛型方法正在重写其超类的方法？为什么override关键字在这里不起作用？
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)