When studying Java, I encountered the concept of polymorphism. I have a tendency to grasp the foundational principles before delving into practical usage, so I have documented my interpretation here.

Common Explanations of Polymorphism I Have Seen

The original meaning of polymorphism is "diversity." However, in the context of this article, it refers to the ability of a variable to hold objects of different types, as long as there is a relationship through class inheritance or interface implementation, without causing errors.

Typical Type Matching

Generally, the type of a variable matches the type of the object it references.

Animal animal = new Animal();

However, when the object extends a class, the variable can be treated as the type of the superclass.

Animal animal = new Dog(); // Dog extends Animal

Furthermore, if an object implements an interface, it can be treated as the interface type.

// Interface definition
interface Animal {
    void makeSound(); // Method in the interface
}

// Classes implementing the interface
class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof!"); // Dog-specific implementation
    }
}

class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow!"); // Cat-specific implementation
    }
}

// Main method
public class Main {
    public static void main(String[] args) {
        // Assign objects to variables of the interface type
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        // Call the interface method
        myDog.makeSound(); // Outputs "Woof!"
        myCat.makeSound(); // Outputs "Meow!"
    }
}

This allows us to handle different classes as the same type, enabling flexible coding.

What Is a Type?

While discussing how a variable's type and an object's type differ, it raises the question: what exactly is a "type"? Based on my analysis, I have concluded that a type serves the following purposes:

• Declaration: Specifies what kind of data is stored in a memory region.
• Type: Dictates how the stored data is utilized.

Referencing the earlier example:

Animal animal = new Dog(); // Dog extends Animal

This implies that memory is allocated for Dog, but the variable interprets the content as Animal. The concept can be visualized like this:

A type acts like a filter lens, determining how the data is perceived. By changing the lens, you can focus on common methods in the superclass or specific methods via interfaces.

Why Not Always Declare with the Superclass?

One might wonder why we don’t always declare variables with the superclass if polymorphism's advantage is handling common methods across classes. The reason is that memory is only allocated for the superclass's data in such cases.

While it is possible to cast a subclass to a superclass (upcasting), the reverse is not true. This is because a subclass includes data from the superclass plus its own unique data. Therefore, memory is pre-allocated for the subclass, allowing the use of subclass-specific methods through upcasting.

In the Case of Interfaces

Interfaces also act as types, and their role as filter lenses for processing the data stored in the object's memory is conceptually similar to that of classes. The methods invoked through the interface are determined by the object's type, not the variable's type (dynamic binding). This reinforces the idea that the variable's type merely acts as a filter, allowing us to utilize the filtered data.

Conclusion

Polymorphism is useful in scenarios where common processes need to be unified while also leveraging individual characteristics. Through my exploration, I gained a better understanding that while the memory layout of an object remains determined by its type, the variable's type controls how that memory is interpreted—a significant realization for me.