Avant de commencer à parler de statique, je veux que vous voyiez un morceau de code intéressant :

public class Test {
     
    static{
        System.out.println("test static 1");
    }
  
    static{
        System.out.println("test static 2");
    }
    
    public static void main(String[] args) {
         
    }
}

Après avoir lu le programme, Xiaobai Tongxiao a dit : Qu'est-ce que c'est ? Il n’y a rien dans la méthode main, alors que peut-elle exécuter ? Blogueuse, tu es une star...

運(yùn)行結(jié)果：
test static 1
test static 2

Petites chaussures blanches pour enfants : Et alors... Alors quoi... Blogueuse, j'ai dit quelque chose, je n'ai rien dit...

En fait, ceux qui comprennent le code ci-dessus le comprendront naturellement, et ceux qui ne le comprennent pas ne le comprendront naturellement pas, car le code ci-dessus implique le chargement de classes JVM ! Bien s?r, cela n'entre pas dans le cadre de cet article de blog. Si vous souhaitez comprendre le programme ci-dessus, cet article peut vous être utile

1 La principale signification de l'existence statique.

La signification principale de static est de créer des variables de domaine ou des méthodes indépendantes d'objets spécifiques. Pour que vous puissiez utiliser des propriétés et appeler des méthodes même sans créer d'objet !

Le mot-clé static joue également un r?le clé dans étant utilisé pour former des blocs de code statiques afin d'optimiser les performances du programme . Un bloc statique peut être placé n’importe où dans une classe et il peut y avoir plusieurs blocs statiques dans une classe. Lorsqu'une classe est chargée pour la première fois, chaque bloc statique sera exécuté dans l'ordre des blocs statiques, et ne sera exécuté qu'une seule fois.

La raison pour laquelle le bloc statique peut être utilisé pour optimiser les performances du programme est due à ses caractéristiques?: il ne sera exécuté qu'une seule fois lorsque la classe est chargée. Par conséquent, de nombreuses opérations d’initialisation qui ne doivent être effectuées qu’une seule fois sont effectuées dans des blocs de code statiques.

[Apprentissage recommandé?: Tutoriel vidéo Java]

2.Le caractère unique de la statique

1. Les variables ou méthodes modifiées par static sont indépendantes de tout objet de la classe C'est-à-dire que ces variables et méthodes n'appartiennent à aucun objet instance, mais sont partagées par les objets instances de la classe<. ??>.

Comment comprenez-vous la phrase ??partagé par les objets d'instance d'une classe???? C'est-à-dire qu'un membre statique d'une classe appartient à tout le monde [Tout le monde fait référence à plusieurs instances d'objet de cette classe. Nous savons tous qu'une classe peut créer plusieurs instances ! ], partagé par tous les objets de classe, contrairement aux variables membres qui sont personnelles [self fait référence à une seule instance d'objet de cette classe]... Je pense avoir rendu les choses très simples, vous comprenez ?

2. Lorsque la classe est chargée pour la première fois, la partie modifiée par static sera chargée, et elle ne sera chargée et initialisée que lorsque la classe sera utilisée pour la première fois. c'est la première fois que la classe est chargée. Elle doit être initialisée une fois utilisée et peut être réaffectée si nécessaire ultérieurement.

3. La valeur de la variable statique se voit attribuer de l'espace lorsque la classe est chargée et ne sera pas réaffectée lors de la création future de l'objet de classe. Si vous attribuez une valeur, vous pouvez l'attribuer arbitrairement?!

4. Les variables ou méthodes modifiées par static ont priorité sur les objets, ce qui signifie qu'une fois chargée, une classe est accessible même si aucun objet n'est créé.

3. Scénarios d'application statiques

Parce que la statique est partagée par les objets d'instance d'une classe, si

une variable membre sont partagés par tous les objets, cette variable membre doit donc être définie comme une variable statique .

Les scénarios d'application statiques les plus courants sont donc?:

