解析Java中的static关键字
一.static关键字使用场景
static关键字主要有以下5个使用场景:
1.1、静态变量
把一个变量声明为静态变量通常基于以下三个目的:
- 作为共享变量使用
- 减少对象的创建
- 保留唯一副本
第一种比较容易理解,由于static变量在内存中只会存在一个副本,所以其可以作为共享变量使用,比如要定义一个全局配置、进行全局计数。如:
public class carconstants { // 全局配置,一般全局配置会和final一起配合使用, 作为共享变量 public static final int max_car_num = 10000; } public class carfactory { // 计数器 private static int createcarnum = 0; public static car createcar() { if (createcarnum > carconstants.max_car_num) { throw new runtimeexception("超出最大可生产数量"); } car c = new car(); createcarnum++; return c; } public static getcreatecarnum() { return createcarnum; } }
第二种虽然场景不多,但是基本在每个工程里面都会使用到,比如声明loggger变量:
private static final logger logger = logfactory.getloggger(myclass.class);
实际上,如果把static去掉也是可行的,比如:
private final logger logger = logfactory.getloggger(myclass.class);
这样一来,对于每个myclass的实例化对象都会拥有一个logger,如果创建了1000个myclass对象,则会多出1000个logger对象,造成资源的浪费,因此通常会将logger对象声明为static变量,这样一来,能够减少对内存资源的占用。
第三种最经典的场景莫过于单例模式了,单例模式由于必须全局只保留一个副本,所以天然和static的初衷是吻合的,用static来修饰再合适不过了。
public class singleton { private static volatile singleton singleton; private singleton() {} public static singleton getinstance() { if (singleton == null) { synchronized (singleton.class) { if (singleton == null) { singleton = new singleton(); } } } return singleton; } }
1.2、静态方法
将一个方法声明为静态方法,通常是为了方便在不创建对象的情况下调用。这种使用方式非常地常见,比如jdk的collections类中的一些方法、单例模式的getinstance方法、工厂模式的create/build方法、util工具类中的方法。
1.3、静态代码块
静态代码块通常来说是为了对静态变量进行一些初始化操作,比如单例模式、定义枚举类:
单例模式
public class singleton { private static singleton instance; static { instance = new singleton(); } private singleton() {} public static singleton getinstance() { return instance; } }
枚举类
public enum weekdayenum { monday(1,"周一"), tuesday(2, "周二"), wednesday(3, "周三"), thursday(4, "周四"), friday(5, "周五"), saturday(6, "周六"), sunday(7, "周日"); private int code; private string desc; weekdayenum(int code, string desc) { this.code = code; this.desc = desc; } private static final map<integer, weekdayenum> week_enum_map = new hashmap<integer, weekdayenum>(); // 对map进行初始化 static { for (weekdayenum weekday : weekdayenum.values()) { week_enum_map.put(weekday.getcode(), weekday); } } public static weekdayenum findbycode(int code) { return week_enum_map.get(code); } public int getcode() { return code; } public void setcode(int code) { this.code = code; } public string getdesc() { return desc; } public void setdesc(string desc) { this.desc = desc; } }
1.4、静态内部类
内部类一般情况下使用不是特别多,如果需要在外部类里面定义一个内部类,通常是基于外部类和内部类有很强关联的前提下才去这么使用。
在说静态内部类的使用场景之前,我们先来看一下静态内部类和非静态内部类的区别:
非静态内部类对象持有外部类对象的引用(编译器会隐式地将外部类对象的引用作为内部类的构造器参数);而静态内部类对象不会持有外部类对象的引用
由于非静态内部类的实例创建需要有外部类对象的引用,所以非静态内部类对象的创建必须依托于外部类的实例;而静态内部类的实例创建只需依托外部类;
并且由于非静态内部类对象持有了外部类对象的引用,因此非静态内部类可以访问外部类的非静态成员;而静态内部类只能访问外部类的静态成员;
两者的根本性区别其实也决定了用static去修饰内部类的真正意图:
- 内部类需要脱离外部类对象来创建实例
- 避免内部类使用过程中出现内存溢出
第一种是目前静态内部类使用比较多的场景,比如jdk集合中的entry、builder设计模式。
hashmap entry:
builder设计模式:
public class person { private string name; private int age; private person(builder builder) { this.name = builder.name; this.age = builder.age; } public static class builder { private string name; private int age; public builder() { } public builder name(string name) { this.name = name; return this; } public builder age(int age) { this.age=age; return this; } public person build() { return new person(this); } } public string getname() { return name; } public void setname(string name) { this.name = name; } public int getage() { return age; } public void setage(int age) { this.age = age; } } // 在需要创建person对象的时候 person person = new person.builder().name("张三").age(17).build();
第二种情况一般出现在多线程场景下,非静态内部类可能会引发内存溢出的问题,比如下面的例子:
public class task { public void oncreate() { // 匿名内部类, 会持有task实例的引用 new thread() { public void run() { //...耗时操作 }; }.start(); } }
上面这段代码中的:
new thread() { public void run() { //...耗时操作 }; }.start();
声明并创建了一个匿名内部类对象,该对象持有外部类task实例的引用,如果在在run方法中做的是耗时操作,将会导致外部类task的实例迟迟不能被回收,如果task对象创建过多,会引发内存溢出。
优化方式:
public class task { public void oncreate() { subtask subtask = new subtask(); subtask.start(); } static class subtask extends thread { @override public void run() { //...耗时操作 } } }
1.5、静态导入
静态导入其实就是import static,用来导入某个类或者某个包中的静态方法或者静态变量。如下面这段代码所示:
import static java.lang.math.pi; public class mathutils { public static double calcirclearea(double r) { // 可以直接用 math类中的静态变量pi return pi * r * r; } }
这样在书写代码的时候确实能省一点代码,但是会影响代码可读性,所以一般情况下不建议这么使用。
二.static变量和普通成员变量区别
static变量和普通成员变量主要有以下4点区别:
- 区别1:所属不同。static变量属于类,不单属于任何对象;普通成员变量属于某个对象
- 区别2:存储区域不同。static变量位于方法区;普通成员变量位于堆区。
- 区别3:生命周期不同。static变量生命周期与类的生命周期相同;普通成员变量和其所属的对象的生命周期相同。
- 区别4:在对象序列化时(serializable),static变量会被排除在外(因为static变量是属于类的,不属于对象)
三.类的构造器到底是不是static方法?
关于类的构造器是否是static方法有很多争议,在《java编程思想》一书中提到“类的构造器虽然没有用static修饰,但是实际上是static方法”,个人认为这种说法有点欠妥,原因如下:
1)在类的构造器中,实际上有一个隐藏的参数this引用,this是跟对象绑定的,也就是说在调用构造器之前,这个对象已经创建完毕了才能出现this引用。而构造器的作用是干什么的呢?它负责在创建一个实例对象的时候对实例进行初始化操作,即jvm在堆上为实例对象分配了相应的存储空间后,需要调用构造器对实例对象的成员变量进行初始化赋值操作。
2)我们再来看static方法,由于static不依赖于任何对象就可以进行访问,也就是说和this是没有任何关联的。从这一层面去讲,类的构造器不是static方法
3)从jvm指令层面去看,类的构造器不是static方法,我们先看一下下面这段代码:
class person { private string name; public person(string name) { this.name = name; } public static void create() { } } public class main { public static void main(string[] args) { person.create(); person p = new person("jack"); } }
这段代码反编译之后的字节码如下:
从上面可以看出,在调用static方法是调用的是invokestatic指令,而在调用类的构造器时实际上执行的是invokespecial指令,而这2个指令在jvm规范中的解释如下:
可以看出,这2个指令的用途是完全不同的,invokestatic定义很清楚,就是用来调用执行static方法,而invokespecial用来调用实例方法,用来特殊调用父类方法、private方法和类的构造器。
以上就是解析java中的static关键字的详细内容,更多关于java static 关键字的资料请关注其它相关文章!