Question

我对多态性感到困惑，我想知道这是否考虑了多态性？

我觉得它看起来很奇怪，但它仍能正确编译。

public class Family {
    void FamilyInfo() {
        System.out.println("This is a family super class");
    }
}

public class Grandparents extends Family {
    void FamilyInfo() {
        System.out.println("Graparents are the elders in the family and they are the sub class of family");
    }
}

public class Parents extends Grandparents {
    void FamilyInfo() {
        System.out.println("The parents are the children of the grandparents and they are the sub sub class for family");
    }
}

public class FamilyDemo {
    public static void main(String ary[]) {
        Grandparents Gp = new Grandparents();
        Parents P1 = new Parents();


        Gp.FamilyInfo();
        P1.FamilyInfo();

    }
}

Answer 1

您的方法FamilyInfo正在层次结构中的所有三个类中被覆盖。这是polymorphism的一个例子。

当您致电Gp.FamilyInfo();时：它将调用Grandparents班级中实施的方法并打印Graparents are the elders in the family and they are the sub class of family，而P1.FamilyInfo();将调用Parents班级中的方法，打印The parents are the children of the grandparents and they are the sub sub class for family。

因此，您可以看到同一方法FamilyInfo()有两种不同的行为，即多态行为。

您的示例与本教程中提到的示例非常相似：Java Tutorial : Polymorphism。所以不要混淆。

Answer 2

该示例未演示多态，而是我可以看到简单的面向对象的继承。为了使用多态的概念，代码应该如下。

public class FamilyDemo 
{
    public static void main(String ary[]) 
    {
        Family Gp = new Grandparents();
        Family P1 = new Parents();

        Gp.FamilyInfo();
        P1.FamilyInfo();
    }
}

即使Gp属于Family类型，它的行为类似于Grandparents类型，因为它是使用该类型的对象初始化的。

然后，可能会出现以下情况：祖父母是家庭中的长者，他们是家庭的子类。父母是祖父母的子女，他们是家庭的子类。

Answer 3

我们的培训师说使用extends更多是继承的一个例子。但是如果我们使用implements（接口），我们可以说它是多态的，因为我们可以实现很多接口。

e.g。

interface Horse {
    void run();
}

interface Eagle {
    void fly();
}

public class Pegasus implements Horse, Eagle {
    // Implement methods
     public void run() {
         // do run
     }
     public void fly() {
         // do fly
     }
 }

Answer 4

polymorphism的一个好例子是：

public static void print(Family[] family){
    for(int i=0; i< family.length; i++){
        family[i].FamilyInfo();
    }
}

public static void main(String args[])
{
    Family[] family = new Family[2];
    Grandparents Gp = new Grandparents();
    Parents P1 = new Parents();
    family[0] = Gp;
    family[1] = P1;

    //and then send the array to another method which 
    //doesn't "know" which entry in the array is a parent and which is grandparent
    //and there you can loop the array calling family[i].FamilyInfo();
    //THIS is the whole idea of polymorphism in a nutshell
    print(family);

}

Answer 5

多态的字典定义是指一个原则生物体或物种可以有许多不同形式的生物学或阶段

基本概念是让一个给定的对象像另一个一样行事。这是通过在Java中使用接口和继承来实现的。

更好的例子是（以你的代码为基础）

public class FamilyDemo {
    public static void main(String ary[]) {
        Family gp = new Grandparents();
        Family p1 = new Parents();

        dump(gp);
        dump(p1);
    }

    public static void dump(Family family) {
        family.FamilyInfo();
    }
}

这基本上允许Gradparents和Parents“行动”，因为它们是Family

Answer 6

1.什么是多态？

在面向对象的编程中，多态性（来自希腊语意为“具有多种形式”）是能够在不同的上下文中为某些东西分配不同的含义或用法的特征 - 特别是允许诸如变量之类的实体，函数或具有多个表单的对象。

<强> 2。两种多态性

a）静态或编译时多态性

要调用哪个方法仅在编译时决定。方法重载就是一个例子。例如

public class calculation
{
    public int add(int x, int y)
    {
        return x + y;
    }
    public int add(int x, int y, int z)
    {
        return x + y + z;
    }
}

在这里你可以看到有两个具有相同名称但签名不同的功能

b）动态或运行时多态性。

运行时多态性也称为方法覆盖。在此机制中，如果基类包含被覆盖的方法，则在运行时（而不是在编译时）解析对重写函数的调用。

Class BaseClass
{
Public void show ()
{ 
Console.WriteLine("From base class show method");
}
}
Public Class DynamicDemo : BaseClass
{
Public void show()
{
Console.WriteLine("From Derived Class show method");
}
Public static void main(String args[])
{
DynamicDemo dpd=new DynamicDemo ();
Dpd.show();

}
}

Answer 7

从技术上讲，这是多态性。但是，你选择了一个糟糕的例子，似乎你并不完全理解多态性背后的想法。一个更好的例子是这样的。

public abstract class Shape {
  public abstract void drawShape();
}

public class Rectangle extends Shape {
  public void drawShape() {
    // code for drawing rectangle
  }
}

public class Circle extends Shape {
  public void drawShape() {
    // code for drawing circle
  }
}

public class FilledRectangle extends Rectangle {
  public void drawShape() {
    super.drawShape();
    // code for filling rectangle
  }
}

然后，负责绘图的类不需要知道如何绘制每个单独的形状。相反，它可以做到这一点

public void drawAllShapes(Shape[] myShapes) {
  for (int i = 0; i < myShapes.length; ++i) {
    myShapes[i].drawShape();
  }
}

目标是抽象出具体实现和所有细节，而只是提供一个通用接口。这使得使用不同的类更加容易，正如您在上面的上一个方法中所看到的那样。

Answer 8

是的，在您的示例程序中，您使用的是inherit和polimorphism，事实上两者都是封闭相关的。

您正在使用继承，因为您从祖父母班级延伸一次家庭，并且一旦父母班级延长祖父母并且您也使用 polimorphism ，因为您在子类中写作a方法void FamilyInfo，它写在超类中。

您应该以这种方式使用@Override：

public class Parents extends Grandparents {
    @Override
    void FamilyInfo() {
        System.out.println("The parents are the children of the grandparents and they are the sub sub class for family");
    }
}

这是考虑多态吗？

8 个答案: