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;
    }
}

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