Which method is overridden?

Question

Class A has run() method and interface B also has run() method. Question is simple, which run() method is overridden in Main class and how will we prove this? Why there is no conflict (Compile-time error) in this code?

class A{
    void run(){System.out.println("A class");}
}

interface B{
    void run();
}

class Main extends A implements B{
    public static void main(String args[]){         
        Main m = new Main();
        m.run();
    }

    // Overridding method
    public void run(){
        System.out.println("run method");
    }
}

very curiously waiting for some expert answer – Hussain Akhtar Wahid 'Ghouri' Mar 12 '14 at 07:56 — Hussain Akhtar Wahid 'Ghouri', Mar 12 '14 at 07:56

score 25 · Accepted Answer · answered Mar 12 '14 at 07:46

25

run of A is overridden, run of B is implemented. As B is an interface, it only states how your objects behave to others and don't enforce any behavior itself.

answered Mar 12 '14 at 07:46

Smutje

17,733
4
24
41

1

so basicly `run` in `Main` that overrides `run` in `A` will meanwhile implement `run` of `B` ? – mangusta Mar 12 '14 at 07:48
Yes. Anyone using `Main` can see by the interface `B` that `Main` will provide a method `run` - how this method is implemented, if it is inherited from a base class or implemented by `Main` itself is not relevant to users of `Main`. – Smutje Mar 12 '14 at 07:51

Not a bug · Answer 2 · 2014-03-12T12:39:52.463

run() Method of Interface B will be Implemented in class Main by overridden method of Class A.

Adding an extra point,

It you will not write the run() method in child class Main, You will not get well known "Unimplemented methods" error. This is true for public methods of class A for non public methods you will get compiler error : The inherited method can not hide public abstract method.

That is because methods of interface are public by default and you can not hide it with default (package private) access modifier.

Sample :

class A{
    public void run() {
        System.out.println("This method will be inherited.");
    }
}

interface B{
    void run();
}

class Main extends A implements B{
    public static void main(String args[]){         
        Main m = new Main();
        m.run();
    }
}

OUTPUT : This method will be inherited.

In above code instance, the run() method is inherited from class A that will implement run() method of interface B.

score 2 · Answer 3 · edited Mar 12 '14 at 14:03

2

There is no conflict because both methods have the same signature. Method declarations in interfaces are not overridden because they don't implement anything. So in this case, run method in class A is overridden.

On the other hand, when overriding methods you are encouraged to use the @Override annotation, e.g.

@Override
public void run() {
   ....
}

edited Mar 12 '14 at 14:03

Philip Allgaier

3,505
2
26
53

answered Mar 12 '14 at 07:49

xea

1,204
12
23

2

You are encouraged to use `@Override` when implementing interface methods as well. – Chris Hayes Mar 12 '14 at 08:15

score 2 · Answer 4 · answered Mar 12 '14 at 07:50

What will be called is

public void run(){
    System.out.println("run method");
}

Why?

You're implementing run of interface B and you're also overriding the A implementation of it.

If you remove the last run() implementation and remove implements B, run() of A will be called.

leigero · Answer 5 · 2014-03-12T07:56:55.557

Interface B says that any class implementing it must have a run method. Main extends A and inherits A's run() method.

Main meets the requirement of the B interface for having a run method. The run method in Main then overrides the run() method it got from the A class.

// This is a class with a run method.
class A{
    void run(){System.out.println("A class");}
}

// Anything implementing this interface must have a run method.
interface B{
    void run();
}

// This class is an extension of A (and therefore has A's run() method)
// This class implements B and must have a run method, which it does, because it has A's
class Main extends A implements B{
    public static void main(String args[]){         
        Main m = new Main();
        m.run();
    }

    // This method then overrides the run Method it inherited from A
    // And this method meets the requirement set by implementing B.
    public void run(){
        System.out.println("run method");
    }
}

this explains why there is no compilation error , still a better explanation expected — Hussain Akhtar Wahid 'Ghouri', Mar 12 '14 at 07:54

score 0 · Answer 6 · answered Mar 12 '14 at 13:27

Super class's method is always called as overridden method whereas subclass method is called as overriding method.

Final method cannot be overridden. [if superclass's method is final]
Final methods can override. [Read it as grammatical way. This method is in subclass and is final, but superclass's method is not final]

Which method is overridden?

6 Answers6