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