I am trying to understand Java\'s polymorphism, and I have one question about downcasting an object. Let\'s say for this example I have two subclasses Dog and Cat that inher
Here you are talking about downcasting, so in this scenario always superclass should be used as a reference and child object should be pointed by that. This usd basically in factory patter.
Java is a strongly typed language, and that means you can only cast an object to a type it extends from (either a superclass or an interface).
Even if you "fake it", e.g. copy all a classes methods and fields, you just can't cast an object to a type it doesn't extend.
public class Foo{
public String phleem;
public void bar(){
}
}
public class Bar{
public String phleem;
}
public interface Baz{
public void bar();
}
Given the above code, you can't cast a Foo
object to either a Bar
or a Baz
, although the class structure seems to imply that you could. There is no inheritance involved, so a ClassCastException
is thrown.
If you want to create an instance of a type that may vary depending upon non-local conditions, use an Abstract Factory (as described in the Design Patterns book).
In it's simplest form:
interface AnimalFactory {
Animal createAnimal();
}
class DogFactory implements AnimalFactory {
public Dog createAnimal() {
return new Dog();
}
}
Note also there is a difference between the static type of a reference and the dynamic type of the object. Even though you have an Animal
reference, if the original object is a Dog
, it still behaves like a Dog
.
You should only cast to a class that the object really is, so if you have a Dog
that extends Animal
you can cast it to an Animal
(because it is one) but you shouldn't cast an Animal
to a Dog
because not all Animal
s are Dog
s. The Dog
class may well have extra fields that are not implemented by the Animal
class and so the cast doesn't make sense (what do you initialise those values to?).