Java静态类的使用

类被声明为静态类时，必须为内部类！
反之：静态类一定是内部类！

静态内部类和非静态内部类的区别：

类的声明方式

静 态 类：public static class StaticClass{ … }
非静态类: public class ClassName{ … }

访问类内部成员的权限

静态类：只能访问类内部的静态成员；
非静态类：可访问类内所有成员；

声明类内部成员的权限

静态类：可以声明静态成员和非静态成员；
非静态类：只能声明非静态成员；

类的初始化方式

假设，类结构为：Outer类内包含Inner类，InnerStatic类为Outer类的内部静态类，Inner为非静态类
静态类的初始化：
Outer.InnerStatic innerStatic = new Outer.InnerStatic();
非静态类初始化：
Outer.Inner inner = new Outer().new Inner();
or
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();

何时使用静态类?

情况一

当A类需要使用B类，并且B某类仅为A类服务，那么就没有必要单独写一个B类，因为B类在其他类中不会使用，所以只需将B类作为A的内部类。那么为什么一定要用静态类呢？通过上面类初始化方式可以看出，内部静态类的初始化无需实例化外部类，与对象无关；所以说这种情况推荐将B类声明为A类的内部静态类

public class 地球 {
private 水 water;
public 地球(水 w){
water = w;
}
public int get地球水含量(){
return water.get含量();
}
public String get地球上水的成分(){
return 水.get成分();
}
public static class 水{
int 含量;
public 水(int 含量){
this.含量=含量;
}

    public int get含量() {
        return 含量;
    }
    public static String get成分(){
        return "H2O";
    }
}

}
调用

public test(){
    dq = new 地球(new 地球.水(78));
    String x = dq.get地球上水的成分();
    int y = dq.get地球水含量();
    x= "水的构成:"+x + "当前地球含水量:"+y;
}

如果使用非静态类也可以实现上面的功能，水类可以作为内部类出现，也可以单独建类，使用情况自行脑补！

情况二

当某个类需要接受多个参数进行初始化时，推荐使用静态类构建。

没有使用静态类的例子：

public class Car {
private String name;
private String model;
private int height;
private int width;

public Car(String name){
    this.name=name;
}
......
//这里省略了 若干Car类的构造函数
public Car(String name,String model,int height,int width){
    this.name=name;
    this.model=model;
    this.height=height;
    this.width=width;
}
......

}
下面调用可以看出，未使用静态类的初始化构造函数 初始化变量很不灵活。

public class test {
Car car1 = new Car(“捷达王”,“大众捷达”,1650，1950);
Car car2 = new Car(“皇冠”);
car2.setModel(“丰田皇冠3.0”);
car2.setHeight(“1920”);
}
这个例子的变量只有4个，假如有40个变量呢，这40个变量又有选择性的初始化呢？那么必须使用静态类进行构建！下面是使用静态类的实现：

public class Car {
private String name;
private String model;
private int height;
private int width;

private Car(Builder build){
    this.name=build.name;
    this.model= build.model;
    this.height=build.height;
    this.width=build.width;
}
public static class Builder {
    private String name;
    private String model;
    private int height;
    private int width;
    public Builder(){

    }
    public Builder withName(String name){
        this.name=name;
        return this;
    }
    public Builder withModel(String model){
        this.model=model;
        return this;
    }
    public Builder withHeight(int height){
        this.height=height;
        return this;
    }
    public Builder withWidth(int width){
        this.width=width;
        return this;
    }
    public Car build(){
        return new Car(this);
    }
}

}
下面是调用代码

public class test {
Car jettaCar = new Car.Builder().withName(“捷达王”)
.withModel(“大众捷达”)
.withHeight(1650)
.withWidth(1950)
.build();
Car toyotaCar = new Car.Builder().withName(“皇冠”)
.withModel(“丰田皇冠3.0”)
.withHeight(1920)
.build();
}

总结

静态类一定是内部类；
静态类只能访问静态成员；
只有静态类才可以声明静态成员；