Overloading - how do I avoid instanceof?

Question

I am looking for a way to chose between overloaded methods without using specific casts.
The following code tries to explain my problem:
public class Overloading {
     public static void main(String[] args){
          new Overloading();
     public Overloading(){
          Animal macavity = new Cat();
          classify(macavity); // macavity is not classified as a cat
          // this is what I want to avoid having to do
          if(macavity instanceof Cat)
               classify((Cat)macavity);
     private void classify(Animal animal){
          System.out.println("Just an animal.");
     private void classify(Cat cat){
          System.out.println("A cat!");
     class Animal{}     
     class Cat extends Animal{}
}In the project I'm working has sanctioned that "Animals" cannot be allowed to classify themselves; they must be classified "from the outside" (not my rules).
In the code I use instanceof to force use of the correct overload, but since there might be many animals this checking quickly becomes cumbersome!
Is there any way I can cast an animal into its instantiation type without using instanceof?

Answer 1

There's not a whole lot you can do as Java is not a dynamically bound (ie. at runtime) language. Java always uses the variable type at compile-time to decide which method is being called. 2 suggestions:
1). You use reflection to be terribly clever at runtime and decide which method should be called.eg.
    Method m = Overloading.class.getDeclaredMethod("classify", macavity.getClass());
    m.setAccessible(true);
    m.invoke(macavity);This is almost certainly a very bad idea.
2). Use some kind of handler-chain to classify and pass the animal along the chain until it is handled. You don't avoid the instanceof mess, but at least you don't have a huge if-else block.
    public class ClassifierChain
        public static interface Classifier {
            /** Return true if the implementation can classify the Animal */
            boolean classify(Animal a);
        public void classify(List<ClassifierChain.Classifier> classifiers, Animal a) {
            for (ClassifierChain.Classifier classifier : classifiers) {
                if (classifier.classify(a)) break;
    public class CatClassifier implements ClassifierChain.Classifier {
        public boolean classify(Animal a) {
            if (a instanceof Cat) {
                // ... do something with a cat
               return true;
            return false;
    }Rubbish design, but you get the idea. Having said this, the previous post makes a lot of sense; in most cases it makes sense to keep your type-specific code bound closely to the type (ie. as a method on it). Obviously there are plenty of examples where this is a bad idea (eg. coupling UI-code to domain object classes).