Overridding Sufficient for Polymorphism?

Question

All,
This is probably an elementary question; however, as I never had a formal CS education, I was wondering what the actual, correct answer is.
Would overridding a concrete (implemented) method in a superclass within a subclass constitute (or provide) polymorphism? In Java code:
class FooAncestor {
   public void bar() { };
class FooDescendant extends FooAncestor {
   public void bar() { super.bar() };
}Has the 'bar()' method become polymorphic? My understanding is that a combination of inheritance (either interface or class) and the implementation of an abstract method (either interface or abstract class) gives you polymorphism.
However, is the requirement that the method overridden (or implemented) be abstract a valid requirement to have polymorphism. Or is overridding alone sufficient for polymorphism?
Thanks!
- Saish

Answer 1

> Would overridding a concrete (implemented) method in
a superclass within a subclass constitute (or
provide) polymorphism?
I think yes, it would. Personally, I consider not only the implemented method in the subclass(es) a demonstration of polymorphism, but the implemented method in a superclass, too! Because the principle of polymorphism means that if you execute a method of an object, you are not able to know exactly which behaviour this method will have (the method can have many forms, many behaviours), but you can be sure that the behaviour is always correct, is always what you expect. I think this definition makes sense even considering the method in a superclass.
Just to clarify more:
class ParentClass {
  public void method() {
    System.out.println("in ParentClass");
class ChildClassOne extends ParentClass {
  public void method() {
    System.out.println("in ChildClassOne");
class ChildClassTwo extends ParentClass {
  public void method() {
    System.out.println("in ChildClassTwo");
public class TheClass {
  public static void main(String[] args) {
    ParentClass objParent = new ParentClass();
    ParentClass objChildOne = new ChildClassOne();
    ParentClass objChildTwo = new ChildClassTwo();
    ParentClass[] theArray = new ParentClass[3];
    theArray[1] = objParent;
    theArray[2] = objChildOne;
    theArray[3] = objChildTwo;
    for (int i=0; i<theArray.length ; i++) {
      //You know that this array contains
      //ParentClass objects,
      //but you are not able to know
      //exactly which method will be executed.
      //Notice that even the method in the ParentClass
      //is one of the methods that you don�t know.
      //This is the demonstration of polymorphism.
      theArray.method();
[i]> Has the 'bar()' method become polymorphic?
Yes, it has.
> My understanding is that a combination of inheritance
(either interface or class) and the implementation of
an abstract method (either interface or abstract
class) gives you polymorphism.
My example shows that non-abstract methods implemented in the subclasses can demonstrate polymorphism. And even the implemented method itself in the superclass, can be considered when you want to demonstrate polymorphism. Therefore, this is a clear proof that the method doesn�t need to be abstract.
> Or is overridding
alone sufficient for polymorphism?
Yes, overriding alone is sufficient for that.