【问题标题】:Polymorphism in java: Why do we set parent reference to child object?java中的多态性:为什么我们将父引用设置为子对象?
【发布时间】:2015-11-15 12:07:41
【问题描述】:

我想了解将父引用设置为子对象的用例。 示例:Dog 类扩展 Animal 类。 (没有接口,请注意) 我通常会像这样创建一个 Dog 对象:

Dog obj = new Dog();

现在,由于 Dog 是 Animal 的子类,它已经可以访问 Animal 的所有方法和变量。那么,这有什么不同:

Animal obj = new Dog(); 

请提供适当的用例及其使用代码 sn-p。请不要有关于“多态性”或“接口编码”的理论文章!

代码:

public class Polymorphism {
    public static void main(String[] args){
        Animal obj1 = new Dog();
        Dog obj2 = new Dog();
        obj1.shout(); //output is bark..
        obj2.shout(); //output is bark..        
    }   
}

class Animal{
    public void shout(){
        System.out.println("Parent animal's shout");
    }       
}

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

class Lion extends Animal{
    public void shout(){
        System.out.println("roar..");
    }
}

class Horse extends Animal{
    public void shout(){
        System.out.println("neigh");
    }
}

两种情况的输出相同。那为什么要给子对象设置父引用呢?

【问题讨论】:

  • 狗是一种动物,因此您可以分配给动物。但你不能将动物分配给狗。因为它可以不同。如果您确定它是狗动物,您可以使用铸造将其命名为狗。如果动物是狗,那么你不能说它是山羊,所以你不能把狗动物扔给山羊
  • 你的谷歌关键词是programming to interface.
  • 从明天开始,您可能想用其他动物、狮子或老虎来实现。
  • 它是一个类,而不是一个接口,这一事实在这个讨论中没有区别。请注意,大多数答案都是关于接口的。如果Animal 是一个类,那么做Animal animal = new Dog() 并不重要。此外,示例请求在 Stack Overflow 上是题外话,因为无法正确回答 - 每个人都可以提出不同的示例。

标签: java oop polymorphism


【解决方案1】:

这是一个原则的实现 -

编程到接口,而不是实现。

