Polymorphism — Week #4 Comprehensive Study Notes Summary & Study Notes

✍️ Source: User Instructions

Purpose: Summarize the Week #4 lecture slides on Polymorphism in Java, capturing all key concepts without oversimplifying or overcomplicating.

Scope & Approach: Produce comprehensive study notes that preserve definitions, examples, rules, advantages, and distinctions (e.g., binding, inheritance vs polymorphism). Emphasize practical implications (extensibility, code reuse, interfaces, and how the JVM resolves calls). Keep explanations concise with clear headings and bold terms for emphasis.

🧩 Introduction to Polymorphism

Polymorphism (from Greek: “many” + “forms”) is the ability of code—most commonly methods—to take on many forms depending on the runtime type of the object it acts upon. In Java this allows a single interface or method call to produce different behavior for objects of different classes that share a common supertype.

🔑 Core Concept

A variable typed as a supertype can refer to subtype objects. The invoked method behavior depends on the actual object type at runtime (not just the reference type). This enables writing code that works on general types while concrete types provide specific implementations.

🐦 Example Patterns (Animal / Movement)

Imagine an inheritance hierarchy with Animal as the superclass and Fish, Frog, Bird as subclasses. Each subclass implements move() differently (swim, jump, fly). A program can hold an array of Animal references and call move() on each element; each element performs the appropriate subclass behavior.

🍚 Food Example (Method Overriding Illustration)

A generic class Food defines taste(). Subclasses Rice, Potatoes, Peppers override taste() to provide specific outputs (sweet, sour, spicy). The same message taste() produces different results depending on the object’s concrete class.

✅ Why Use Polymorphism in Java

• Flexibility & Extensibility: New subclasses can be added with minimal or no change to existing generic code.
• Simplified programming: One interface or method name handles many related behaviors.
• Code reuse: Subclasses inherit general behavior and override only where needed.
• Plug-in design: Systems that operate on supertypes can accept new subtype classes with minimal changes.

🧭 Interfaces and Polymorphism

Interfaces let unrelated classes share a common protocol. Objects implementing the same interface can be treated polymorphically; the interface defines calls, and each implementing class provides its own behavior.

🔁 Inheritance vs Polymorphism (Difference)

• Inheritance: establishes an “is-a” relationship and shares structure/behavior from a superclass to subclasses.
• Polymorphism: concerns behavioral substitution—the change or specialization of behavior in subclasses. Inheritance makes polymorphism possible, but polymorphism is the runtime selection of specific behavior.

⏱ Types of Polymorphism in Java

• Dynamic (runtime) polymorphism: Method overriding; the exact implementation is chosen at runtime based on the object.
• Static (compile-time) polymorphism: Method overloading; resolved at compile time based on method signatures.

🔁 Method Overriding (Runtime Polymorphism)

• Occurs when a subclass declares a method with the same signature as a superclass method.
• The superclass method is overridden; the subclass method is overriding.
• Advantage: allows each subclass to provide specialized behavior without changing superclass code.

Rules for Method Overriding

• Signature match: The argument list (types and order) must match exactly.
• Access modifier: The overriding method cannot be more restrictive than the overridden method.
• Non-overridable methods: private, static, and final methods cannot be overridden. (Static methods may be re-declared in subclasses, but this is not overriding—this is hiding.)

🔗 Binding: Linking Calls to Implementations

Binding associates a method call with a method body. Java supports two binding strategies:

• Static (early) binding: Resolved at compile time (used for static, private, final methods). The compiler determines the class type to bind.
• Dynamic (late) binding: Resolved at runtime. The JVM locates the method implementation by walking the actual object’s class hierarchy until it finds a matching implementation; the first found is invoked. This is how overriding works in practice.

🧠 Dynamic Binding Details

When an object o is an instance of class C1 (a subclass of C2, ... up to Object), and a method p is invoked on o, the JVM searches from the most specific class up the hierarchy (C1, then C2, etc.) until it finds the implementation. The first match is invoked and search stops. This guarantees the most specific applicable implementation runs.

📚 Method Matching vs Binding

• Method matching (compile-time): The compiler finds a method signature matching the call (based on parameter types and order). This is how overload resolution is done.
• Binding (runtime): Once a matching signature is established, the JVM dynamically binds the actual implementation based on the object's runtime type.

🧾 Practical Examples & Use Cases

• Quadrilaterals: A Rectangle subclass of Quadrilateral can be used anywhere a Quadrilateral is expected; calls to shared methods will execute Rectangle versions when appropriate.
• Video game objects: A ScreenManager stores references to SpaceObject; subclasses (Martian, Venusian, SpaceShip, LaserBeam) override draw(). The manager calls draw() on each SpaceObject and each draws itself appropriately—new subclasses can be added without modifying the manager.
• Payroll example: Hold Employee references and invoke a pay() method polymorphically —different employee types compute pay differently.

🧾 Tips to Remember

• A polymorphic reference can refer to different object types at different times.
• A method invoked through a polymorphic reference can change implementation between calls.
• All object references in Java are potentially polymorphic.
• Polymorphism promotes extensibility: systems operating on supertypes are open to new subtypes without core changes; only code that instantiates new types needs to change.

🧩 Static vs Dynamic Binding Examples (Summary)

• Static binding: static, private, final methods — compiler determines the binding; behavior does not vary with runtime object type.
• Dynamic binding: non-static, non-final, non-private instance methods — the JVM chooses the implementation using the actual object’s class at runtime.

🏷 Common Pitfalls & Clarifications

• Overriding is not possible for private, static, or final methods; static methods are hidden, not overridden.
• Matching method signatures is a compile-time responsibility; choosing which implementation to run is a runtime responsibility.
• Access modifiers must allow the overriding method to be at least as accessible as the overridden one.

🧭 UML & Documentation

UML diagrams can illustrate polymorphic relationships (superclass -> subclasses) and show which methods are overridden. They help visualize how a manager or client operates on the supertype and relies on polymorphic behavior of subtypes.

📚 References Mentioned in Slides

The slides reference texts such as JavaHowtoProgram (Deitel), JavaFoundations (Lewis/DePasquale/Chase), and Introduction to Java Programming (Liang) for deeper reading and example code.

✅ Key Takeaway

Polymorphism is a foundational object-oriented principle in Java that decouples the use of an operation from the specific implementations. By relying on inheritance and interfaces, polymorphism enables extensibility, cleaner designs, and runtime selection of behavior—making systems more maintainable and easier to extend.