关于oop：为什么Java中允许不同类型的对象引用？

Why different types of object reference is allowed in Java?

我想知道为什么它可以有不同类型的对象引用？例如；

1	Animal cow = new Cow();

你能举个例子说明使用不同类型的对象引用有什么用处吗？

编辑：Cow extends Animal。

这是多态性和抽象的核心。例如，它意味着我可以写：

1
2
3

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

…并且处理任何类型的输入流，无论是来自文件、网络、内存等，或者类似的，如果您有一个List，那么无论实现如何，您都可以请求它的元素0。

将子类的一个实例视为超类的一个实例的能力称为Liskov的替换原理。它允许松耦合和代码重用。

还可以阅读Java教程的多态性部分以获取更多信息。

相关讨论

这基本上是标准化的概念。

我们知道每种动物都有一些共同的特征。让我们举一个吃和睡的例子，但是每种动物可以有不同的吃或睡的方式…然后我们可以定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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
}
}

现在您不必为不同的类定义不同的对象…只需使用动物和呼叫一般

1
2
3
4
5
6
7
8
9
10
11

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
}
}

更简单的说，这可以实现多态性。例如，您可以有几个从动物派生的对象，所有对象的处理方式都类似。

你可以有这样的东西：

1
2
3
4

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

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

然后必须在每个子类中重写feed()方法。

顺便说一下，代码是类似于C的，但是Java中的概念是相同的。

这被称为多态性，它是Java最强大的方面之一。

多态性允许您对不同的对象进行相同的处理。

这是创建可重用、灵活的代码的好方法。

不幸的是，新程序员通常需要花些时间才能理解Java的一部分。

您提供的示例涉及继承(扩展类)。

另一种享受多态性好处的方法是使用接口。

实现相同接口的不同类可以处理相同的内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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();
}
}

这是一个继承101问题。

它允许对共享公共功能的对象进行相似的处理。它还允许在运行时提供抽象类型的子类的特定实现。

我可能会闲聊很久。也许这样的问题太宽泛了，无法在这里回答。