IB Computer Science Topic B3.2.2: Constructing Code to Model Polymorphism and Its Various Forms, Such as Method Overriding Notes

Polymorphism: One Method Name, Many Behaviours

1. The same method name runs different code depending on the object it is called on or the arguments it is given.
2. Calling code can hold a parent type and stay unchanged as new subclasses are added, which is where the flexibility and reusability come from.
3. Inheritance is the mechanism that makes it possible, and polymorphism is the behaviour you get out of it.

Two Forms: Decided Early or Decided Late

1. Compile-time (static) polymorphism
   1. The compiler picks the version from the arguments written in the call, before the program ever runs.
   2. You get it from method overloading and operator overloading.
2. Runtime (dynamic) polymorphism
   1. The version is chosen while the program runs, from the actual object sitting in the variable.
   2. You get it from method overriding in subclasses.

Method Overloading: Same Name, Different Parameter List

1. Two or more methods share a name but differ in the number or type of their parameters.
2. A different return type alone is not enough in Java, because the compiler matches on the signature, which is the name plus the parameter list.
3. This makes it efficient: the target is fixed at compile time, so there is no lookup cost when the call runs.
4. Python has no true overloading: a second def with the same name replaces the first, so default parameters or *args and **kwargs stand in for it.

Method Overriding: Same Signature, New Body

1. A subclass declares a method with the same name and the same parameter list as one in its parent, and replaces the body.
2. Change the parameter list and Java treats it as a new overloaded method, so the parent version keeps running and nothing looks broken.
3. Writing @Override in Java is optional, and it makes the compiler check the signature for you.
4. super inside the override runs the parent version first, so the child can extend the behaviour rather than throw it away.

Dynamic Dispatch: The Object Chooses, Not the Variable

1. A variable declared as the parent type can hold any subclass object, so an Animal variable can hold a Dog.
2. When you call sound() on that variable, the version that runs comes from the object stored in it, not from the declared type.
3. This is what lets one loop over a parent-typed collection drive every subclass, and it is the point of runtime polymorphism.
4. Add a Rabbit subclass later and the loop still works, because it never names a subclass.

What Polymorphism Buys, and What It Costs

1. Reusability: one block of calling code drives every subclass, so the loop above is written once.
2. Extensibility: a new subclass slots in without a single edit to the code that calls it.
3. Flexibility: the caller works against one shared interface and never has to test which subclass it is holding.
4. Cost, speed: dynamic polymorphism looks the method up while the program runs, which is slightly slower than a call fixed at compile time.
5. Cost, debugging: in a deep hierarchy, working out which version actually ran takes tracing rather than reading.
6. Cost, clarity: a method overloaded six ways leaves the reader guessing which one a given call resolves to.

Answering Polymorphism Questions

1. Name the form you mean, static or dynamic, and say what decides the call and when.
2. Back an explanation with a two-class example, because a described mechanism scores where a definition alone does not.
3. Give at least one limitation when the command term is Evaluate or Discuss, since those marks need both sides.