Swift中如何将方法标记为「需要重写」？

一、第一种方案（类抽象方法）的可行性与实现 #

Swift本身没有内置的@mustBeOverridden属性或原生抽象类支持，无法直接实现编译期强制子类重写的效果，但可以通过以下方式模拟近似的约束能力：

1. 运行时强制兜底
   在父类的目标方法中调用fatalError，确保子类如果未重写该方法，调用时会直接崩溃并明确提示原因：

   class Parent {
       func overrideThis(_ s: Source) -> Target {
           fatalError("此方法必须被子类重写")
       }
   }
   
   class Child1: Parent {
   }
   // 编译通过，但调用Child1().overrideThis(...)时会触发崩溃
   
   class Child2: Parent {
       override func overrideThis(_ s: Source) -> Target {
           // 子类自定义实现
           return Target()
       }
   }
   // 编译、运行均正常
   

   这种方式无法在编译阶段拦截错误，但能在开发测试阶段快速定位未重写的问题。

2. 配合编译警告提示
   给父类方法添加废弃警告，让开发者编写子类时收到明确提示：

   class Parent {
       @available(*, deprecated, message: "必须重写此方法，禁止直接调用父类实现")
       func overrideThis(_ s: Source) -> Target {
           fatalError("此方法必须被子类重写")
       }
   }
   

   子类继承后若未重写，调用该方法时会触发编译警告，但仍无法强制报错。

如果必须要求编译期强制子类重写，第一种方案无法满足，需要采用协议相关的实现方式。

二、第二种方案（协议+类型别名）的问题处理 #

针对「父类遵循某协议，但希望子类实现特定功能」的场景，可以通过以下两种方式优化：

1. 拆分协议明确职责 #

将协议拆分为父类负责实现的基础功能协议，以及子类必须实现的抽象功能协议：

// 父类实现的基础功能协议
protocol ParentBase {
    func baseFunction()
}

// 子类必须实现的抽象功能协议
protocol ParentAbstract {
    func overrideThis(_ s: Source) -> Target
}

// 父类仅实现基础协议
class ParentClass: ParentBase {
    func baseFunction() {
        // 父类基础逻辑实现
    }
}

// 组合两个协议作为父类类型别名
typealias Parent = ParentClass & ParentAbstract

// 子类必须实现抽象协议的方法，编译期会强制检查
class Child: Parent {
    func overrideThis(_ s: Source) -> Target {
        // 子类自定义实现
        return Target()
    }
}

这种方式清晰划分了父类与子类的职责范围，且编译期会强制子类完成抽象协议的方法实现。

2. 协议默认实现做运行时兜底 #

如果不想拆分协议，可以给需要子类实现的方法添加默认实现，并在默认实现中调用fatalError，父类不主动实现该方法：

protocol IParent {
    func baseFunction()
    func overrideThis(_ s: Source) -> Target
}

// 给抽象方法添加默认实现，作为运行时兜底
extension IParent {
    func overrideThis(_ s: Source) -> Target {
        fatalError("此方法必须被子类重写")
    }
}

class ParentClass: IParent {
    func baseFunction() {
        // 父类实现基础方法
    }
    // 不实现overrideThis，依赖协议默认实现
}

typealias Parent = ParentClass & IParent

class Child: Parent {
    // 若不重写，运行时调用会崩溃；重写则正常执行
    func overrideThis(_ s: Source) -> Target {
        return Target()
    }
}

这种方式编译期不会强制子类重写，但能在运行阶段兜底报错，适合需要灵活兼容的场景。

内容的提问来源于stack exchange，提问作者CocoaNut