Alternative to overriding with different arguments in java (which is impossible)

Question

Hi I am facing a design problem which I think it should be quite common:

public abstract class Parent
{
    ...

   public boolean itsOk()
   {
       return true;
   }
   public void execute()      
   { 
       if (itsOk()){
          System.out.println("done");
       }
   }
}

I need to be able to override itsOK() function in any subclass inherited from 'Parent' even if arguments are different.

public class Example extends Parent
{
    public boolean itsOK(int a)
    {
       if (a==1)      return true;
       else           return false;
    }

}

Then when I call execute, I want the subclass' itsOk() method to be invoked.

public static void main(String[] args) {
    Example e=new Example();
    e.execute();
}

This works ok if the subclass' itsOk() method has no arguments (like the 'Parent's method), so it's an overriding case, but how can I make it when arguments are different?

Related question: http://stackoverflow.com/questions/5562051/how-to-provide-a-plug-in-model-where-different-plug-ins-take-different-parameters — WW., May 25 '11 at 12:24
I know overriding does not work with different arguments, I am just asking for a way to do it. I need a way to ensure that whenever a subclass extends my Parent class, execute() will call the subclass' itsOk() method instead of the parent's, even if that method has different arguments, unless 'itsOK()' is not defined in the subclass, in that case the parent's method will be invoked. If that's impossible, I just will pass an array of strings as an argument (so that array can be empty and also can have variable length) — de3, May 25 '11 at 12:27
In your example call of `execute()`: If it would work that way and the child `itsOK()` gets called, what should happen with its parameter `int a`? — Robert, Oct 17 '14 at 18:33

Mac · Answer 1 · 2011-05-25T12:18:44.463

Call super.itsOk(); in your subclass' itsOk method.

That is, I'm assuming what you mean is you want to have an overload of itsOk defined in your subclass which does something new but also invokes the parent class' default implementation of itsOk.

As an aside, note the terminology: you're not overriding: to do that, the itsOk in your subclass must have the same method signature as in the parent class. Instead you're overloading creating a brand new method that just happens to have the same name.

Yochai Timmer · Answer 2 · 2011-05-25T12:28:40.673

2

You can use generics:

public abstract class Parent
{
    ...

   public <T> boolean itsOk(T t)
   {
       return true;
   }
   public void execute()      
   { 
       if (itsOk()){
          System.out.println("done");
       }
   }
}

public class Example extends Parent<Integer>
{
    public boolean itsOK(Integer a)
    {
       if (a==1)      return true;
       else           return false;
    }

}

edited May 25 '11 at 12:28

answered May 25 '11 at 12:15

Yochai Timmer

48,127
24
147
185

The idea is ok, but this is not going to work. `Example` should extend `Parent` instead of raw `Parent`, but you can't use primitive types such as `int` to fill in type parameters in Java. You should use `Integer` in that case. Also the `itsOk()` call in `Parent` wouldn't automatically call the `itsOk` that takes an argument. – Jesper May 25 '11 at 12:17

score 1 · Accepted Answer · answered May 25 '11 at 12:27

In such a case I would rather try to have the same method signature in the parent and the child class, ie. a real overwriting and not an overloading. Then, your parameter a could be a member of the class Example which would avoid the need for a parameter. Of course it strongly depends on the rest of the code.

score 0 · Answer 4 · answered May 25 '11 at 12:13

The itsOk(int a) method in class Example is not overriding the itsOk() method in class Parent - it is an entirely separate method that doesn't have anything to do with the method in class Parent.

With what value of a do you want itsOk(int a) in Example to be called when you call itsOk() in Parent?

You could ofcourse add an itsOk(int a) method to class Parent; then the version in Example would be overriding that version, and in the execute() method you could call it:

public abstract class Parent {
    public boolean itsOk() {
        return true;
    }

    public abstract boolean itsOk(int a);

    public void execute() {
        if (itsOk(0)) {
            System.out.println("done");
        }
    }
}

Without declaring an itsOk(int a) method in class Parent, you cannot call that method on a Parent object (or on an Example object, if the type of the variable referring to the object is Parent).

I don't think this is a common design problem.

score 0 · Answer 5 · answered May 25 '11 at 12:14

0

When arguments are different it no longer is a case of Overriding. It is called Overloading which basically means that you have two distinct methods to call.

answered May 25 '11 at 12:14

d-live

7,926
3
22
16

Alternative to overriding with different arguments in java (which is impossible)

5 Answers5

Linked