0

我在 A 类中创建了两个方法，在 B 类中被覆盖，如下所示。我有一些与动态多态性和覆盖有关的问题。

这是我的代码，其中 B 类扩展了 A 类。

public class A {


    public void methoda()
    {
        System.out.println("a");
    }
    public void methodb()
    {
        System.out.println("aaa");
    }
    public static void main(String[] args) {
    B a =new B();
    A b=a;
    b.methoda();


    }

}

public class B extends A{
@overrides
public void methoda()
{
    System.out.println("A");
}
@overrides
public void methodb()
{
    System.out.println("g");
}
}

在这里，我重写了两个方法，当使用超类引用时，调用的方法取决于在运行时确定的对象类型，并且是动态多态性的一个示例。

但是，如果我对子类对象使用子类引用并覆盖该方法，那么被覆盖的对象将在运行时得到解决，并且是动态多态性的一种情况，或者仅在编译时解决，因为对象类型和引用是相同的类型并且不会保持动态多态的情况？

重写和动态多态性总是同时发生吗？

4

5 回答 5

3

我不确定我是否理解这个问题，但多态方法总是在运行时解决。执行的方法是对象的具体运行时类型之一。引用它的变量的声明类型无关紧要。

狮子就是狮子，它总是会咆哮，即使你把它称为动物。

于 2013-02-16T13:41:33.513 回答
1

First, (subtype) polymorphism is always dynamic(i.e. at runtime), so "dynamic" modifier is redundant, unless it's used to distinguish from ad-hoc polymorphism or parametric polymorphism.

Second, @Override(not @overrides) annotation isn't mandatory(in fact it's only introduced by Java 5.0), although it's recommended for more readable(explicitly shows the overridden method) and more robust(compiler will check the misspelt methods) code.

In a word, method overriding is an OOP language's key feature, and annotation @Override is checked at compile-time, while polymorphic behavior is resolved at runtime.

于 2013-02-16T13:45:41.540 回答
0

如果您使用对子类对象的子类引用，则无需覆盖。仅当基类的指针指向其子类之一的对象并且此指针调用基类的方法时才会发生覆盖。但是实际执行的方法是子类的方法。

于 2013-11-06T08:35:00.587 回答
0

是否通过子类引用都没关系。重要的是创建的实例。如果您的实例是从 B 创建的，您将获得 B 的结果。

于 2013-02-16T13:40:30.063 回答
0 
class Bike {  
   void run() {
      System.out.println("running");
   }  
}  

class Splender extends Bike {  
   void run() {
      System.out.println("Bike is running");
   }  

   public static void main(String args[]) {

      Bike a = new Bike();
      a.run(); //output: running

      Bike b = new Splender();  
      b.run(); //output: Bike is running 
   }  
}

这里超类（自行车）引用指向子类对象。该对象是在运行时而不是在编译时创建的。不管是不是，

1) 引用变量和对象类型相同或

2）引用变量是超类类型，对象是子类类型。

在上面的示例中，编译器无法确定对象类型，因为 Splender 的实例也是 Bike 的实例。JVM 在运行时根据创建的对象类型调用该方法。这两种情况都是动态多态性而不是编译时多态性。

于 2016-01-27T07:30:25.337 回答