Swift：如何实现需子类重写但不可外部调用的函数

我需要创建一个必须被子类重写，但外部代码无法直接调用的方法，现有示例代码如下：

open class Animal {
  func favFood() throws -> String {
    throw UnImplementedError()
  }

  func eatFood() throws {
    print("Yum, I love \(try favFood())")
  }
}

class Cat: Animal {
  override func favFood() throws -> String {
    return "fish"
  }
}

let cat = Cat()
try cat.eatFood()  // 希望此方法可正常调用
try cat.favFood()  // 希望禁止外部调用此方法

已知fileprivate的解决方案不适用于我的场景——我无法将所有子类放在同一文件中，同时需要允许任意模块继承并重写Animal类，且强制子类必须实现favFood()方法。我曾考虑过在初始化器中强制子类传入方法实现的闭包，但这种方式在方法数量增多时会变得混乱，且无法处理依赖实例状态的方法。

可行解决方案 #

方案1：用@available标记禁止外部调用

将目标方法标记为open以允许跨模块子类重写，同时通过@available注解禁止外部直接调用，子类仍可正常重写该方法：

// 自定义未实现错误
struct UnimplementedError: Error, CustomStringConvertible {
    var description: String {
        return "方法未被子类重写"
    }
}

open class Animal {
    // open修饰允许跨模块子类重写，@available禁止外部调用
    @available(*, unavailable, message: "此方法仅允许子类重写，禁止外部直接调用")
    open func favFood() throws -> String {
        throw UnimplementedError()
    }

    // 外部可正常调用的公共方法
    open func eatFood() throws {
        print("Yum, I love \(try favFood())")
    }
}

// 跨模块子类示例
open class Cat: Animal {
    // 子类可正常重写目标方法
    override open func favFood() throws -> String {
        return "fish"
    }
}

// 使用示例
let cat = Cat()
try cat.eatFood() // 输出：Yum, I love fish
try cat.favFood() // 编译报错：'favFood()' is unavailable: 此方法仅允许子类重写，禁止外部直接调用

优势：

• 编译器层面阻止外部调用目标方法，直接报错
• 支持任意模块的子类重写该方法
• 子类未重写时，调用eatFood()会抛出运行时错误，间接强制子类实现

方案2：闭包注入（适合少量方法场景）

如果需要重写的方法数量较少，可以通过父类初始化器强制子类注入方法实现，避免子类重写方法：

struct UnimplementedError: Error, CustomStringConvertible {
    var description: String {
        return "未注入方法实现"
    }
}

open class Animal {
    private let _favFood: () throws -> String

    // 初始化器强制子类传入favFood的实现
    public init(favFood: @escaping () throws -> String) {
        self._favFood = favFood
    }

    open func eatFood() throws {
        print("Yum, I love \(try _favFood())")
    }
}

// 子类实现
open class Cat: Animal {
    public init() {
        super.init(favFood: {
            return "fish"
        })
    }
}

// 使用示例
let cat = Cat()
try cat.eatFood() // 输出：Yum, I love fish
// 外部无法访问私有属性_favFood，自然无法调用对应逻辑

劣势：方法数量增多时，初始化器参数会臃肿，且无法处理依赖实例运行时状态的方法。

总结 #

优先选择方案1，它完美匹配跨模块子类重写、外部禁止调用的需求，同时通过运行时错误间接强制子类实现目标方法。Swift目前没有原生支持“必须重写且外部不可见”的方法，@available是最贴合需求的实现方式。

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