java对象，我用动物speedy = new dog（）创建动物或狗吗？ 为什么？

Question

I don't get what I'm creating actually... Usually you create an object with dog speedy = new dog(); you call the constructor dog() which creates a dog object and speedy is the name of the reference to it. but what if the first dog is named "animal" ( dog extends animal ) ?

Answer 1

Your question isn't very clear, but if your Dog class is extending Animal, and you want to use the Dog methods/fields, you need to create a new Dog. You could create an Animal a = new Dog() but you still won't be able to access the Dog methods/fields (although it shouldn't throw an error)

Answer 2

Static vs dynamic type of an object

Consider the following classes:

class Animal {
    void eat() { System.out.println("Nom nom"); }
}
class Dog extends Animal {
    void eat() { System.out.println("I want a bone"); }
    void bark() { System.out.println("WOOF"); }
}

Now consider the following code:

Animal dog = new Dog();

Question: what is the type of the variable dog ? The answer depends on whether you want to know the static type or the dynamic type.

Static type is the type the compiler sees, which is Animal in this case. This is also the type of the variable. This will define which methods are available.

Dynamic type is the type that is defined at runtime, it is the "real" type of the variable, which defines its behaviour.

In the above code you will not be able to call bark() on variable dog , because its static type is Animal . However, when you call eat() , it will return I want a bone because its behaviour is defined by its dynamic type which is Dog .

In many cases you do not know the dynamic type of an object. For example if you write a method that has a parameter of type List , the actual dynamic type will be known only when someone calls your method with a List implementation (such as ArrayList , LinkedList etc.).

Answer 3

This depends on the way in which you would like to use your dog object. Consider this example:

class Animal {
    public void eat() {
        System.out.writeln("nam nam nam");
    }
    public void sleep() {
        System.out.writeln("zzzz zzzz");
    }
}
class Dog extends Animal {
    public void bark() {
        System.out.writeln("ruff ruff");
    }
}

If you want to treat your dog like the rest of the animals, ie as someone who can eat and sleep, you do this:

Animal fifi = new Dog();
fifi.eat();   // Works fine
fifi.sleep(); // Works fine
fifi.bark();  // Compile error!

However, Fifi cannot bark. If you do this, on the other hand,

Dog speedy = new Dog();
speedy.eat();
speedy.sleep();
speedy.bark();

your Dog would be able to bark, in addition to also being able to eat and sleep, like the rest of the animals.