Java: polymorphically call super implementation

Suppose I have this:

public class A { 
  public String foo() { return "A"; } 
}

public class B extends A { 
  public String foo() { return "B"; } 
  public String superFoo() { return super.foo(); }
}

public class C extends B { 
  public String foo() { return "C"; } 
}

Here, new C().superFoo() returns "A".
Is there a way I can polymorphically make new C().superFoo() invoke B.foo() (and hence return "B") without the need to override superFoo() in C?
I tried with reflection (redefining B.superFoo() like this: return getClass().getSuperclass().getDeclaredMethod("foo").invoke(this)), hoping that with getDeclaredMethod I could reference the exact method implementation in superclass, but I get "C" in that case (hence, polymorphism is applied).

I was searching for a solution that doesn't require me to redeclare superFoo() whenever I add a new subclass to the hierarchy.

TL;DR

Going through the question and comments, it seems like the ask here is to incrementally build up on a behavior. Taking a different perspective, I would prefer Composition over Inheritance in this scenario.

You can use Decorator pattern and compose the instances together; which in turn gives you a reference to the parent's foo() implementation. One of the other benefits is that you can extend/change the behavior at runtime, which is not possible with a static inheritance design.

About Decorator Pattern

Decorator pattern can be used to attach additional responsibilities to an object either statically or dynamically.

• Component - Interface for objects that can have responsibilities added to them dynamically.
• ConcreteComponent - Defines an object to which additional responsibilities can be added.
• Decorator - Maintains a reference to a Component object and defines an interface that conforms to Component's interface.
• Concrete Decorators - Concrete Decorators extend the functionality of the component by adding state or adding behavior.

Sample Code

Let's take a Pizza baking process as an example.

Component interface - Defines the contract that a Pizza must be baked.

public interface Pizza {
    void bake();
}

ConcreteComponent class - This is your implementation of the interface which can stand alone by itself. It should not extend the Decorator and it appears at the innermost position when the objects are composed together (see client code at the end)

public class VeggiePizza implements Pizza {
    @Override
    public void bake() {
        System.out.println("I'm a Veggie Pizza in the making :)");
    }
}

Decorator - Specifies a contract for extending the functionality of the ConcreteComponent.

public abstract class Topping implements Pizza {

    private Pizza pizza;

    public Topping(Pizza pizza) {
        this.pizza = pizza;
    }

    @Override
    public void bake() {
        pizza.bake();
    }
}

Concrete Decorator - These implementations add to the functionality of the ConcreteComponent by nesting their constructors together (one of the ways to compose!). The concrete decorator can appear anywhere while composing, except for the innermost position (see client code below).

Here we are defining two toppings - Mushroom and Jalapeno.

public class Mushroom extends Topping {

     public Mushroom(Pizza pizza) {
         super(pizza);
     }

    @Override
    public void bake() {
         addMushroom();
         super.bake();
    }

    private void addMushroom() {
         System.out.println("Adding mushrooms...");
    }
}

public class Jalapeno extends Topping {

    public Jalapeno(Pizza pizza) {
        super(pizza);
    }

    @Override
    public void bake() {
        addJalapenos();
        super.bake();
    }

    private void addJalapenos() {
        System.out.println("Adding jalapenos...");
    }

}

Client code - How do you compose the ConcreteDecorator and ConcreteComponenttogether?

public void bakePizza() {
    Pizza pizza = new Mushroom(new Jalapeno(new VeggiePizza()));
    pizza.bake();
}

Notice that we build upon the VeggiePizza by wrapping the objects around with additional behavior from Mushroom and Jalapeno. Here, the ConcreteComponent is the innermost VeggiePizza, while our ConcreteDecorators are Jalapeno and Mushroom.

Note: Constructor composition is only one of the ways to compose. You can compose object together via setters or use a Dependency Injection framework.

Output

Adding mushrooms...
Adding jalapenos...
I'm a Veggie Pizza in the making :)

Following will return B though I've omitted various safety features for the sake of brevity and used commons-lang because you don't want to have to do this stuff yourself! At a minimum, this code assumes every class defines foo() and the you never directly call a.superFoo()!

    public String superFoo() {
      return superXXX("foo");
    }

    private <T> T superXXX(String name, Object... args) {
      Method overriddenMethod = MethodUtils.getAccessibleMethod(getClass(), name);
      Iterator<Method> methods = MethodUtils.getOverrideHierarchy(overriddenMethod, EXCLUDE).iterator();
      methods.next(); // this is C
      Method parentMethod = methods.next(); // This is B;

      try {
        return (T)parentMethod.invoke(this, args);
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    }

FYI. There may well be an AspectJ/Javassist/Bytebuddy style solution possible as well whereby you can reimplement the superFoo method on all children of A to be super.foo()