Question

我可以使用java中的子类对象调用父类重写方法吗？

我试过下面的例子

class First1
 {
   void show()
    {
    String msg="You are in first class";
    System.out.println(msg);
    }
 }   
 class second extends First1  
 {  
   void show()  
   {  
   String msg="You are in second class";  
   System.out.println(msg);          }  
   }  
 }
 class CallingMethod extends second  
 {  
   void show()  
   {  
    String msg="You are in the third class";  
    System.out.println(msg);  
   }  
    public static void main(String[] args)  
    {  
    CallingMethod cm=new CallingMethod();  
    cm.show();  
    }

}

现在告诉我是否可以打印“我在二等舱”。通过使用CallingMethod类的对象，该对象在示例中为cm，并且不在任何地方使用超级关键字。

Answer 1

我假设您的意思是从子类外部调用该方法。

然后不，在java中不可能，因为覆盖方法意味着改变了对新类有意义的行为。

在课堂内部，无论如何都要使用super关键字。

注意：使用Reflection可以对对象执行操作，语言本身不允许这样做。

注意：我使用Reflection测试了它，它不起作用。但是当你使用C和JNI时，你可能会这样做......

//does not work
class YourClass
{
    public static void main(String[] args) throws SecurityException,
            NoSuchMethodException, IllegalArgumentException,
            IllegalAccessException, InvocationTargetException
    {
        CallingMethod cm = new CallingMethod();
        First1 f = new First1();
        // Method m = First1.class.getDeclaredMethod("show");
        Method m = First1.class.getMethod("show");
        m.invoke(f);
                    //output: You are in first class
        m.invoke(cm);
                    //output: You are in the third class
    }

}

Answer 2

是的，这里有一个覆盖方法的示例：

http://www.cs.umd.edu/~clin/MoreJava/Objects/overriding.html

Answer 3

只要您在子类本身内调用它，就可以使用super.overriddenMethod()。

Answer 4

也许你想要这样的东西：

class A
    method()
class B extends A
    method()
class C extends B
    method()
    {
        //call A.method()
    }

在Java中也是不可能的。您只能调用直接超类的方法。你总是需要使用

super

编辑：这就是原因：

class A
{
  private int positionA;
  void move()
  {
    positionA++;
  }
  int getPosition()
  {
    return positionA;
  }
}
class B
{
  private int positionB;

  void move()
  {
    positionB++;
  }
  int getPosition()
  {
    return positionB;
  }
}
A a = new A()
B b = new B()

如果你跑

b.move()

然后positionB递增。你可以通过调用getPosition（）得到你所期望的结果。

如果你可以运行

A.move()

上 B'/ P>

它会增加位置A.因此，对b.getPosition（）的调用不会返回正确的位置。

如果你有

Class C extends B

如果你可以打电话

，你会绕过B的移动（）

A.move()

on

this.

这与班级之外的问题相同。你的类会表现得很奇怪，这就是Java开发人员不允许它的原因。

如何使用子类对象调用超类重写方法而不使用超级关键字？

4 个答案: