Java内部类、外部类之间访问权限

啥是内部类

顾名思义，内部类就是在一个类中定义了另一个类，比如在类A中定义了一个类B，B就是A的内部类。

class A{
	String a = "a";

	class B{
		String b = "b";
	}
}

内部类可以访问外部类的所有成员吗

修改一下代码，外部类A中有多种访问权限的字符串，在内部类B中的方法去打印这些字符串，先抛开static来看。

public class A {
    String a = "a";
    private String privateA = "privateA";
    protected String protectedA = "protectedA";
    public String publicA = "publicA";

    public static void main(String[] args){
        A a = new A();
        a.test();
    }

    public void test(){
        B b = new B();
        b.accessA();
    }

    class B{
        public void accessA(){
            System.out.println(a);
            System.out.println(privateA);
            System.out.println(protectedA);
            System.out.println(publicA);
        }
    }
}

编译没有错可以正常执行，结果如下，可以看出内部类B可以访问所有外部类A的成员。

那外部类能访问内部类的所有成员吗

再改，需要创建一个内部类的对象

public class A {
  
    public static void main(String[] args){
        A a = new A();
        a.accessB();
    }

    public void accessB(){
        B b = new B();
        System.out.println(b.b);
        System.out.println(b.privateB);
        System.out.println(b.protectedB);
        System.out.println(b.publicB);
    }

    class B{
        String b = "b";
        private String privateB = "privateB";
        protected String protectedB = "protectedB";
        public String publicB = "publicB";

        public void accessA(){
            System.out.println(a);
            System.out.println(privateA);
            System.out.println(protectedA);
            System.out.println(publicA);
        }
    }
}

执行结果如下。嗯，没啥问题，各种权限都能访问

匿名内部类

public class A {
    String a = "a";
    private String privateA = "privateA";
    protected String protectedA = "protectedA";
    public String publicA = "publicA";

    public static void main(String[] args){
        A a = new A();
        a.test();
    }

    public void test(){
        B b = new B(){
            @Override
            public void accessA(){
                System.out.println(a);
                System.out.println(privateA);
                System.out.println(protectedA);
                System.out.println(publicA);
            }
        };
        b.accessA();
        accessB(b);
    }

    public void accessB(B b){
        System.out.println(b.b);
        System.out.println(b.privateB);
        System.out.println(b.protectedB);
        System.out.println(b.publicB);
    }

    class B{
        String b = "b";
        private String privateB = "privateB";
        protected String protectedB = "protectedB";
        public String publicB = "publicB";

        public void accessA(){
           
        }
    }
}

运行结果，匿名内部类和内部类都一样

静态内部类呢

给B加上static关键字结果

但是外部类A还是可以通过内部类B的对象访问B的所有成员

为啥会这样呢

为什么B中的accessA方法可以直接访问A的成员，而A中的accessB方法要创建B对象？

内部类创建的时候会自动持有一个外部类的引用，所以创建内部类B的对象可以直接访问A的成员，而外部类A的对象要手动创建一个内部类B的对象才能访问B对象的成员。

为什么加上static关键字A的成员就访问不了了？

加上static关键字B就脱离了对象，B不会持有A的引用了，但B还可以创建A对象，去访问对象的所有成员

 static class B{
        public void accessA(){
            A aObj = new A();
            System.out.println(aObj.a);
            System.out.println(aObj.privateA);
            System.out.println(aObj.protectedA);
            System.out.println(aObj.publicA);
        }
    }

得出结论

外部类、内部类之间通过对象可以访问任意权限的成员。