在Java中使用多态时是否存在对象的隐式转换？

Question

Suppose I have 3 classes:

• The super class is: Animal
• There is 1 subclass Dog that inherits Animal
• There is 1 subclass Cat that inherits Animal

Now if I do this: Animal a = new Dog();

Does the object Dog that a points to get casted to Animal ?

If yes then does this cast both the variable and the object to dog?

((Dog)a).bark(); // bark() is specific for the Dog

Also what are the rules for casting these reference types in Java?

Answer 1

I will try to describe what happens in the background, in the hopes that it will clear some things. Lets break this declaration & definition into parts.

1. 'a' is declared as an Animal.
2. 'a' is defined as a Dog.
3. Dog extends Animal, therefore, animal methods (including constructor) get defined.
4. Dog's methods get defined, whilst overriding any method that was defined by the parent class Animal) and overshadowing member variables of the parent class.

When looking at 'a', you are using the 'Animal' perspective and for that reason you are not capable of using any methods (or fields) declared only by sub-classes of Animal. In order to "gain" that perspective you can downcast from Animal to Dog exactly as you did. Keep in mind that downcasting is not safe whereas upcasting is.

For example:

Animal a = new Cat(); // cats can mew
Animal b = new Dog(); // dogs can bark
(Dog)b.bark() // Unsafe but compiles and works.
(Dog)a.bark() // Unsafe but compiles and throws a run time exception. 

In general, a good practice would be to create an abstract class for an Animal and then override some of it's methods with subclasses. For example:

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


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


public class Cat extends Animal {
  void makeNoise(){
    System.out.println("mew");
  }
}