Swift中函数重写的多态问题：无法调用子类特化方法

你遇到的核心问题是Swift泛型方法的静态派发机制：

• 基类的foo<S: Base>(to value: S)是泛型方法，Swift默认对泛型方法采用静态派发——编译时就绑定到基类的实现，不管运行时实例实际是哪个子类。
• 子类里的foo(to: Two)这类方法属于方法重载，并非重写基类的泛型方法，所以加override会报错，而且父类类型的实例根本找不到这些重载方法。

有两种简洁的实现方式，都能实现「子类有特化逻辑就调用，否则用基类默认实现」的需求：

方案一：重写泛型方法，内部做类型判断 #

直接在子类中重写基类的泛型foo方法，在方法内部判断参数的实际类型，触发特化逻辑，否则回退到基类实现：

class Base {
    func foo<S: Base>(to value: S) {
        print("Base class foo")
    }
}

class One: Base {
    override func foo<S: Base>(to value: S) {
        if value is Two {
            print("foo: Two")
        } else {
            super.foo(to: value)
        }
    }
}

class Two: Base {
    override func foo<S: Base>(to value: S) {
        if value is One {
            print("foo: One")
        } else {
            super.foo(to: value)
        }
    }
}

class Three: Base {
    override func foo<S: Base>(to value: S) {
        if value is One {
            print("foo: One")
        } else {
            super.foo(to: value)
        }
    }
}

测试代码运行结果：

var sample: Base = One()
sample.foo(to: Two())    // 输出"foo: Two"
sample.foo(to: Three())  // 输出"Base class foo"

方案二：拆分泛型入口与动态处理方法 #

如果特化逻辑比较复杂，可将代码拆分：基类保留泛型方法作为入口，内部调用一个可被重写的非泛型方法，子类重写该方法实现特化逻辑：

class Base {
    func foo<S: Base>(to value: S) {
        handleFoo(to: value)
    }
    
    // 可被重写的动态派发方法
    func handleFoo(to value: Base) {
        print("Base class foo")
    }
}

class One: Base {
    // 单独的特化方法，逻辑清晰
    private func handleTwo(_ value: Two) {
        print("foo: Two")
    }
    
    override func handleFoo(to value: Base) {
        if let two = value as? Two {
            handleTwo(two)
        } else {
            super.handleFoo(to: value)
        }
    }
}

class Two: Base {
    private func handleOne(_ value: One) {
        print("foo: One")
    }
    
    override func handleFoo(to value: Base) {
        if let one = value as? One {
            handleOne(one)
        } else {
            super.handleFoo(to: value)
        }
    }
}

class Three: Base {
    private func handleOne(_ value: One) {
        print("foo: One")
    }
    
    override func handleFoo(to value: Base) {
        if let one = value as? One {
            handleOne(one)
        } else {
            super.handleFoo(to: value)
        }
    }
}

这种方式的优势是特化逻辑与通用逻辑分离，代码可读性更高，后续维护更方便。

• 被override修饰的方法会采用动态派发，运行时会根据实例的实际类型调用对应的子类实现。
• 通过类型判断（is/as?），我们可以在运行时识别参数的具体类型，触发对应的特化逻辑，未匹配到则回退到基类的默认行为。

内容的提问来源于stack exchange，提问作者Martin Kopecký