为什么 javac 允许“new CLS().new InnerCLS()”编译？

Question

Consider the following snippet:
(I came across this syntax when inspecting some decompiled class files and this is a minimal representation)

public class Main {
    public static void main(String[] args) {
        Main.Inner o = new Main().new Inner() {};

        System.out.println("Bye from " + o.getClass());
    }

    class Inner {}
}

This compiles and runs fine (I tested a bunch of JDKs).
Can someone please explain how come this compiles and what does this code represent?

This code creates 3 classes:

1. Main - This creates the following code (I removed the irrelevant parts):   
    new Main$1
    dup
    new Main
    dup
    invokespecial Method Main <init> ()V
    dup
    invokevirtual Method java/lang/Object getClass ()Ljava/lang/Class;
    pop
    invokespecial Method Main$1 <init> (LMain;)V

Why is it calling getClass (the result is popped anyway)?

2. Main$Inner - This class looks like as would expect an inner class to look

3. Main$1 - This creates the following class (I removed the irrelevant parts):
    final class Main$1 extends Main$Inner 
    method <init> : (LMain;)V 
    aload_0
    aload_1
    dup
    invokevirtual Method java/lang/Object getClass ()Ljava/lang/Class;
    pop
    invokespecial Method Main$Inner <init> (LMain;)V
    return

Again, why is it calling getClass (the result is popped anyway)?

BTW, it can be nested even further like this:

public class Main {
    public static void main(String[] args) {
        Object o = new Main().new Inner1().new Inner2().new Inner3() {};

        System.out.println("Bye from " + o.getClass());
    }

    class Inner1 {
        class Inner2 {
            class Inner3 {
            }
        }
    }
}

Answer 1

This is how instance (non-static) inner classes work. You need an instance of the outer class to instantiate instance of the inner class. This is another example:

var outer = new Outer();
var inner = outer.new Outer.Inner();

See:

• The Java™ Tutorials: Nested Classes

Answer 2

Inner classes must be instantiated with a this pointer to the outer class.

The syntax outer.new Inner() is one way to achieve that (the new instance of Inner will have the value of outer as the outer.this reference.

This is equivalent to having a non-static method in the Main class:

class Main {

    Inner makeInner() {
        /// "this." is implied here, but it is there.
        return new Inner();
    }
    class Inner {
    }
}