Python中如何实现子类重写父类指定方法时自动抛出错误

以下是不同常用编程语言的具体实现方式：

Python 实现 #

Python 3.8+ 可以用final装饰器配合类型检查工具（如mypy）在编码阶段拦截重写操作，需要运行时也拦截的话可以自定义元类实现：

• 静态检查（编码阶段提示）示例：

from typing import final

class BaseClass:
    @final
    def cannot_override_me(self):
        print("这是禁止重写的基类方法")

class SubClass(BaseClass):
    # 此处mypy会直接抛出重写错误提示
    def cannot_override_me(self):
        pass

• 运行时拦截示例：

class FinalMethodMeta(type):
    def __new__(cls, name, bases, attrs):
        final_methods = set()
        for base in bases:
            final_methods.update(getattr(base, '_final_methods', set()))
        for method_name in final_methods:
            if method_name in attrs:
                raise TypeError(f"方法 {method_name} 禁止重写")
        current_final = {k for k, v in attrs.items() if getattr(v, '_is_final', False)}
        attrs['_final_methods'] = final_methods.union(current_final)
        return super().__new__(cls, name, bases, attrs)

def final_method(func):
    func._is_final = True
    return func

# 使用示例
class BaseClass(metaclass=FinalMethodMeta):
    @final_method
    def cannot_override_me(self):
        print("禁止重写")

# 定义子类时会直接抛出TypeError
class SubClass(BaseClass):
    def cannot_override_me(self):
        pass

Java 实现 #

直接在需要禁止重写的方法上添加final修饰符，编译阶段就会校验重写逻辑：

public class BaseClass {
    public final void cannotOverrideMe() {
        System.out.println("禁止重写的方法");
    }
}

public class SubClass extends BaseClass {
    // 编译直接报错：cannot override method which is final
    public void cannotOverrideMe() {
    }
}

C# 实现 #

基类原生方法默认非virtual就无法被重写，如果是虚方法需要禁止后续子类重写，添加sealed关键字即可：

public class BaseClass {
    // 非virtual方法默认无法被重写
    public void CannotOverrideMe() {
        Console.WriteLine("禁止重写的方法");
    }

    public virtual void CanOverrideOnce() {
        Console.WriteLine("子类可以重写一次，再往下的子类不能重写");
    }
}

public class SubClass : BaseClass {
    // 此处重写CannotOverrideMe会直接编译报错
    public void CannotOverrideMe() {
    }

    public sealed override void CanOverrideOnce() {
        base.CanOverrideOnce();
    }
}

public class SubSubClass : SubClass {
    // 此处重写CanOverrideOnce会编译报错，已被sealed修饰
}

C++ 实现 #

在方法后添加final关键字即可，编译阶段会做重写校验：

class BaseClass {
public:
    virtual void cannot_override_me() final {
        std::cout << "禁止重写的方法" << std::endl;
    }
};

class SubClass : public BaseClass {
    // 编译报错：cannot override 'final' function
    void cannot_override_me() override {
    }
};

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