目錄一.static關鍵字使用場景1.1、靜態變量1.2、靜態方法1.3、靜態代碼塊1.4、靜態內部類1.5、靜態導入二.static變量和普通成員變量區別三.類的構造器到底是不是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 {@Overridepublic void run() { //...耗時操作 } }}1.5、靜態導入

靜態導入其實就是import static，用來導入某個類或者某個包中的靜態方法或者靜態變量。如下面這段代碼所示：

import static java.lang.Math.PI; public class MathUtils { public static double calCircleArea(double r) {// 可以直接用 Math類中的靜態變量PIreturn 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規范中的解釋如下：

https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.invokestatic

可以看出，這2個指令的用途是完全不同的，invokestatic定義很清楚，就是用來調用執行static方法，而invokespecial用來調用實例方法，用來特殊調用父類方法、private方法和類的構造器。

以上就是解析Java中的static關鍵字的詳細內容，更多關于Java static 關鍵字的資料請關注好吧啦網其它相關文章！