Polymorphism (Week 4) — Comprehensive Study Notes Summary & Study Notes

🧭 Overview

Polymorphism = "many forms". It is the capability of a method to do different things based on the object it acts upon. Polymorphism lets you “program in the general” rather than “program in the specific,” enabling code that processes objects sharing a common superclass or interface as if they were objects of the general type.

🔁 Core Concepts

Subtype / Supertype — A class defines a type; a subclass defines a subtype and a superclass defines a supertype. A variable of a supertype can refer to an object of any subtype (e.g., a Bird is a subtype of Animal; an Animal reference can hold a Bird).

Key idea: Send the same message (method call) to different objects; each object responds in its own way. The runtime object determines the actual behavior.

🧩 Examples to Internalize

• Animal examples: Fish.swim(), Frog.jump(), Bird.fly(); program issues move() to each Animal reference and the concrete subclass updates coordinates appropriately.
• Food example: superclass Food defines taste(); Rice, Potatoes, Peppers override taste() to provide specific behaviors.
• Video game: SpaceObject superclass with subclasses Martian, SpaceShip, LaserBeam each override draw() — screen manager stores SpaceObject references and repeatedly calls draw().

⚙️ Why Use Polymorphism?

• Makes class design flexible and extensible.
• Simplifies programming by providing a single interface with multiple concrete meanings.
• Enables code reuse and adding new classes with minimal changes to existing (general) code.
• New subclasses can “plug in” as long as they follow the inheritance/interface contract.

🔁 Polymorphism Through Inheritance

The type of the object being referenced (not the reference type) determines which implementation is invoked. Example: if pet references a Horse object, pet.move() calls Horse.move(); if it references a Mammal object, it calls Mammal.move().

⚖️ Inheritance vs Polymorphism (short contrast)

• Inheritance applies behaviors and structure from a superclass to a subclass.
• Polymorphism is about altering or selecting behavior at runtime through overriding so the same call can have many forms.

🧾 Method Overriding

Definition: A subclass declares a method with the same signature as one in its parent to provide a specialized implementation.

Rules and constraints:

• The overriding method must match the argument list (type and sequence).
• The overriding method’s access modifier cannot be more restrictive than the overridden one.
• private, static, and final methods cannot be overridden (static can be re-declared but not overridden).

Advantages:

• Helpful when a class has multiple child classes; each child can choose its own implementation without modifying the parent code.

🔎 Binding (Early vs Late)

Binding = association of a method call to the method body.

• Static (early) binding: resolved at compile-time. Applies to static, private, and final methods because they cannot be overridden.
• Dynamic (late) binding: resolved at runtime. The JVM uses the actual object to determine which overridden implementation to invoke.

Important: The compiler matches a method by signature (parameter types/number/order) at compile-time; the JVM dynamically binds the actual implementation at runtime.

🧠 Types of Polymorphism in Java

• Static (compile-time) polymorphism: Method overloading.
• Dynamic (runtime) polymorphism: Method overriding.

🔬 Dynamic Binding Details

When an object is an instance of multiple classes in an inheritance chain, the JVM searches for the method implementation starting from the most specific class upward to the root (Object). The first found implementation is invoked.

⚠️ Static Binding Example Notes

If a method is static in both parent and child, the method invoked depends on the reference type (compile-time type) — not the runtime object. Thus static methods do not exhibit runtime polymorphism.

✅ 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 from one invocation to the next.
• All object references in Java are potentially polymorphic.
• Interfaces are especially useful for polymorphism across unrelated classes: objects implementing the same interface can be processed generically.

🧾 Practical Advice

Design systems so that general code operates on supertypes or interfaces; add new concrete classes that implement or extend those types when extending functionality. Only instantiation points need changes when new classes are added.

📚 References (from slides)

Examples and diagrams in the slides drew from JavaFoundations, Liang, and Deitel texts for demonstration code and UML diagrams.

📝 Context & Task Note

This note records the user task: capture key concepts from the provided Week #4 lecture slides into an organized structure. The previous section summarizes those slide concepts. Use these notes to review polymorphism, method overriding, binding, and design tips for writing extensible Java code.