Java OOP – Override Method with Subclass as Argument

designjavaobject-oriented-design

When you want an overrided method to take as argument a subclass of the argument of the overridden method, you usualy accomplish that with generics (as discussed in Template pattern with varying input type in overridden method). An example of that can be seen in my methodA of the class Parent and Child

I am wondering if it is possible to do the same thing with a method that takes as argument an object of the class itself (my methodB)

abstract class Super {}

class Sub extends Super {}

abstract class Parent<S extends Super> {
    abstract void methodA(S argument);
    abstract void methodB(Parent<S> parent);
}

public class Child extends Parent<Sub> {
    @Override
    void methodA(Sub argument) {}

    @Override
    void methodB(Child child) {}
}

In the code above methodB in Child does not override methodB from Parent.

I could of course use casting in methodB from Child as in:

public class Child extends Parent<Sub> {
    @Override
    void methodB(Parent<Sub> child) {
        (Child) child
    }
}

But as a general rule I try to avoid casting as much as possible.

Is it possible to have an overrided methodB in Child (with signature @Override void methodB(Child child))? If so, what would the signature of methodB (in Parent) look like?

Best Answer

Let's assume what you want was possible. Let's make another child class:

public class Child2 extends Parent<Sub> {
    @Override
    void methodA(Sub argument) {}

    @Override
    void methodB(Child2 child) {}
}

Now, what if I have this:

Parent<Sub> child = new Child();
Parent<Sub> child2 = new Child2();
child.methodB(child2);

The child is a pointer of type Parent<Sub>, so it's methodB is expecting an argument of type Parent<Sub> - which is OK because child2 is also a pointer of type Parent<Sub>. But the object child refers to is of type Child, which it's methodB only accepts argument of type Child - and child2 is pointing to an object of type Child2 - which is not a subclass of Child...

Related Solutions

Java Inheritance – Enforcing Implementation of Superclass Public Methods

First thing to understand here is that this part of requirements: super.methodA() means this applies to the code of the classes extending A, in a way defined in JLS 15.12.4.4-2. Method Invocation Using super

An overridden instance method of a superclass may be accessed by using the keyword super to access the members of the immediate superclass, bypassing any overriding declaration in the class that contains the method invocation...

Let's say, we want a way to create some specific subclasses of A such that whenever super.methodA() is invoked in these, we are guaranteed that instead of code that was in class A (out of our control) it will run some other code, defined in some subclass of A (under our control).

Let's see what "tools" are at our disposal to achieve above.

Need to create some, specific subclasses of A brings to mind traditional way to specialize - subclassing, that is we'll consider subclass of A (let's call it B) that would redefine (override) methodA in the way we want.
Need to force a subclass to provide a code that would run where we want it in superclass can be satisfied by defining an abstract method, let's call it forcedImplementationInSubclass()

Now we've got all what we need.

We will define a class B extending A, so that all subclasses of B will also be subclasses of A.
In B, we will override methodA, so that its implementation in class A won't be available to subclasses of B anymore.
In overridden method in B we will invoke abstract method forcedImplementationInSubclass() which will guarantee that subclasses of B will have to define the code that will eventually run in methodA.

As a result, any subclass of B won't be able to invoke methodA implementation provided in class A and instead, will be guaranteed to run code defined in some subclass of B.

Extending B is the way to create specific subclasses of A that behave as we want. The code could look about as follows:

public abstract class B extends A {
    // override, so that subclasses of B won't be able to get to super.methodA
    @Override public void methodA() {
        // invoke abstract method here (subclass would have to implement it)
        forcedImplementationInSubclass();
    }

    // define abstract method so that subclass would have to implement it
    protected abstract void forcedImplementationInSubclass();
}

// extending B is the way to get what we need
public class C extends B {
    // enforced implementation of the abstract method
    @Override protected void forcedImplementationInSubclass() {
        // that will be invoked when B.methodA() is called, and since B is-a A...
        System.out.print("Hello from implemented methodA");
    }

    public void testSuperMethodA() {
        // that will invoke B.methodA() which won't go to class A
        super.methodA();
    }

    public static void main(String[] args) {
        A a = new C();
        a.methodA(); // goes to B.methodA(), which in turn invokes C.forcedImplementationInSubclass()
        C c = new C();
        c.testSuperMethodA(); // won't go to class A
    }
}

Java Inheritance – Is Code from Superclass Copied or Referred to by Subclass?

Option 2.

The bytecode is referenced dynamically at runtime: this is why, for example, LinkageErrors occur.

For example, assume you compile two classes:

public class Parent {
  public void doSomething(String x) { ... }
}

public class Child extends Parent {
  @Override
  public void doSomething(String x) {
    super.doSomething(x);
    ...
  }
}

Now modify and recompile the parent class without modifying or recompiling the child class:

public class Parent {
  public void doSomething(Collection<?> x) { ... }
}

Finally, run a program that uses the child class. You will receive a NoSuchMethodError:

Thrown if an application tries to call a specified method of a class (either static or instance), and that class no longer has a definition of that method.

Normally, this error is caught by the compiler; this error can only occur at run time if the definition of a class has incompatibly changed.

Best Answer

Related Solutions

Java Inheritance – Enforcing Implementation of Superclass Public Methods

Java Inheritance – Is Code from Superclass Copied or Referred to by Subclass?

Related Topic