Java从内部类单例访问外部类变量

Question

I have an interface ( Node ) that is implemented by two classes: White , which I want to be a singleton, and Black , not a singleton. The problem is I want these classes to be enclosed by an outer class ( Outer ), which has a field of its own ( outerObject ). White should be a singleton, which means it should be static. But Black needs to be able to access the outer class fields, which means it cannot be static.

Here, if White is not static, then it's not really a singleton:

class Outer {
    interface Node {
        Node foo();
    }

    // I would like the White class to be a singleton class
    class White implements Node {
        Node foo() {
            return new Black();
        }
    }

    class Black implements Node {
        Node foo() {
            outerObject.doSomething();
            return this;
        }
    }

    Object outerObject;
}

But if I make White a static singleton, then it cannot instantiate a new Black without an enclosing Outer :

    enum White implements Node {
        INSTANCE;

        Node foo() {
            return new Black(); // This doesn't work because Black
                                // needs an enclosing outer class.
        }
    }

And if I were to make Black a static class, then it cannot access the field ( outerObject ) in the outer class:

    static class Black implements Node {
        Node foo() {
            outerObject.doSomething(); // can't access non-static field
            return this;
        }
    }

A simpler representation which captures the same problem is simply trying to access outerObject from a singleton White :

class Outer {
    enum White {
        INSTANCE;

        Node foo() {
            outerObject.doSomething();
            return this;
        }
    }

    Object outerObject;
}

I'd have to make White non-static to be able to access outerObject , but it should be static in order to be singleton.

Does anyone know if there is a solution to this? If it comes down to it, I could try to make a pseudo-singleton inner class (in the sense that each instance of the outer class can only have one instance of that inner class). Or just ditch the singleton pattern and manually declare only one White .

Answer 1

You can specify on what instanse of Outer you want to create new Black. But probably it is not what you want.

    enum White implements Node {
        INSTANCE;

        public Node foo() {
            return new Outer().new Black(); // This will work
        }
    }