Question

运行时多态性与静态多态性有何不同？

这可以是运行时多态性的一个例子吗？

public class X
{
    public void methodA() // Base class method
    {
        System.out.println ("hello, I'm methodA of class X");
    }
}

public class Y extends X
{
    public void methodA() // Derived Class method
    {
        System.out.println ("hello, I'm methodA of class Y");
    }
}
public class Z
{
   public static void main (String args []) {
       X obj1 = new X(); // Reference and object X
       X obj2 = new Y(); // X reference but Y object
       obj1.methodA();
       obj2.methodA();
   }
}

代码已从here

中挑选出来

Answer 1

是的，这是Java中的Runtime polymorphism

在static polymorphism中，编译器本身确定应该调用哪个方法。 Method overloading是静态多态的一个例子。

在runtime polymorphism中，编译器无法在编译时确定方法。 Method overriding（作为您的示例）是runtime polymorphism的示例。因为在Runtime polymorphism（作为示例）中，methodA()的签名在类X(base class)和Y(child class)中都相似。因此编译器无法在编译时确定应该执行的方法。只有在创建对象（运行时进程）之后，运行时环境才能理解要调用的确切方法。

正是因为这种情况，obj1.methodA()在methodA()中调用Class X，因为obj1是为class X创建的对象的引用变量

和 obj2.methodA()在methodA()中调用了Class Y，因为obj2是为class Y创建的对象的引用变量

Answer 2

为了更好地理解我已经尝试过调制你的代码。请注意对这两个类的构造函数的调用。

class X
{
    X(){
        System.out.println("X constructor called");
    }
    public void methodA() //Base class method
    {
        System.out.println ("hello, I'm methodA of class X");
    }
}

class Y extends X
{
    Y(){
         System.out.println("Y constructor called");
    }

    public void methodA() //Derived Class method
    {
        System.out.println ("hello, I'm methodA of class Y");
    }
}

public class Z
{
   public static void main (String args []) {
       X obj1 = new X(); // Reference and object X
       X obj2 = new Y(); // X reference but Y object
       obj1.methodA();
       obj2.methodA();
   }
}

输出： -

X构造函数名为

X构造函数名为

Y构造函数名为

你好，我是X类的方法A

你好，我是Y类的方法A

仔细查看对象的创建位置。看来X的引用是用y创建的。期望调用X的方法，但是用于X引用创建的Y的构造函数调用间接地说明在创建X的引用之前已将内存分配给Y的Object。看一下控制台的说明。

Answer 3

它的运行时多态性，因为编译器在运行时不知道要调用哪个对象方法。

然而，以下行将为您提供强制转换异常：

Y obj1 = new X（）; //方式不正确

X obj1 = new Y（）; //正确的方式

现在obj1.methodA（）在类Y中调用methodA（），因为obj1是为类Y创建的对象的引用变量

Answer 4

是的，您的示例是运行时多态性的示例。静态多态的一个例子是方法重载。以下是一些很好的例子： What is the difference between dynamic and static polymorphism in Java?

干杯，

马库斯

Answer 5

我对main方法进行了如下更改：

public class X
{
    public void methodA() // Base class method
    {
        System.out.println ("hello, I'm methodA of class X");
    }
}

public class Y extends X
{
    public void methodA() // Derived Class method
    {
        System.out.println ("hello, I'm methodA of class Y");
    }
}
public class Z
{
public static void main (String args []) {

    //this takes input from the user during runtime
    System.out.println("Enter x or y");
    Scanner scanner = new Scanner(System.in);
    String value= scanner.nextLine();

    if(value.equals("x"))
        X obj1 = new X(); // Reference and object X
    else if(value.equals("y"))
        X obj2 = new Y(); // X reference but Y object
    else
        System.out.println("Invalid param value");

    obj1.methodA();
    obj2.methodA();
}
}

现在，看着代码，您永远无法知道将调用哪个方法。因为这取决于用户在运行时提供的值。因此，仅在运行时决定将调用哪种方法。因此，运行时多态性。

Java中运行时多态的示例？

5 个答案: