5

Let's consider the following simple code in Java.

package temppkg;

interface Interface
{
    @Override
    public abstract boolean equals(java.lang.Object arg);

    @Override
    public abstract String toString();

    public void show();
}

final class Demo implements Interface
{
    public void show()
    {
        System.out.println("Method invoked.");
    }
}

final public class Main
{
    public static void main(String...args)
    {
        new Demo().show();
    }
}

In the above code snippet, the interface named Interface has some Object class methods from JDK and they are with the @Override annotation even though they are abstract. Now, the class Demo has implemented Interface and has not implemented the equals() and the toString(); methods. Still the compiler doesn't complain and the program is running successfully. Why? What is the relation between interfaces and the object class in Java?

Improve this question
1

4 Answers 4

Reset to default
8

The Java Language Specification clearly says that the members of an interface are those which are declared in the interface and those which are inherited from direct super interfaces. If an interface has no direct superinterface then the interface implicitly declares a public abstract member method corresponding to each public instance method declared in the Object class, unless a method with the same signature, same return type, and a compatible throws clause is explicitly declared by that interface. This is what makes the signatures of the Object methods available to the compiler and the code compiles without any error. Remember if the interface tries to declare a public instance method declared 'final' in the Object class then it'll result into a compile-time error. For example, 'public final Class getClass()' is a public instance method declared 'final' in the Object class and therefore if an interface tries to declare a method with this signature then the compilation will fail.

http://geekexplains.blogspot.com/2008/06/do-interfaces-really-inherit-from-class.html

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Nice explanation, can you please share the exact specification url of Oracle's official website ?
2

Check out JLS 9.2:

If an interface has no direct superinterfaces, then the interface implicitly declares a public abstract member method m with signature s, return type r, and throws clause t corresponding to each public instance method m with signature s, return type r, and throws clause t declared in Object, unless a method with the same signature, same return type, and a compatible throws clause is explicitly declared by the interface. It is a compile-time error if the interface explicitly declares such a method m in the case where m is declared to be final in Object.

In other words, every interface implicitly defines each of Object's methods, and you can therefore @Override those methods. The other methods aren't defined in Object, so you can't override them.

Improve this answer

Comments

1

In Interface you're not actually overriding anything - an interface by definition can not provide implementations for any of its methods. The class Demo just inherits the equals and toString implementation from Object.

In essence an interface in Java contains a set of zero or more method signatures (all of them are implicitly abstract, in your code you made it explicit by adding the keyword abstract), and the concrete classes that implement the interface must provide an implementation for those methods. In the case of your code, that implementation comes from Object, since all the classes implicitly extend Object, which provides default implementations for equals and toString (among other methods).

You really shouldn't mark the methods in an interface with @Override, as you have seen, it's confusing and serves for no practical purpose. Instead, use @Override in the methods in the concrete class that implement the methods of the interface, like this:

class Demo implements Interface {
    @Override
    public void show() {
        System.out.println("Method invoked.");
    }
}

Also, it's completely unnecessary to declare equals and toString in an interface, so you're better off with this definition:

interface Interface {
    public void show();
}
Improve this answer

5 Comments

An attempt to annotate other methods with @Override within an interface issues a compile-time error. How? This is the actual question.
I know that it has no practical importance but why does actually this happen?
Of course it issues a compile-time error, as I've stated in my answer, you can not provide an implementation for a method in an interface, when you mark a method with @Override you're saying that you're going to implement it
The OP is saying that it issues a compile-time error when he uses the annotation on a method not implemented by Object. But no error happens when he uses it on methods such as equals() and toString().
OK, that's weird. Maybe the compiler simply ignores those methods in an interface, given that they already exist in every object in Java
0

@Override can only be used for functions defined in the base class, Object. Object defines equals and toString, so you can use @Override with them, but not with, say, the function show. It indicates a relationship between the @Override functions in a class and its base classes, not it's derived classes.

Improve this answer

2 Comments

What's that bade class?
must be base class. I think it's a typo

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.