Why different types of object reference is allowed

问题:

I wonder why it is allowed to have different type of object reference? For example;

Animal cow = new Cow();

Can you please give an example where it is useful to use different type of object reference?

Edit:Cow extends Animal

回答1:

This is at the heart of polymorphism and abstraction. For example, it means that I can write:

public void handleData(InputStream input) {
    ...
}

... and handle any kind of input stream, whether that's from a file, network, in-memory etc. Or likewise, if you've got a List<String>, you can ask for element 0 of it regardless of the implementation, etc.

The ability to treat an instance of a subclass as an instance of a superclass is called Liskov's Substitution Principle. It allows for loose coupling and code reuse.

Also read the Polymorphism part of the Java tutorial for more information.

回答2:

On a simpler note, this enables polymorphism. For example you can have several objects that derive from Animal and all are handle similar.

You could have something like:

Animal[] myAnimal = {new Cow(), new Dog(), new Cat()};

foreach (Animal animal in myAnimal)
   animal.Feed();

The Feed() method must then be overriden within each child class.

By the way, code is C#-like but concept is the same in Java.

回答3:

This is basically a concept of standardization.

We know that each animal have some common features. Let us take an example of eating and sleeping, but each animal can have different way of eating or sleeping ... then we can define

public abstract class Animal
    {
         public abstract void Eat();
         public abstract void Sleep();

    }
    //Now Define them in various classes..

     public class Cow extends Animal
    {
         pubic void Eat()
         {
            //process of eating grass
         }

         public void Sleep()
         {
            //process of sleeping
         }
    }

   public class Lion extends Animal
   {
         public void Eat()
         {
            //process of eating flesh
         }

         public void Sleep()
         {
            //process of sleep
         }
   }

Now you do not have to define different objects to different classes... just use Animal and call generally

public class MyClass
  {
      public static void main(String[] args)
      {
           Animal _animal = new //think the type of animal is coming dynamically 
          //you can simply call 
          _animal.Eat();
          _animal.Sleep();
          // irrespective of checking that what can be the animal type, it also reduces many if else
       }
  }

回答4:

This is called polymorphism and it's one of the most powerful aspects of Java.

Polymorphism allows you to treat different objects the same.

It's a great way to create re-usable, flexible code.

Unfortunately it's a part of Java that new programmers often take awhile to understand.

The example you've provided involves inheritance (extending a class).

Another way to enjoy the benefits of polymorphism is to use interfaces.

Different classes that implement the same interface can be treated the same:

class Dog extends Animal implements Talker {
    public void speak() {
        System.out.println("Woof woof");
    }
}

class Programmer implements Talker {
    public void speak() {
        System.out.println("Polymorphism rocks!");
    }
}

interface Talker {
    public void speak();
}

public static void testIt() {
    List<Talker> talkerList = new ArrayList<Talker>();
    talkerList.add(new Dog());
    talkerList.add(new Programmer());
    for (Talker t : talkerList) {
        t.speak();
    }
}

回答5:

Simply putting all Cows are Animals. So JAVA understands that when Cow extends Animal, a Cow can also be called as Animal.

This is Polymorphism as others have pointed out. You can extend Animal with Dog and say that Dog is also an Animal.

回答6:

In another class/method you might want to use different implementations of the same interface. Following your example, you might have something like:

public void feed( Animal animal ) {   
  animal.getHome().insertFood(animal.getFavFood());
}

Now you can implement the details in your animal classes and don't have to extend this method anytime you add a new animal to your programm.

So in some cases you need the common interface in order not to implement a method for each implementation, whereas on other occasions, you will need to use the explicit implementation.

回答7:

This is an inheritance 101 question.

It allows objects that share common functionality to be treated alike.
It also allows specific implementations to be supplied at runtime that are subclasses of an abstract type.

I could probably ramble on for ages. Perhaps thus question is just too broad to answer here.