1. Modification des variables membres

2. Modification des méthodes membres
3. Classes modifiées [ne peuvent modifier que les classes internes, c'est-à-dire les classes internes statiques]
5. Package d'importation statique

Les scénarios d'application ci-dessus seront discutés les uns après les autres ci-dessous...

4. Les notions de variables statiques et de variables d'instanceVariables statiques?:

Les variables membres modifiées par static sont appelées variables statiques [également appelées variables de classe], les variables statiques appartiennent à cette classe, pas aux objets.

Variables d'instance?:

Les variables membres qui ne sont pas modifiées par static sont appelées variables d'instance. Les variables d'instance sont des objets d'instance appartenant à cette classe.

Une autre chose à noter est?:

static n'est pas autorisé à modifier les variables locales , ne me demandez pas ce que je demande, car c'est stipulé par Java?!

5. La différence entre les variables statiques et les variables d'instance [Points clés couramment utilisés]Variables statiques?:

Statiques les variables n'appartiennent pas à Tout objet d'instance appartient à une classe, il n'y aura donc qu'une seule copie dans la mémoire. Pendant le processus de chargement de la classe, la JVM n'alloue qu'une seule fois de l'espace mémoire pour les variables statiques.

Variables d'instance?:

Chaque fois qu'un objet est créé, un espace mémoire de variable membre sera alloué pour chaque objet. Les variables d'instance appartiennent à l'objet d'instance. Dans la mémoire, l'objet est créé plusieurs fois. fois. Plusieurs variables membres.

Je crois que tout le monde a un QI plus élevé que Yichun, vous devriez donc tous comprendre ce qui précède. Les exemples donnés ci-dessous sont uniquement destinés au divertissement. Vous n'avez pas besoin de les lire si vous les comprenez. Les exemples ci-dessous sont uniquement à titre de référence et sont uniquement destinés au divertissement et à l'ambiance. Si vous êtes pressé, vous pouvez les ignorer?!

怎么理解呢？打個(gè)比喻吧...就比方說程序員小王是一個(gè)比較溫柔陽光的男孩子，這1024的這一天，老板閑的沒事，非要拉著程序員小王來玩耍，怎么個(gè)玩法呢？老板和小王一人拿著一把菜刀，規(guī)則很簡單，互相傷害，一人一刀，你一刀，我一刀....游戲一開始，老板二話不說，跳起來就是一刀，程序員小王二話也沒說反手就是一菜刀回去，這個(gè)時(shí)候老板發(fā)飆了，雙眼瞪得忒大，跳起來又是一刀，這個(gè)時(shí)候程序員小王不敢還手了，就沒動(dòng)手。沒想到老板越來越生猛，左一刀右一刀全程下來差不多砍個(gè)半個(gè)時(shí)....程序員小王一直沒有還過手，因?yàn)樾⊥踔浪抢习?..

這個(gè)程序員小王只會(huì)在老板第一次揮刀的時(shí)候，回老板一刀，之后就不還手了，這個(gè)時(shí)候我們把程序員小王看做是靜態(tài)變量，把老板第一次向小王揮刀看做是類加載，把小王回老板一刀看出是分配內(nèi)存空間，而一人一刀這個(gè)回合過程看成是類加載的過程，之后老板的每一刀都看成是創(chuàng)建一次對象。

連貫起來就是static變量值在類第一次加載的時(shí)候分配空間，以后創(chuàng)建類對象的時(shí)候不會(huì)重新分配

之后這個(gè)老板挨了一刀之后躺醫(yī)院了一年，一出院回到公司第一件事就是拉程序員宜春出來玩耍，老板殊不知其然，這個(gè)博主程序員宜春性格異常暴躁，老板遞給程序員宜春一把菜刀，博主宜春一接過菜刀，猝不及防的被老板跳起來就是一刀，程序員宜春痛的嗷了一聲，暴躁的程序員宜春還沒嗷完，在嗷的同時(shí)跳起來就是給老板一刀，接著老板跳起來又是一刀，程序員宜春嗷的一聲又是回一刀，老板跳起來又一刀，程序員宜春嗷的一聲又是回一刀，只要老板沒停程序員宜春就沒停，因?yàn)槌绦騿T宜春知道，就自己這曝脾氣，暴躁起來si都敢摸，肯定有幾個(gè)老鐵知道....

