Why downcasting is allowed in java?

Question

class Animal{
  public void findAnimal(){
    System.out.println("Animal class");
  }
  public void sayBye(){
    System.out.println("Good bye");
  }
}

class Dog extends Animal{
 public void findAnimal(){
  System.out.println("Dog class");
 }
}

Given the inheritance above ,it is understood that a reference of Animal can refer to an object of Dog

Animal animal=new Dog();

As a Dog object can perform everything an Animal can do like in above case a Dog also have sayBye and findAnimal methods.

But why it is allowed to downcast an Animal object to a Dog object which serves no purpose and fails at runtime.

Dog dog=(Dog)new Animal(); // fails at runtime but complies.

Dog dog=(Dog)animal;

The above statement look logical as the animal reference is pointing to a Dog object.

Answer 1

This sort of casting is allowed for situations when you get an object of a superclass from outside code, e.g. as a parameter to your method, and then you need to call methods specific to a subclass.

This is not a good practice, but in some rare situations you are forced to do things like that, so the language allows it:

void sound(Animal animal) {
    if (animal instanceof Dog) {
        Dog dog = (Dog)animal();
        dog.bark();
    }
    if (animal instanceof Cat) {
        Cat cat = (Cat)animal();
        cat.meow();
    }
}

why it is allowed to compile Dog dog=(Dog) new Animal()

Because compiler designers decided to not detect this error at compile time. They verified that the expression being cast to Dog is of type that is a superclass of Dog, and allowed the expression to compile. They could go further and check that the expression will always result in an exception, but that would require an additional effort for very little improvement in user experience with the language.

Answer 2

Because you need it sometimes.

Especially when Java did not yet have generics (Java 1.4 and older), you almost always needed to cast when you got for example an object out of a collection.

// No generics, you don't know what kinds of objects are in this list
List list = new ArrayList();

list.add(new Dog());

// Need to cast because the return type of list.get() is Object
Dog dog = (Dog)list.get(0);

Since we have generics since Java 5, the need for casting is greatly reduced.

You should try to avoid casting in your code as much as possible. A cast is a way to deliberately switch off the compiler's type checking - in general you don't want to do that, you want to make use of the compiler's checking instead of circumventing it. So, if you have code where you need to cast, think a bit further to see if you can write it without the cast.

Answer 3

You need that capability to access an earlier cast object as its original type.

For example, if you cast a Dog to an Animal to pass it to a generic processor, you may later need to cast it back to a Dog to perform specific methods.

The developer is responsible to make sure the type is compatible - and when it is there will be no error. Some pseudo code:

public void example(Animal foo){
    if( ...condition... ) ((Dog)foo).bark();
    else if( ...other condition... ) ((Cat)foo).meow();
}

Since the introduction of generics, this is less commonly used, but there are still cases for it. The developer is solely responsible for guaranteeing the type is right if you don't want an error.

Answer 4

case 1 -

Here we use loose coupling.

Animal animal = getSomeDog(),

Dog dog = (Dog) animal; // this is allowed because animal could reference a dog

case 2

Here we you use tight coupling.

Animal animal = new Animal();

Dog dog = (Dog) animal; // this will fail at runtime, because animal doesn't reference a Dog

We use Downcasting when there is possibility to succeed at run time so case 1 has possibility to succeed at runtime over case 2

Answer 5

Down casting is considered as a bad Object Oriented practice. It must be avoided to as much extent as possible.

Java still has it and your question is a good question as why Java allows Down-casting.

Suppose a case below.

public interface List{
    public boolean add(Object e);
    public boolean remove(Object o);
}  

public class ArrayList implements List{

  // Extra method present in the ArrayList and not in the parent Interface
    public Object[] toArray() {
        // returns array of the objects
        return Arrays.copyOf(elementData, size);
    }

    @Override
    public boolean add(Object e){
        // add e to the ArrayList Underlying array
    }
    @Override
    public boolean remove(Object o){
       // remove o from the ArrayList Underlying array
    }
}

A good Object oriented practice is to Code for Interfaces. But often there are methods defined in the concrete implementations which we need to call. I read an comment from some one and I quote it in my words.

Know the Rules, in case you need to break them Do break them Knowingly and take care so as to prevent from any adverse effect.

Below is an example where we need to do the Down-casting. The example of down-casting in your question is to teach what is down-casting, below is real life example.

public void processList(List items){
   items.add( new Object() );
   items.add( new Object() );
   processAsPerTypeOfList(items);
}

public void processAsPerTypeOfList( List items ){
    if( items instanceof ArrayList){
         Object[] itemArray = ((ArrayList)items).toArray();// DOWNCASTING
         // Process itemArray
    }
} 

For more reference you can also see a related question : Why Java needs explicit downcasting?