interface I {
    String getClass();
}

All class and array types inherit the methods of class Object, which are summarized here

9.4.2 Overloading
If two methods of an interface (whether both declared in the same interface, or both inherited by an interface, or one declared and one inherited) have the same name but different signatures that are not override-equivalent (§8.4.2), then the method name is said to be overloaded. This fact causes no difficulty and never of itself results in a compile-time error. There is no required relationship between the return types or between the throws clauses of two methods with the same name but different signatures that are not override-equivalent.

The signature of a method consists of the name of the method and the number and types of formal parameters to the method. A class may not declare two methods with the same signature, or a compile-time error occurs.

...
* 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.

    using System;
    namespace Polymorphism
    {
        class A
        {
              public void Foo() { Console.WriteLine("A::Foo()"); }
        }

        class B : A
        {
              public void Foo() { Console.WriteLine("B::Foo()"); }
        }

        class Test
        {
            static void Main(string[] args)
            {
                A a;
                B b;

                a = new A();
                b = new B();
                a.Foo();  // output --> "A::Foo()"
                b.Foo();  // output --> "B::Foo()"

                a = new B();
                a.Foo();  // output --> "A::Foo()"
            }
        }
    }

...
* 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.

interface Empty
{
};

Empty empty=new Empty() {};
Class clazz=empty.getClass(); //Всё нормально!

Class clazz=int.class;
assert clazz.getDeclaredMethods().length==0; //Всё ОК!

public class Test
{
    interface Empty{}
    public static void main(String []args)
    {
        System.out.println(Empty.class);
        System.out.println(new Empty(){}.getClass());
        System.out.println(int.class);
    }
}

public class A {
    private final void foo() { }
    public class B extends A {
        public void foo() { } // а это что: overload или override?
    }
}

DZ>    using System;
DZ>    namespace Polymorphism
DZ>    {
DZ>        class A
DZ>        {
DZ>              public void Foo() { Console.WriteLine("A::Foo()"); }
DZ>        }

DZ>        class B : A
DZ>        {
DZ>              public void Foo() { Console.WriteLine("B::Foo()"); }
DZ>        }
DZ>

class A {
    public override sealed string ToString() { return "A"; }
}

int.class = String.class; //Упс...

class $1 implements Empty extends Object
{
}
new $1().getClass()

N>public class A {
N>    private final void foo() { }
N>    public class B extends A {
N>        public void foo() { } // а это что: overload или override?
N>    }
N>}
N>

public class A {
    private final void foo() { }
    public class B extends A {
        public void foo() { new A().foo(); }
    }
}

class A {
    public void foo() { }
}
class B extends A {
    public void foo() { }
}

N>class A {
N>    public void foo() { }
N>}
N>class B extends A {
N>    public void foo() { }
N>}
N>

public class AbstractClass
{
    public abstract void someFunction();

    public void someFunc()
    {
           //... реализация
    }
}
public class Implementor extends AbstractClass
{
    public void someFunction() {/*....*/} //Тихо-мирно реализуем

    public void someAPI()
    {
         //Какая-то публичная функция
    }
}

public class AbstractClass
{
    public abstract void someFunction();

    public void someFunc()
    {
           //... реализация
    }

    private void someAPI()
    {
         //Просто совпало имя функции.
    }
}
public class Implementor extends AbstractClass
{
    public void someFunction() {/*....*/} //Тихо-мирно реализуем

    public void someAPI()
    {
         //Какая-то публичная функция
    }
}

class A {
    public override sealed string ToString() { return "A"; }
}

It follows that is a compile-time error if the interface declares a method with a signature that is override-equivalent (§8.4.2) to a public method of Object, but has a different return type or incompatible throws clause.

...
Two methods have the same signature if they have the same name and argument types.

Two method or constructor declarations M and N have the same argument types if all of the following conditions hold:

* They have the same number of formal parameters (possibly zero)
* They have the same number of type parameters (possibly zero)
* Let <A1,...,An> be the formal type parameters of M and let <B1,...,Bn> be the formal type parameters of N. After renaming each occurrence of a Bi in N's type to Ai the bounds of corresponding type variables and the argument types of M and N are the same.

The signature of a method m1 is a subsignature of the signature of a method m2 if either

* m2 has the same signature as m1, or
* the signature of m1 is the same as the erasure of the signature of m2.
...
Two method signatures m1 and m2 are override-equivalent if either m1 is a subsignature of m2 or m2 is a subsignature of m1.

The members of an interface are:
* Those members declared in the interface.
* Those members inherited from direct superinterfaces.
* 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.