程序員宜春就類似實(shí)例變量，每次創(chuàng)建對象，都會(huì)為每個(gè)對象分配成員變量內(nèi)存空間，就像老板來一刀，程序員宜春都會(huì)回一刀這樣子的...

6、訪問靜態(tài)變量和實(shí)例變量的兩種方式

我們都知道靜態(tài)變量是屬于這個(gè)類，而不是屬于是對象，static獨(dú)立于對象。

但是各位有木有想過：靜態(tài)成員變量雖然獨(dú)立于對象，但是不代表不可以通過對象去訪問，所有的靜態(tài)方法和靜態(tài)變量都可以通過對象訪問【只要訪問權(quán)限足夠允許就行】，不理解沒關(guān)系，來個(gè)代碼就理解了

public class StaticDemo {

        static int value = 666;

        public static void main(String[] args) throws Exception{
            new StaticDemo().method();
        }

        private void method(){
            int value = 123;
            System.out.println(this.value);
        }

}

猜想一下結(jié)果，我猜你的結(jié)果是123，哈哈是咩？其實(shí)

運(yùn)行結(jié)果： 666

回過頭再去品味一下上面的那段話，你就能非常客觀明了了，這個(gè)思想概念要有只是這種用法不推薦！

因此小結(jié)一下訪問靜態(tài)變量和實(shí)例變量的兩種方法：

靜態(tài)變量：

類名.靜態(tài)變量

對象.靜態(tài)變量(不推薦)

靜態(tài)方法：

類名.靜態(tài)方法

對象.靜態(tài)方法(不推薦)

7、static靜態(tài)方法

static修飾的方法也叫做靜態(tài)方法，不知道各位發(fā)現(xiàn)咩有，其實(shí)我們最熟悉的static靜態(tài)方法就是main方法了~小白童鞋：喔好像真的是哦~。由于對于靜態(tài)方法來說是不屬于任何實(shí)例對象的，this指的是當(dāng)前對象，因?yàn)閟tatic靜態(tài)方法不屬于任何對象，所以就談不上this了。

還有一點(diǎn)就是：構(gòu)造方法不是靜態(tài)方法！

8、static靜態(tài)代碼塊

先看個(gè)程序吧，看看自個(gè)是否掌握了static代碼塊，下面程序代碼繼承關(guān)系為 BaseThree——> BaseTwo——> BaseOne

BaseOne類

package com.gx.initializationblock;

public class BaseOne {

    public BaseOne() {
        System.out.println("BaseOne構(gòu)造器");
    }

    {
        System.out.println("BaseOne初始化塊");
        System.out.println();
    }

    static {
        System.out.println("BaseOne靜態(tài)初始化塊");

    }

}

BaseTwo類

package com.gx.initializationblock;

public class BaseTwo extends BaseOne {
    public BaseTwo() {
        System.out.println("BaseTwo構(gòu)造器");
    }

    {
        System.out.println("BaseTwo初始化塊");
    }

    static {
        System.out.println("BaseTwo靜態(tài)初始化塊");
    }
}

BaseThree 類

package com.gx.initializationblock;

public class BaseThree extends BaseTwo {
    public BaseThree() {
        System.out.println("BaseThree構(gòu)造器");
    }

    {
        System.out.println("BaseThree初始化塊");
    }

    static {
        System.out.println("BaseThree靜態(tài)初始化塊");
    }
}

測試demo2類

package com.gx.initializationblock;

