Best way to route method calling from List in Java

Question

What's definitely the best way to call a different method of a class according to a different object type in a List?

common example:

public class Dog extends Animals{
  ...
  public void say(){
    System.out("i'm a dog");
}

public class Cat extends Animals{
  ...
  public void say(){
    System.out("i'm a cat");
}

public class OtherClass {
  public void route(){
    List<Animals> aList = new ArrayList<>();
    a.add(new Dog());
    a.add(new Cat());
    for(Animals a:aList)
     methodOverloaded(a); ---> that's the point <---
  }
  public methodOverloaded(Dog d){
    d.say();
  }

  public methodOverloaded(Cat c){
    c.say();
 }
}

Of course, the metaphorical goal is print I'm a dog on the first iteration and I'm a cat on second running methodOverloaded().

I tried

• Visitor Pattern
• instanceOf()

but I'm looking for better solution.

edit : I stricrtly want to call the overloaded methods of example's OtherClass.

Answer 1

The best way is to define abstract method in Animal and override it in child classes. That's how the polymorphism works.

No need of overloadings.

public abstract class Animal {
    public abstract void say();
}

public class Dog extends Animal {

    @Override
    public void say() {
        System.out.println("Bark");
    }
}

public class Cat extends Animal {

    @Override
    public void say() {
        System.out.println("Meow");
    }
}

Usage:

public class Main() {
    public static void main(String[] args) {
        List<Animals> aList = new ArrayList<>();
        a.add(new Dog());
        a.add(new Cat());
        for (Animals a : aList)
            a.say();
    }
}

Output:

Bark
Meow

____UPDATE_1

I would like to add some comments why the overloading these methods is not a good idea.

If you will add the following to your code - it will compile:

public methodOverloaded(Animal a) {
    a.say();
}

But it will not work as you're expecting. It will call public methodOverloaded(Animal a) for all the elements of List.

Why does this happen?

For all iterations of the loop, the compile-time type of the parameter is Animal. The runtime type is different in each iteration, but this does not affect the choice of overloading. Because the compile-time type of the parameter is Animal, the only applicable overloading is the third one.

The behavior of this program is counterintuitive because selection among overloaded methods is static, while selection among overridden methods is dynamic.

The correct version of an overridden method is chosen at runtime, based on the runtime type of the object on which the method is invoked.

This can be fixed with:

public methodOverloaded(Animal a) {
    if (a instanceof Cat) ? "Meow" : 
       (a instanceof Dog) ? "Bark" : "Unknown Animal"
}

Of course suggested option with overriding methods demonstrates better approach and more clean code.

Also, a safe, conservative policy is never to export two overloadings with the same number of parameters, because it can confuse the client of the API. You can always give methods different names instead of overloading them.

But there is the case when at least one corresponding formal parameter in each pair of overloadings has a “radically different” (when it's clearly impossible to cast an instance of either type to the other) type in the two overloadings.

For example, ArrayList has one constructor that takes an int and a second constructor that takes a Collection. It is hard to imagine any confusion over which of these two constructors will be invoked under any circumstances.