我可以从静态内部类访问外部类的字段吗？

Question

I have a class which has another static inner class:

class A {
    private List<String> list;

    public static class B {
        // I want to update list here without making list as static 
        // I don't have an object for outer class
    }
}

Answer 1

You generally use static classes when you don't need access to the instance variables. If you need to access the instance variables make the class non-static.

Answer 2

As you can see from other answers that you will need a non-static inner class to do that.

If you really cannot make your inner class non-static then you can add required getter and setter method in outer class and access them by creating an instance of outer class from inside inner static class:

public class A {
    private List<String> list = new ArrayList<String>();
    public List<String> getList() {
        return list;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public static class B {
        // i want to update list here without making list as static
        void updList() {
            A a = new A();
            a.setList(someOtherList);
            System.out.println(a.getList());
        }
    }
} 

Answer 3

No, you'll need a non- static inner class to do that.

From the JLS §8.5.1 :

The static keyword may modify the declaration of a member type C within the body of a non-inner class or interface T . Its effect is to declare that C is not an inner class. Just as a static method of T has no current instance of T in its body, C also has no current instance of T , nor does it have any lexically enclosing instances.

It is a compile-time error if a static class contains a usage of a non-static member of an enclosing class.

Answer 4

In your code, list is an instance variable of class A and B is nested static class. The rules of accessing static and not static member don't change for nested static class.

• The variable list is instance variable so a can't be accessed from static context.

• To enable this, you need to change static nester class to inner class.

   class A { private List<String> list = new ArrayList<String>(); public class B { public void someMethod(){ list.add("abc"); } } }

Answer 5

private List<String> list;

Here list is an instance variable while the inner class is static which means that class B is the same across different class A instances; one cannot access it. And, that too for a very good and obvious reason.

One solution that you can use is pass reference of member list to the constructor of class B with a weakReference to avoid memory leak.

Something like this:

class A {
    private List<String> list;

    public static class B {
        WeakReference<List<String>> innerList;
        //constructor
        B(WeakReference<List<String>> innerList){
            this.innerList = innerList;
        }
    }