I'd like to see the real code.  My best guess as to what he meant does
not exhibit the behavior he described.  Here's my version of the code:

class Outer {

    class Inner {
        public Inner() {
            Outer.this.hello();
        }
    }

    public Outer() {
        new Inner();
    }

    void hello() {
        System.out.println("hello");
    }

    public static void main(String[] args) {
        new Outer();
    }
}

When I run it (Sun JRE 1.5.0_02), it prints "hello" and exits normally,
as I expected it would.

When a constructor or instance initializer runs, it has access to a
valid "this" reference (per JLS).  I haven't found the same level of
assurance in the JLS for a qualified "this", but I do find a flat "Any
lexically enclosing instance can be referred to by explicitly qualifying
the keyword this" (JLS 15.8.4).  There is no particular reason why the
qualified "this" reference(s) should be unavailable on account of inner
class instantiation happening in a constructor.  In fact, I assert that
the Java compiler is in error in successfully compiling the above code
if it cannot or does not ensure that the Inner constructor has a valid
value for Outer.this.

It is an *entirely* different story, however, if the inner class'
constructor assumes that its containing instance is fully initialized,
and thus attempts to directly or indirectly read or manipulate its
member variables.  For instance:

class Outer2 {

    PrintStream out;

    class Inner2 {
        public Inner2() {
            Outer2.this.hello();
        }
    }

    public Outer2() {
        new Inner2();
        out = System.out;
    }

    void hello() {
        out.println("hello");
    }

    public static void main(String[] args) {
        new Outer2();
    }
}

This version of the program quite expectedly throws a
NullPointerException from Outer2.hello().

Yup, several of you were right (Chris S., Benji and others). I realized
just after I posted what the problem was, too, but by that time I was
on the bus on the way home. My actual code has one additional twist:
the "Outer.this" reference gets stuck with the null pointer
permanently. The constructor is actually _passed_ the null pointer as
if it were the outer reference.

The actual code I was using is close to the following:

class Outer {
    public static void main(String args[]) {
        new Outer();
    }

    Outer() {
        Inner inner = (Inner)(new InnerFactory()).o;
        System.out.println("still " + inner.parent());
    }

    class Inner {
        Inner() { System.out.println(Outer.this); }
        Outer parent() { return Outer.this; }
    }

    class InnerFactory extends Factory {
        Object makeone() { return new Inner(); }
    }

}

class Factory {
    Object o;
    Factory()  { o = makeone(); }
    Object makeone() { return "unused"; }
}

Compiled and run with sun's 1.4.1_02 jdk, I get:
null
still null

The explanation probably looks something like this:

- main()
-- Outer.<init>()
--- Factory.<init>() // superconstructor of InnerFactory
---- InnerFactory.makeone() // has null Outer.this, since constructor
not yet called
----- Inner.<init>() // passed the null Outer.this by
InnerFactory.makeone()
------ println()      // prints the null Outer.this
----- return from Inner.<init>()
---- return from InnerFactory.makeone()
--- InnerFactory.<init>() // finished superconstructor, start
InnerFactory constructor
---- // now sets Outer.this in InnerFactory instance, but too late
--- return...

Notice how the inner object is now wedged, since it was passed a null
pointer and stored that as its Outer.this reference. Even after the
constructors are all done, the inner object's Outer.this reference is
permanently set to null. Ouch. I don't have the time or motivation to
figure
out if this is legit behavior or what, but maybe I deserved it for such
ugly
code.

Thanks for the comments!

-Kevin