再議Java中的static關鍵字

時間 2019-11-05

標籤再議 java static 關鍵字欄目 Java 简体版

原文原文鏈接

再議Java中的static關鍵字

　　java中的static關鍵字在好久以前的一篇博文中已經講到過了，感興趣的朋友能夠參考：《Java中的static關鍵字解析》。html

　　今天咱們再來談一談static關鍵字，此次咱們側重講述static關鍵字的一些使用場景和方式，如下是本文目錄大綱：java

　　一.static關鍵字使用場景編程

　　二.static變量和普通成員變量區別設計模式

　　三.類的構造器究竟是不是static方法？多線程

　　如有不正之處，但願諒解並歡迎批評指正。oracle

　　請尊重做者勞動成果，轉載請標明原文連接：jvm

　　https://www.cnblogs.com/dolphin0520/p/10651845.htmlide

一.static關鍵字使用場景

　　static關鍵字主要有如下5個使用場景：工具

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

2）靜態方法

　　將一個方法聲明爲靜態方法，一般是爲了方便在不建立對象的狀況下調用。這種使用方式很是地常見，好比jdk的Collections類中的一些方法、單例模式的getInstance方法、工廠模式的create/build方法、util工具類中的方法。

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

4）靜態內部類

　　關於內部類的使用場景可參考以前寫的這篇文章 http://www.javashuo.com/article/p-hdzvhjxq-ed.html

　　內部類通常狀況下使用不是特別多，若是須要在外部類裏面定義一個內部類，一般是基於外部類和內部類有很強關聯的前提下才去這麼使用。

　　在說靜態內部類的使用場景以前，咱們先來看一下靜態內部類和非靜態內部類的區別：

　　非靜態內部類對象持有外部類對象的引用（編譯器會隱式地將外部類對象的引用做爲內部類的構造器參數）；而靜態內部類對象不會持有外部類對象的引用

　　因爲非靜態內部類的實例建立須要有外部類對象的引用，因此非靜態內部類對象的建立必須依託於外部類的實例；而靜態內部類的實例建立只需依託外部類；

　　而且因爲非靜態內部類對象持有了外部類對象的引用，所以非靜態內部類能夠訪問外部類的非靜態成員；而靜態內部類只能訪問外部類的靜態成員；

　　二者的根本性區別其實也決定了用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() {
            //...耗時操做    
        }
        
    }
}

5）靜態導入

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

import static java.lang.Math.PI; 
 
    public  class MathUtils { 

    public static double calCircleArea(double r) {
        // 能夠直接用 Math類中的靜態變量PI
        return PI * r * r; 
    } 
}

　　這樣在書寫代碼的時候確實能省一點代碼，可是會影響代碼可讀性，因此通常狀況下不建議這麼使用。

2.static變量和普通成員變量區別

　　static變量和普通成員變量主要有如下4點區別：

區別1：所屬不一樣。static變量屬於類，不單屬於任何對象；普通成員變量屬於某個對象
區別2：存儲區域不一樣。static變量位於方法區；普通成員變量位於堆區。
區別3：生命週期不一樣。static變量生命週期與類的生命週期相同；普通成員變量和其所屬的對象的生命週期相同。
區別4：在對象序列化時（Serializable），static變量會被排除在外（由於static變量是屬於類的，不屬於對象）

3.類的構造器究竟是不是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方法和類的構造器。