Where can polymorphism be applied in Java?

Polymorphism in Java can be applied in the following cases:

When working with collections: You can store objects of different subtypes of a base type or interface in a collection and process them uniformly.

// Creating a list of Animal objects (or its subtypes)
List<Animal> animals = new ArrayList<>();
animals.add(new Dog());
animals.add(new Cat());

// Calling the sound() method uniformly for all objects in the list
for (Animal animal : animals) {
    animal.sound(); // calls the method specific to each subtype
}

When passing method arguments: You can pass objects of different subtypes to a method expecting a base type or interface.

// Method accepts an Animal object as a parameter
public void processAnimal(Animal animal) {
    animal.eat(); // calls the method specific to the particular object
}

// Calling the method with different subtypes
processAnimal(new Dog());
processAnimal(new Cat());

When returning method values: A method can return objects of different subtypes of a base type or interface.

// Method returns an Animal object (or its subtype)
public Animal createAnimal(String type) {
    if ("dog".equals(type)) {
        return new Dog();
    } else if ("cat".equals(type)) {
        return new Cat();
    }
    return null; // or throw an exception
}

// Assigning the result to a variable of the base type
Animal myAnimal = createAnimal("dog");
myAnimal.sound(); // calls sound() for Dog

When inheriting and overriding methods (runtime polymorphism): A subclass overrides a parent class method. The specific method implementation is chosen at runtime depending on the actual object type.
When overloading methods (compile-time polymorphism): Multiple methods with the same name but different signatures (parameters) exist in a class. The compiler determines which method to call based on the types and number of arguments during compilation.
In framework and library development: Polymorphism allows creating flexible and extensible APIs, where users can provide their own interface implementations or extend existing classes. For example, in working with input/output streams or event handling.
When implementing design patterns: Many patterns, such as Strategy, Factory Method, Observer, actively use polymorphism to create flexible and interchangeable components.