类继承的性能影响：十万子类场景下的方法调用疑问

Awesome question—this dives into the nitty-gritty of dynamic dispatch, which is the backbone of polymorphism in most statically typed OOP languages (think Java, C#, C++ with virtual functions). Let's unpack this one piece at a time.

Short answer: Almost never.

Here's why: The number of subclasses doesn't change how individual method calls are resolved. Even with 10,000 subclasses, each object instance only cares about its own class's method table. The runtime doesn't iterate through all subclasses to find the right method—so adding more subclasses won't slow down your doStuff() calls.

The only edge case where this might matter is if you're using a language with a JIT compiler that does aggressive type profiling, but even then, 10,000 subclasses would only cause issues if your 100 random objects cover a huge portion of those subclasses (unlikely in most cases). For standard static dispatch via virtual tables, subclass count is irrelevant.

It uses a virtual table (vtable)—a type of pointer table—not a giant switch-case. Here's the step-by-step breakdown:

• When you define an abstract class with a method like doStuff(), the compiler creates a blueprint for a vtable. Every subclass that implements doStuff() gets its own vtable, which stores pointers to its version of the method (and any other virtual/abstract methods).
• Every instance of your subclass has a hidden internal pointer called a vptr (vtable pointer) that points directly to its class's vtable.
• When you call obj.doStuff(), the runtime does two quick steps:
  1. Fetch the vptr from the obj instance.
  2. Look up the pre-determined index for doStuff() in the vtable (this index is fixed at compile time based on the abstract class's method order) and jump directly to the function pointer stored there.

This is an O(1) operation—fast, consistent, and completely independent of how many subclasses exist. A switch-case would be O(n) in the worst case (if it had to check every possible type), which is way less efficient and not how modern OOP languages handle polymorphism.

Since the base case has no meaningful performance hit, this is mostly hypothetical, but here are a few approaches if you ever needed to optimize dynamic dispatch:

• Static dispatch with explicit type checks: You could use instanceof (Java) or dynamic_cast (C++) to check the object's type at runtime, then call the subclass-specific method directly. This avoids vtable lookup, but it gets messy fast if you have many types (and defeats the purpose of polymorphism).
• Visitor Pattern: This pattern shifts the method logic into a "visitor" class, allowing you to convert dynamic dispatch into static dispatch. It's useful if you need to add new operations to many classes without modifying them, but it adds boilerplate code.
• Compile-time polymorphism: Use templates (C++) or reified generics (some languages) to lock in the concrete type at compile time. This eliminates dynamic dispatch entirely, but it only works if you know the object's type before runtime (which you don't in your random dictionary scenario).
• Cached method handles: In languages like Java, you can use MethodHandle to look up the method once and cache the handle, then reuse it for subsequent calls. This cuts down on any runtime lookup overhead (though in practice, vtable lookups are already so fast this rarely helps).

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