Question

 interface A { public void m1(); }
 **//Gives error**
   class D implements A { public void m1(int x) { } }
 **//this doen't** 
 abstract class G implements A { public void m1(int x) { } }

I have a doubt that why abstract class is able to override and class D can’t

If I see the second case

 class X1
{
 public void f2(){}
 }

class X2 extends X1
 {**//No error**
  public void f2(int x){}
}

why public void m1() is not getting overidden in class D whereas same type of method f2() is getting overriden in class X2
In both cases we are overidding but why in interface case class D cant and in second case class X2 can override.

Answer 1

When there are two methods with the same name but different parameter types (or counts), that’s overloading, not overriding.

• D doesn’t implement A itself because it doesn’t provide an implementation of m1() – no parameters. It tries to provide a method m1(int), but that doesn’t help to implement the interface – so it won’t compile (as it’s not an abstract class). It could provide both methods of course.
• X1 provides a method f2(), and X2 extends X1 and adds a new overload f2(int) – but it doesn’t override the method provided by X1.

In particular, if you write:

X2 x2 = new X2();
x2.f2(10); // Calls X2.f2(int)
x2.f2(); // Calls X1.f2()

Using the @Override annotation makes all of this clearer:

class X1
{
     public void f2(){}
}

class X2 extends X1
{
     @Override public void f2(int x){}
}

This now gives an error:

error: method does not override or implement a method from a super type
     @Override public void f2(int x){}
     ^
1 error