Does interface in java extends object class internally?

As you can see the below code where we can override equals method from an object class:

@FunctionalInterface
interface abc
{
    void meth1();
    default void meth2(){
    };
    boolean equals(Object obj);
}

So according to the above code does interface in Java extends object class internally?

> So accroding to the above code does interface in java extends object class internally?

No. interfaces cannot extend classes at all, and java.lang.Object is a class, not an interface.

> As you can see the below code where we can override equals method from an object class.

The Java Language Specification explicitly calls out that any interface is considered a functional interface if you follow this list of steps:

• remove any signatures in it, defaulted or not, that match precisely anything defined in java.lang.Object.
• remove anything that has a default implementation.
• Disregard inner types and fields.

Are you left with precisely one method definition?

Then it is a functional interface. @FunctionalInterface isn't required; that is merely compiler-checkable documentation, which causes the compiler to error out if the interface does not fit the above requirements. (It's a: Do nothing if all is well, fail to compile otherwise).

The fact that you disregard all methods that j.l.Object already defines is part of the JLS - it isn't some internal 'oh it extends object'. No, the code in javac explicitly checks.

> "... So according to the above code does interface in Java extends object class internally?"

Contrary to everyone's responses, I believe I did read this somewhere.
Although, this doesn't mean they are wrong—it depends on what you mean by "internally".

Here is the Java Language Specification entry.

Java Language Specification – 4.3.1. Objects.

> "An object is a class instance or an array. ...
>
> ... A class instance is explicitly created by a class instance creation expression (§15.9)."

So, in terms of a "class instance creation expression", from 15.9,

> "ClassInstanceCreationExpression:
>   UnqualifiedClassInstanceCreationExpression
>   ExpressionName . UnqualifiedClassInstanceCreationExpression
>   Primary . UnqualifiedClassInstanceCreationExpression
>
> UnqualifiedClassInstanceCreationExpression:
>   new [TypeArguments] ClassOrInterfaceTypeToInstantiate ( [ArgumentList] ) [ClassBody]
>
> ClassOrInterfaceTypeToInstantiate:
>   {Annotation} Identifier {. {Annotation} Identifier} [TypeArgumentsOrDiamond]"

As ClassOrInterfaceTypeToInstantiate defines it, the compiler will interpret the interface as an object.
Or, maybe a better way to say it is, the interpreter is going to schedule the interface as an object.

Essentially, this is referring to the anonymous inner-class.

abc abc = new abc() {
    @Override
    public void meth1() {

    }
};