超类不会调用重写方法吗？

Question

I have the following classes:

class foo {
    public void a() {
        print("a");
    }
    public void b() {
        a();
    }
}

class bar extends foo {
    public void a() {
        print("overwritten a");
    }
}

When I now call bar.b() I want it to call the overridden method a() in foo. It does, however, print "a".

Answer 1

Are your two classes in different packages? And is your foo class methods declared public, protected, or private or package local? Obviously if they are private, this won't work. Perhaps less obvious, is if they are package local (ie no public/protected/private scope) then you can only override them if you are in the same package as the original class.

For example:

package original;
public class Foo {
  void a() { System.out.println("A"); }
  public void b() { a(); }
}

package another;
public class Bar extends original.Foo {
  void a() { System.out.println("Overwritten A"); }
}

package another;
public class Program {
  public static void main(String[] args) {
    Bar bar = new Bar();
    bar.b();
  }
}

In this case, you will still get 'A'. If you declare the original a() method in Foo public or protected, you will get the result you expected.

Answer 2

It may be that you are trying to use static methods, which won't work as they don't get overridden.

A good way of checking is to add the @Override annotation to bar.a() and see if the compiler gives you an error that a() isn't actually overidding anything

Answer 3

When I run the following:

public class Program {
    public static void main(String[] args) {
        bar b = new bar();
        b.b();
    }
}

class foo {
    public void a() {
       System.out.printf("a");
    }
    public void b() {
        a();
    }
}

class bar extends foo {
    public void a() {
        System.out.printf("overwritten a");
    }
}

I get the following output:

overwritten a

which is what I would expect to see.

Answer 4

Are the methods defined as static? That's the only way I could see getting that result. I found a good explanation about that here: http://faq.javaranch.com/view?OverridingVsHiding

Answer 5

From the horse's mouth:

http://download.oracle.com/javase/tutorial/java/IandI/override.html

"The version of the overridden method that gets invoked is the one in the subclass. The version of the hidden method that gets invoked depends on whether it is invoked from the superclass or the subclass."

So if they are both static methods and you invoke the method from the super class, then the super class method is invoked, not the subclass method. So really, no overriding is taking place.

Answer 6

You may be confused if you are coming from C# or some other language where you have to explicitly declare virtual functions and/or overriding functions.

In Java, all instance functions are virtual, and can be overridden -- unless they are declared as private and/or final.

It is not necessary to specify the new @Override annotation to do so, adding the annotation just specifies that your intent is to override, and will cause a either a warning or error if it isn't an override. (If you accidentally misspelled the method name for example).

Andrew's example shows how this should work.

Answer 7

While I was working on an Android program, I had the same problem on my Java classes. It turned out that the problem was not in the classes but the way Android framework processes screen output.

for example if output was programmed in the onCreate() method in the parent class, Android failed to correctly fetch the output of overridden methods from child classes beyond first child. Honestly I don't understand whole method calling order.

To resolve the issue I simply programmed the output in the onResume() and now it seem to work fine.