例如,如果您设计一个方法来接受Animal 类型的引用,那么将来您可以轻松地将一个= Cat 实现传递给它(当然前提是Cat 是一个子Animal 的类型。

这意味着-

public void doSomethingWithAnimal(Animal animal) {
    // perform some action with/on animal
}

比 -

灵活得多
public void doSomethingWithAnimal(Dog d) {
    // your code
}

因为对于第一种方法,您可以轻松地执行类似的操作 -

doSomethingWithAnimal(new Cat());

如果您决定创建新的 Cat 类型,继承自 Animal。

【讨论】:

  • 哇,这些天人们对答案投反对票的速度如此之快。有人可以指出我在回答中所说的错误吗?也许我可以改正自己并学到新的东西。
  • 不知道。我怀疑为什么答案会闪烁?
  • @Reddy 当答案为 -3 时,它会消失。你看到了。现在有人投了这个票,变成了-2。所以你现在不会看到这种褪色。
  • 我不知道为什么 .... 这被否决了。它至少与其他答案一样清晰且恕我直言。
【解决方案2】:

一般想一想,你就会知道 java cast/oop 的概念。

Dog 是Animal 的一种类型,因此您可以将其分配给动物。

但您不能将Animal 分配给Dog。因为它可以是任何其他动物,例如Cat。如果您确定对象是Dog,则可以将其强制转换为Animal。如果Animal 是Dog 类型,那么您不能神奇地转换为Goat。

【讨论】:

  • 请用更好的英语改进这个答案谢谢。
  • 问题不在于为什么我们不能将 Animal 分配给 Dog,而在于当我们可以将 Dog 分配给 Dog 时,为什么还要将 Dog 分配给 Animal。请再次阅读我的问题!
  • @SubhadeepBanerjee 它在我的回答中。见第 3、4 行
【解决方案3】:

让我写一些代码。

List<String> list = new ArrayList<String>;
list.doThis();
list.doThat();

哦等等..我疯了。我想使用LinkedList 而不是ArrayList

List<String> list = new LinkedList<String>;
list.doThis();
list.doThat();

是的,我只需要更改声明部分。无需触摸我的所有代码。感谢对接口和超类的编程。

【讨论】:

  • 首先List是一个接口。我的问题更局限于父类和子类。其次,如果你会使用: ArrayList list = new ArrayList();即使这样,更改也会相似(在一行,两个地方) LinkedList list = new LinkedList();它有多大的不同?
  • @SubhadeepBanerjee 这就是我在最后提到的原因。 hanks to programming to interfaces and with super classes.
  • @SubhadeepBanerjee LinkedList&lt;String&gt; list = new LinkedList&lt;String&gt;(); 您没有看到任何变化,但考虑到仅在 ArrayList 中添加的方法很少,而在 LinkedList 中不可用的方法
【解决方案4】:

当您从这样一个简单的示例开始时,您看不到任何好处,因为您已将变量与它将持有的实际对象类型紧密耦合。

多态性只有在你考虑方法声明时才会出现,其中参数是方法实现所需的最不具体的类型:然后你可以用任何子类型调用它,并且方法会知道如何处理它,即使它不知道实际的对象类型。这就是 Liskov 类型可替换性的本质。

假设你有一个方法

int getAge(Animal a) {
   return Days.toYears(currentDate() - a.dateOfBirth());
}

该方法适用于任何Animal,即使是您在定义该方法后定义的那些。


但是,如果你碰巧理解了上面的内容,那么具体地问为什么要写

Animal a = new Dog();

那么它仍然通常是有道理的:您预先承诺您不会引用该实例的任何特定于狗的方面。通常你会看到

List<String> strings = new ArrayList<>();

在这种情况下,我们知道其余代码不依赖于 ArrayList 作为列表实现的特定选择。这与上面描述的差异相比要小得多,但它结合了简洁性、安全性和定制性,使其得以坚持。

【讨论】:

  • 马尔科,我明白你在说什么。但是猫、狗、猴子等已经是 Animal 类型的子类。因此,您也可以将任何子类类型传递给该方法。那么为什么要玩弄对象引用呢?
  • 那么,你可以看到更通用的方法参数的值,但是你看不到实际声明的类型的值?您的问题不仅表述不清,而且谁在乎?它是如此迂腐,甚至不值得努力。如果您构建的应用程序在接口和实现之间有明确的分离,那么您将在任何地方使用该接口。您一直在区分父类和接口,但这是没有区别的区别。
【解决方案5】:

这将是您希望编写的代码针对 Animal 接口而不是 Dog 实现的情况。从长远来看,以这种方式创建对象会使您的代码更加健壮。

我经常使用:

List<Object> aList = new ArrayList<>();

这在定义类级别变量时很重要,因为即使您稍后更改不重要的细节,您也希望整个对象都能正常工作。

【讨论】:

    【解决方案6】:

    看问题:-

    Polymorphism in java: Why do we set parent reference to child object?
    

    在下面的方法中(工厂模式):-

    public Animal doSomething(String str){
    if(str.equals("dog")){
        return new Dog();
        }
    else if(str.equals("cat")){
        return new Cat();
        }
    else {
        return new Animal();
        }
    }
    

    你得到一个 Animal 类型和 Dog 或 Cat 的实际对象,因此如果调用的方法在基类中被重写,那么调用 Animal 的方法将调用在 Dog 或 Cat 的实际 Object 中重写的方法。它使您可以在运行时灵活地根据实际对象和基类中的重写方法(如果有)来决定运行哪个方法。

    完整的例子如下:-

    package com.test.factory;
    
    public class Animal{
        public void shout(){
            System.out.println("Parent animal's shout");
        }       
    }
    
    package com.test.factory;
    
    public class Dog extends Animal{
    
        @Override
        public void shout(){
            System.out.println("bark..");
        }
    }
    
    package com.test.factory;
    
    public class Horse extends Animal{
    
        @Override
        public void shout(){
            System.out.println("neigh");
        }
    }
    
    package com.test.factory;
    
    public class Lion extends Animal{
    
        @Override
        public void shout(){
            System.out.println("roar..");
        }
    }
    
        package com.test.factory;
    
        public class AnimalFactory {
    
            public Animal createAnimal(String str){
    
                if(str.equals("dog")){
                    return new Dog();
                    }
                else if (str.equals("horse")){
                    return new Horse();
                    }
    
                else if(str.equals("lion")){
                    return new Lion();
                    }
                else{
                    return new Animal();
                }
            }
    
        }
    
        package com.test.factory;
    
    
      package com.test.factory;
    
    
    public class Polymorphism {
        public static void main(String[] args){
    
            AnimalFactory factory = new AnimalFactory();
            Animal animal = factory.createAnimal("dog");
            animal.shout();
            animal = factory.createAnimal("lion");
            animal.shout();
            animal = factory.createAnimal("horse");
            animal.shout();
            animal = factory.createAnimal("Animal");
            animal.shout();
    
        }   
    }
    
    
        Output is :-
        bark..
        roar..
        neigh
        Parent animal's shout
    

    AnimalFactory 有一个返回 Animal 的 createAnimal 方法。因为狗、狮子和马都是动物。所以我们可以使用 Animal 返回类型来创建 Dog、Lion 和 Horse 对象。我们使用 Animal 返回类型实现的是

    Animal animal = new Dog();
    Animal animal = new Lion();
    Animal animal = new Horse();
    

    如果没有 Animal 返回类型,这是不可能的。

    如果我在 createAnimal 方法中使用作为 Dog 的返回类型,那么它不能返回 Lion 或 Horse 等等。

    【讨论】:

    • @Vicky,你能详细说明一下,使用我上面提供的代码吗?
    【解决方案7】:

    虽然有一些很好的答案(在“meh”答案中),但似乎没有一个对你来说是可以接受的。也许它们过于理论化或包含您不感兴趣的细节。所以再试一次:


    对于您描述的示例,这无关紧要。如果你真的只有两行方法,比如

    void doit()
    {
        Animal x = new Dog();
        x.shout();
    }
    

    那么你也可以写

    void doit()
    {
        Dog x = new Dog();
        x.shout();
    }
    

    而这不会有直接的劣势。


    人们甚至可以概括这种说法:对于仅在本地使用的引用,这并不重要。当您在方法中声明引用,并且仅在该方法中使用此引用,并且不将其传递给其他方法,然后将其声明为 Animal 而不是 Dog 并没有直接优势。两者都可以。

    但是……

    即使你对此不感兴趣,我也不能省略:

    ...使用父类型是最佳实践的一部分:

    你应该总是使用最不具体的类型来满足你想要做的事情

    这有各种技术原因,涉及抽象、泛化、灵活性、多态性的应用,甚至可以称之为一种“类型卫生”。

    而这个显式也是指引用只在本地使用的情况:如果不想调用Dog类型特有的方法,而只想调用Animal 类中的方法,那么您应该通过将变量声明为 Animal 来明确这一点 - 仅仅是因为这是您需要的最不具体的类型。因此,在这些情况下使用类型 Animal 有一个间接优势 - 即很明显,以下代码将仅使用 Animal 类的方法,而 none 属于Dog 类。

    这里有更多的理由、用例示例和技术细节,可以继续并走得更远。但为此,您可以参考其他答案,或者一些中级或高级教科书和教程。

    【讨论】:

      【解决方案8】:

      好的。我想我得到了答案。

      public class Polymorphism {
          public static void main(String[] args){
              Animal obj1 = new Horse();
              Horse obj2 = new Horse();
      
              obj1.shout();    //output is neigh..
              obj2.shout();    //output is neigh..
              obj1.winRaces(); /*But this is not allowed and throws compile time error, 
                                 even though the object is of Animal type.*/ 
          }   
      }
      
      class Animal{
          public void shout(){
              System.out.println("Parent animal's shout");
          }       
      }
      
      class Horse extends Animal{
          public void shout(){
              System.out.println("neigh..");
          }
          public void winRaces(){
              System.out.println("won race..");
          }
      }
      

      因此,当我们对子类对象使用父引用时,我们无法使用该对象访问子类中的任何特定方法(父类中不存在)。

      【讨论】:

      • 其实可以使用 DownCasting 访问子类中的方法。
      猜你喜欢
      • 2019-05-22
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2020-04-06
      • 1970-01-01
      • 2015-04-04
      • 1970-01-01
      • 2014-08-03
      相关资源
      最近更新 更多