/*
     注：這里的ABC對應(yīng)BaseOne、BaseTwo、BaseThree 
 * 多個(gè)類的繼承中初始化塊、靜態(tài)初始化塊、構(gòu)造器的執(zhí)行順序
     在繼承中，先后執(zhí)行父類A的靜態(tài)塊，父類B的靜態(tài)塊，最后子類的靜態(tài)塊，
     然后再執(zhí)行父類A的非靜態(tài)塊和構(gòu)造器，然后是B類的非靜態(tài)塊和構(gòu)造器，最后執(zhí)行子類的非靜態(tài)塊和構(gòu)造器
 */
public class Demo2 {
    public static void main(String[] args) {
        BaseThree baseThree = new BaseThree();
        System.out.println("-----");
        BaseThree baseThree2 = new BaseThree();

    }
}

運(yùn)行結(jié)果

BaseOne靜態(tài)初始化塊
BaseTwo靜態(tài)初始化塊
BaseThree靜態(tài)初始化塊
BaseOne初始化塊

BaseOne構(gòu)造器
BaseTwo初始化塊
BaseTwo構(gòu)造器
BaseThree初始化塊
BaseThree構(gòu)造器
-----
BaseOne初始化塊

BaseOne構(gòu)造器
BaseTwo初始化塊
BaseTwo構(gòu)造器
BaseThree初始化塊
BaseThree構(gòu)造器

至于static代碼塊運(yùn)行結(jié)果不是很清晰的童鞋，詳細(xì)講解請看這篇Static靜態(tài)代碼塊以及各代碼塊之間的執(zhí)行順序

以上僅僅是讓各位明確代碼塊之間的運(yùn)行順序，顯然還是不夠的，靜態(tài)代碼塊通常用來對靜態(tài)變量進(jìn)行一些初始化操作，比如定義枚舉類，代碼如下：

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進(jìn)行初始化
    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;
    }
}　

當(dāng)然不僅僅是枚舉這一方面，還有我們熟悉的單例模式同樣也用到了靜態(tài)代碼塊，如下：

public class Singleton {
    private static Singleton instance;
 
    static {
        instance = new Singleton();
    }
 
    private Singleton() {}
 
    public static Singleton getInstance() {
        return instance;
    }
}

9、static變量與普通變量區(qū)別

static變量也稱作靜態(tài)變量，靜態(tài)變量和非靜態(tài)變量的區(qū)別是：靜態(tài)變量被所有的對象所共享，在內(nèi)存中只有一個(gè)副本，它當(dāng)且僅當(dāng)在類初次加載時(shí)會(huì)被初始化。而非靜態(tài)變量是對象所擁有的，在創(chuàng)建對象的時(shí)候被初始化，存在多個(gè)副本，各個(gè)對象擁有的副本互不影響。

還有一點(diǎn)就是static成員變量的初始化順序按照定義的順序進(jìn)行初始化。

10、靜態(tài)內(nèi)部類

靜態(tài)內(nèi)部類與非靜態(tài)內(nèi)部類之間存在一個(gè)最大的區(qū)別，我們知道非靜態(tài)內(nèi)部類在編譯完成之后會(huì)隱含地保存著一個(gè)引用，該引用是指向創(chuàng)建它的外圍內(nèi)，但是靜態(tài)內(nèi)部類卻沒有。沒有這個(gè)引用就意味著：

1、它的創(chuàng)建是不需要依賴外圍類的創(chuàng)建。
2、它不能使用任何外圍類的非static成員變量和方法。

代碼舉例（靜態(tài)內(nèi)部類實(shí)現(xiàn)單例模式）

public class Singleton {
    
   // 聲明為 private 避免調(diào)用默認(rèn)構(gòu)造方法創(chuàng)建對象
    private Singleton() {
    }
    
   // 聲明為 private 表明靜態(tài)內(nèi)部該類只能在該 Singleton 類中被訪問
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }
}

