Java静态嵌套类详解

1. 什么情况下可以使用静态的类？

使用静态的类的只有一种情况，就是在内部类中。如果是在外部类中使用 static 关键字是会报错的。

2.静态内部类的使用条件限制

1. 静态的内部类中不能访问外部类中非静态的变量和方法 。

   class Outer{
       public  String name = "什么神奇";
       private int age;
       public void fun(){
           System.out.println("我靠");
       }
       public static class Inner{
           public void fun2(){
               fun();//报错
               System.out.println(name);//报错
           }
       }
   }

   再来对比普通内部类的使用

   class Outer{
       public  static String name = "什么神奇";
       private int age;
       public static void fun(){
           System.out.println("我靠");
       }
       public class Inner{
           public void fun2(){
               fun();
               System.out.println(name);
           }
       }
   }

   证明了一点，在非静态的内部类中能够使用外部类中静态的方法和变量

2. 静态的内部类的实例化可以直接通过外部类 . 的形式来进行

   public class TestOne {
       public static void main(String[] args){
           Outer.Inner one = new Outer.Inner();
           one.fun2();
       }
   }
   
   class Outer{
       public static String name = "什么神奇";
       private int age;
       public static void fun(){
           System.out.println("我靠");
       }
       public static class Inner{
           public void fun2(){
               fun();
               System.out.println(name);
           }
       }
   }

   对比普通的内部类

   public class TestOne {
       public static void main(String[] args){
           Outer one = new Outer();
           Outer.Inner two=one.new Inner();
           two.fun2();
       }
   }
   
   class Outer{
       public static String name = "什么神奇";
       private int age;
       public static void fun(){
           System.out.println("我靠");
       }
       public class Inner{
           public void fun2(){
               fun();
               System.out.println(name);
           }
       }
   }

   普通的内部类必须通过外部类的对象来进行实例化，否则出现问题，需要注意的是, one.new Inner() 的写法。

3. 静态内部类是不同使用普通内部类的实例化形式的

   public class TestOne {
       public static void main(String[] args){
           Outer one = new Outer();
           Outer.Inner two=one.new Inner();//one这里会报错
           two.fun2();
       }
   }
   
   class Outer{
       public static String name = "什么神奇";
       private int age;
       public static void fun(){
           System.out.println("我靠");
       }
       public static class Inner{
           public void fun2(){
               fun();
               System.out.println(name);
           }
       }
   }

3.静态内部类的使用场景

对于静态内部类我们可能在平时的编程环境中不多见，但是在某些项目中，很多都使用了静态内部类，这种场景一般针对于静态内部类不需要外部类的资源，而外部类需要使用内部类的时候。

public class TestOne {
    public static void main(String[] args){
        Outer one = Outer.two();
        System.out.println(one.getName());
        System.out.println(one.getAge());
    }
}

class Outer{
    private String name;
    private int age;
    public Outer(Inner one){
        this.name= one.name;
        this.age=one.age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
    //静态内部类
    public static class Inner{
        private String name;
        private int age;
        public Inner(int age){
            this.age= age;
        }
        public Inner setName(String name){
            this.name=name;
            return this;
        }
        public Inner setAge(int age){
            this.age=age;
            return this;
        }
        public Outer returnOuter(){
            return  new Outer(this);
        }
    }
    //外部类实现
    public static Outer two(){
        Outer one =  new Outer.Inner(20).setName("什么神奇").returnOuter();
        return one;
    }
}

上面的代码中就是静态内部类不使用外部类的资源，而是外部类使用静态内部类中的数据，当然，上面只是个例子为了叙述这种使用场景，比如说在某些复杂的项目中，这种写法避免个各种继承的麻烦，并且外部类中实现了与内部类中数据的交互。