需要加修饰符static；
    可以定义静态成员和非静态成员；
    不能直接访问包围类的非静态成员，可直接访问包围类的静态成员；
    可以通过包围类的对象进行访问非静态成员；
    外界可以通过静态嵌套类名访问其静态成员，通过对象访问其非静态成员；
    外界需要通过包围类才可以访问到静态嵌套类，并创建其对象，不需要外部包围类的实例；
    和正常的类没有什么区别，纯粹只是为了打包的便利性存在；

    1. public class Outer1 {
    2.     String name;
    4.     //静态嵌套类
    5.     static class Inner1{
    6.         String name;
    7.     }
    8. }
    10. ---测试类
    11. public class MyTest1 {
    12.     public static void main(String[] args) {
    13.         Outer1.Inner1 obj = new Outer1.Inner1();
    14.         //第三方需要通过外部包围类才可以访问到静态嵌套类
    15.     }
    16. }

    静态内部类分析

    1. ----测试类
    2. public class Outer2Test {
    3.     public static void main(String[] args) {
    4.         //第三方类访问静态嵌套类
    5.         Outer2.Inner1 obj1 = new Outer2.Inner1();
    6.         obj1.getInnFlied1();
    8.         Outer2.Inner1 obj2 = new Outer2.Inner1();
    9.         System.out.println(obj1 == obj2);
    11.         System.out.println("===================");
    12.         Outer2 obj3 = new Outer2();
    13.         obj3.outFun2();
    14.         /*false
    15.         ===================
    16.         false
    17.         inner 333
    18.         inner hello
    19.         inner static 444*/
    20.     }
    21. }
    1. ----静态内部类
    2. public class Outer2 {
    3.     private static String outStaticFiled2 = "outer static 222";
    4.     private String outFiled = "outer 111";
    6.     public void outFun2() {
    7.         Inner1 obj1 = new Inner1();
    8.         Inner1 obj2 = new Inner1();
    9.         System.out.println(obj1 == obj2);//false
    10.         System.out.println(obj1.getInnFlied1());//inner 333
    11.         System.out.println(Inner1.getInnerStaticFiled2());//inner static 444
    12.     }
    14.     public String getOutFiled() {
    15.         return this.outFiled;
    16.     }
    18.     //静态嵌套类
    19. //    private static class Inner1
    20. //    static class Inner1
    21. //    protected static class Inner1
    22.     public static class Inner1 {
    23.         static String innerStaticFiled2 = "inner static 444";
    24.         //静态嵌套类可以定义静态的、非静态的成员
    25.         private String innFlied1 = "inner 333";
    27.         public static String getInnerStaticFiled2() {
    28.             hello();
    29.             //Outer2.hello();
    30.             return innerStaticFiled2;
    31.         }
    33.         private static void hello() {
    34.             System.out.println("inner hello");
    35.         }
    37.         public String getInnFlied1() {
    38.             return innFlied1;
    39.         }
    41.         public void innFun1() {
    42.             //静态嵌套类可以直接访问包围类的静态成员
    43.             System.out.println(outStaticFiled2);
    44.             //System.out.println(outFiled);--error
    46.             //静态嵌套类可以通过对象访问包围类的非静态成员
    47.             Outer2 obj = new Outer2();
    48.             System.out.println(obj.getOutFiled());
    49.         }
    50.     }
    51. }

    https://blog.csdn.net/weixin_45082647/article/details/106558172?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165079342116781667880264%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=165079342116781667880264&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-106558172.142^v9^control,157^v4^control&utm_term=java%E5%B5%8C%E5%A5%97%E7%B1%BB&spm=1018.2226.3001.4187