1. 静态类访问外部类成员（比如：静态属性），访问方式：直接访问所有静态成员。
    2. 外部类访问静态内部类，访问方式：创建对象，再访问。
    3. 外部其他类访问静态内部类（三种方式）。
    4. 如果外部类和静态内部类成员重名，静态内部类访问时，遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员）去访问。 ```java package test;

    public class Main { public static void main(String[] args) { Outer outer = new Outer(); outer.hi();

    1.     //外部其他类 使用静态内部类
    2.     //方式1
    3.     //因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
    4.     System.out.println("方法一：");
    5.     Outer.Inner inner = new Outer.Inner();
    6.     inner.say();
    8.     //方式2
    9.     //编写一个方法，可以返回静态内部类的对象实例.
    10.     System.out.println("方法二：");
    11.     Outer.Inner inner1 = outer.getInner();
    12.     inner1.say();
    14.     //方式3
    15.     //编写一个静态方法，可以返回静态内部类的对象实例.
    16.     //不用创建对象
    17.     System.out.println("方法二：");
    18.     Outer.Inner inner01 = Outer.getInner01();
    19.     inner01.say();
    20. }

    }

    class Outer { //外部类 private int n1 = 10; private static String name = “WTY2002”; private static void cry() {}

    1. //Inner就是静态内部类
    2. //放在外部类的成员位置，使用static 修饰
    3. //2. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    4. //3. 作用域 ：同其他的成员，为整个类体
    5. public static class Inner {
    6.     private static String name = "52编程";
    7.     public void say() {
    8.         //1. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    9.         //System.out.println(n1);//报错！！！
    11.         //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
    12.         //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
    13.         System.out.println("name = " + name);
    14.         System.out.println("外部类name = " + Outer.name);
    15.         cry();
    16.     }
    17. }
    18. //5. 外部类访问静态内部类，访问方式：创建对象，再访问。
    19. public void hi(){
    20.     Inner inner = new Inner();
    21.     inner.say();
    22. }
    24. public Inner getInner(){
    25.     return new Inner();
    26. }
    28. public static Inner getInner01(){
    29.     return new Inner();
    30. }

    } ``` image.png