當(dāng) Singleton 類加載時(shí)，靜態(tài)內(nèi)部類 SingletonHolder 沒有被加載進(jìn)內(nèi)存。只有當(dāng)調(diào)用 getUniqueInstance()方法從而觸發(fā) SingletonHolder.INSTANCE 時(shí) SingletonHolder 才會(huì)被加載，此時(shí)初始化 INSTANCE 實(shí)例，并且 JVM 能確保 INSTANCE 只被實(shí)例化一次。

這種方式不僅具有延遲初始化的好處，而且由 JVM 提供了對線程安全的支持。

11、靜態(tài)導(dǎo)包

靜態(tài)導(dǎo)包格式：import static

這兩個(gè)關(guān)鍵字連用可以指定導(dǎo)入某個(gè)類中的指定靜態(tài)資源，并且不需要使用類名調(diào)用類中靜態(tài)成員，可以直接使用類中靜態(tài)成員變量和成員方法

//  Math. --- 將Math中的所有靜態(tài)資源導(dǎo)入，這時(shí)候可以直接使用里面的靜態(tài)方法，而不用通過類名進(jìn)行調(diào)用
//  如果只想導(dǎo)入單一某個(gè)靜態(tài)方法，只需要將換成對應(yīng)的方法名即可
 
import static java.lang.Math.;
//  換成import static java.lang.Math.max;具有一樣的效果
 
public class Demo {
    public static void main(String[] args) {
 
        int max = max(1,2);
        System.out.println(max);
    }
}

靜態(tài)導(dǎo)包在書寫代碼的時(shí)候確實(shí)能省一點(diǎn)代碼，可以直接調(diào)用里面的靜態(tài)成員，但是會(huì)影響代碼可讀性，所以開發(fā)中一般情況下不建議這么使用。

12、static注意事項(xiàng)

1、靜態(tài)只能訪問靜態(tài)。
2、非靜態(tài)既可以訪問非靜態(tài)的，也可以訪問靜態(tài)的。

13、final與static的藕斷絲連

到這里文章本該結(jié)束了的，但是static的使用始終離不開final字眼，二者可謂藕斷絲連，常常繁見，我覺得還是很有必要講講，那么一起來看看下面這個(gè)程序吧。

package Demo;

class FinalDemo {
    public final double i = Math.random();
    public static double t = Math.random();
}

public class DemoDemo {
    public static void main(String[] args) {

        FinalDemo demo1 = new FinalDemo();
        FinalDemo demo2 = new FinalDemo();
        System.out.println("final修飾的  i=" + demo1.i);
        System.out.println("static修飾的 t=" + demo1.t);
        System.out.println("final修飾的  i=" + demo2.i);
        System.out.println("static修飾的 t=" + demo2.t);

        System.out.println("t+1= "+ ++demo2.t );
//      System.out.println( ++demo2.i );//編譯失敗
      }
}
運(yùn)行結(jié)果：
    final修飾的  i=0.7282093281367935
    static修飾的 t=0.30720545678577604
    final修飾的  i=0.8106990945706758
    static修飾的 t=0.30720545678577604
    t+1= 1.307205456785776

static修飾的變量沒有發(fā)生變化是因?yàn)?span style="color:red">static作用于成員變量只是用來表示保存一份副本，其不會(huì)發(fā)生變化。怎么理解這個(gè)副本呢？其實(shí)static修飾的在類加載的時(shí)候就加載完成了（初始化），而且只會(huì)加載一次也就是說初始化一次，所以不會(huì)發(fā)生變化！

至于final修飾的反而發(fā)生變化了？是不是巔覆你對final的看法？關(guān)于final詳細(xì)講解博主也準(zhǔn)備好了一篇文章程序員你真的理解final關(guān)鍵字嗎？

ok,文章就先到這里了，希望這篇文章能夠幫助到你對static的認(rèn)識，若有不足或者不正之處，希望諒解并歡迎批評指正！

本文來自?java入門?欄目，歡迎學(xué)習(xí)！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!