访问匿名外部类而不存储变量？

Question

Is there a way to access an anonymous outer class? A normal class can be accessed by ClassName.this. This doesn't work, as an anonymous class obviously doesn't have a name. I also tried using the extended class/interface (like Runnable.this) but it doesn't seem like it would work this way.

I'm sure this may be not the best coding style, I'm just curious if it's possible without storing this of the outer in a variable.

Example, watch out for outer.this:

public class A
{
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        synchronized (outher.this) {
                            outher.this.notify();
                        }
                    }
                }).start();
                try {
                    synchronized (this) {
                        wait();
                    }
                } catch (final InterruptedException ex) {}
            }
        }).start();
    }
}

Answer 1

No, there is no way to access anonymous classes from anywhere, except from inside them (ie otherwise than by this reference). Or by an explicitly declared variable.

final Runnable r1 = new Runnable() {...};
Runnable r2 = new Runnable() {
    public void run() {
         synchronized(r1) {...}
    }
};

Answer 2

You could add a method to return this middle this . It would be in scope but not hidden (is that the right term? Shadowed? I forget.).

public static void main(String[] args) {
    new Thread(new Runnable() {
        Runnable middleThis() { return this; } // <-- this
        @Override
        public void run() {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    synchronized (middleThis()) {
                        middleThis().notify();

Note, although anonymous inner classes have no name, they still are types. So adding members is visible to the immediate expression ( new X() { Y z; }.z ) and inside. You can't do middleThis().middleThis() .