How to avoid type checking with Java/OOP in this situation?

Question

I have a collection of animals (interface) which contains birds and cats (both also interfaces). I want to print out all the cats to the console and I am forbidden to use instanceof (I did not make up this arbitrary restriction).

What is the correct way in OOP to solve this? getClass() is not possible because I just have access to the API and it would not comply with OOP concepts. Another alternative would be the visitor pattern (I can change the API), but this would be just be a very convoluted way to effectively perform a type-check.

Answer 1

This doesn't occur to a lot of people for some reason, but my preferred way in real code is to never mix them up in the first place. Have a List<Bird> and a separate List<Cat>, and either create your List<Animal> from the first two on demand when needed, or add to it at the same time you construct the bird and cat lists.

The other ways I'm aware of either violate the Interface Segregation Principle by requiring classes to use or implement methods that are of no interest to them (like an empty print or an isCat or a visitor pattern), or are functionally equivalent to instanceof. In my opinion, if you can't avoid the intermingling, you may as well use instanceof to split it out into a separate list. Whoever gave you that restriction should advise you on what principle is worse to violate in your particular case.

Answer 2

Add method Print to the interface
Cats will implement this method by printing out some value
Birds will implement it as an "empty" method, which do nothing or print empty string.

public interface IAnimal
{
    public string Name { get; }
    public void Print();
}    

public class Cat : IAnimal
{
    public Cat(string name) => Name = name;

    public Print() => Console.WriteLine(Name);
}

public class Bird : IAnimal
{
    public Cat(string name) => Name = name;

    public Print()
    {
        // Do nothing or print empty string
    }
}

Usage would look like below

var animals = new IAnimal[] { new Cat("First"), new Bird("Second"), new Cat("Third") };

foreach (var animal in animals)
{
    animal.Print();
}

 // Output:
 // First
 // Third

With such approach consumers of Animals(Cats and Birds) don't need to know of their actual type.

"Knowing" specific type somewhere where interface is used - will bound consumer code to the implementation details, which we trying to avoid when following Dependency Inversion Principle.