Wider argument types of overridding method in Java

Question

What OO principle is broken by the following code ? Not Java OO principle but general OO principle.

class GeneralArg{}
class Arg extends GeneralArg{}

class A{
    public void test(Arg a){}
}

class B extends A{
    @Override
    public void test(GeneralArg a){}
}

I think this should work!

However there is a compile error saying that B.test() doesn't override A.test()

Answer 1

No, it should not!

By annotating method with Override you say it overrides something but it does not.

In Java, methods are resolved and bound at the compile time. This means that declared type of argument is checked and one method is chosen. Inheritance of argument types is not important at this point.

Answer 2

Statement 1: Every GeneralArg is not an Arg.

Base definition of test says: test() takes an Arg as input.

B's definition says: the same test() should take GeneralArg as input. But given Statement 1, this is can't be true.

@Override says that you are overriding the base class's definition.

In summary, A.test() and B.test() are not same methods(different signatures) and hence one cannot override another.

Answer 3

What you are doing is not overriding but overloading.

You overload a method when you change the parameter list. You override a method when you change it implementation.

    public class Foo {

       public void method1() {        
       }

       public void method1(String str) {
       //We overload method1
       }

    }

    public class Bar extends Foo {

       public void method1(String str) {
           // We override method1 here
       }

       public void method1(Number num) {
           // We overload method1 here 
       }
  }

Note, that annotation is not mandatory it only inform the compiler that you have override some method to prevent potential faults.

Concluding when you in child class declare method with the same [signature] you override it, when you add/remove switch parameter order you overload. This rule obey to Java world as every not final method is virtual an can be overridden.

Answer 4

It is not a violation of any OO principle. It just changes the method signature, which is the exactly the one thing a method is identified by. Thus, the compiler does not realize that your intention is to widen the argument type of the super-method.

The Liskov Substitution Principle allows what you want to do, Java just doesn't support it this way.