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"; }
}