static

骑车带着你去看日出

话说李大明白和相亲对象小馨见了2次面了，经历了

逛公园（爱情终结者）

看电影（并非一成不变）

做核酸（做个守规矩的人）

然后北京又经历了一波疫情，两个人好久没有约见面了，更多的是通过微信聊天。

经过国家的努力与每个人的配合，疫情趋于稳定。

于是李大明白约小馨出去爬山，因为疫情在家办公，人都要废了，所以约了爬山，活动活动。

两个人约定到某个地铁站门口集合，然后骑共享单车去山脚下。

两人准时来到地铁站门口，地铁站门口有美团的共享单车，于是两个人就每人扫了一辆，骑了大概十几分钟，就到了山脚下不远处的共享单车停车处。

于是两人停下车，开始了爬山之旅。

爬到一半的时候，李大明白又开始了他的脱单得逼得。也就是以下对话：

李：共享单车是真方便，很多时候公交车来的慢了，找一个共享单车骑，很节省时间。

馨：是呀，我刚到北京的时候还有小黄车，现在也不多了。

李：可别说了，小黄车还欠我押金没退呢。

馨：哈哈哈，没有欠我的，我当时用的少。

李：共享单车，很像我们Java中的一个关键字。

馨：哦？是吗

李：是的，关键字叫static

static关键字可以用于变量、方法、代码块和内部类，表示某个成员属于类本身，而不是类对象。

1、静态变量

静态变量也叫类变量，他是属于某个类的，而不是某个类对象。

我们下边举个例子：

package vip.freeedu;

/**
 * @author 木子的昼夜编程
 * 女娲造人
 */
public class NvWa {
    // 记录总共造了几个人
    private static int count;
    // 记录自己造的人数
    private  int myCount;
    // 造人方法 每次造一个人 就让总记录+1
    public void createPerson(){
        new Person();
        count++;
        myCount++;
    }

    public static void main(String[] args) {

        NvWa nvWa01 = new NvWa();
        // 开始造人
        for (int i = 0; i < 10; i++) {
            nvWa01.createPerson();
        }
        NvWa nvWa02 = new NvWa();
        // 开始造人
        for (int i = 0; i < 10; i++) {
            nvWa02.createPerson();
        }
        System.out.println("女娲1号造人："+nvWa01.myCount);
        System.out.println("女娲2号造人："+nvWa02.myCount);
        System.out.println("总人数："+ NvWa.count);
    }
}
// 人
class Person{
    {
        System.out.println("造人+1");
    }
}


输出结果：
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
造人+1
女娲1号造人：10
女娲2号造人：10
总人数：20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

我们可以看到，两个女娲造人，没用static 修饰的myCount都是10，

但是用static修饰的count输出结果是20 。

由于静态变量属于一个类，所以不能通过对象来访问，比如：

2. 我们在什么业务场景中会用呢

​ 表示常量，比如一年12个月，一般我们会配合final进行使用

​ 表示最大值、最小值、范围、常用信息等

​ 我们看源码的时候，随处可见，比如Integer的源码中：

2、静态方法

静态方法我们是太熟悉，太熟悉了，基本上每个人的项目中都有一个日期转换工具类，这个类里边的方法都是静态的。

我们项目可能还会有一些ExcelUtils,大多数也是static 方法

我们也常用一些apache的一些工具类比如：CollectionUtils 、StringUtils 、FileUtils

Java自带的java.lang.Math里边也有很多静态方法

我们简单说一下静态方法的注意事项

1. 静态方法是再编译时解析的，静态方法不能被重写（方法重写发生在运行时阶段）
2. 抽象方法不能是静态的
3. 成员方法（非静态方法）可以直接访问静态方法
4. 静态方法可以访问静态方法，不能访问成员方法

3、 静态代码块

静态代码块，顾名思义，就是静态的代码块（说了，但是又好像没说，像不像你的领导下给你出谋划策）

静态代码块可以用来初始化静态变量，我们偶尔会这样用。

我们需要初始化一些静态的值，可以用配置，可以用字典，也可以代码写死。

package vip.freeedu;
import java.util.HashMap;
import java.util.Map;

/**
 * @author 木子的昼夜编程
 */
public class test {
    // 初始化map1
    static Map<String, String> map1 = new HashMap<>();
    static {
        map1.put("01","大帅哥");
        map1.put("02","小奶狗");
        map1.put("03","身体好");
        map1.put("04","大叔");
    }

    public static void main(String[] args) {
        System.out.println(map1.get("01"));
        System.out.println(map1.get("02"));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

当然了，我们也可以这样初始化

package test;

import java.util.HashMap;
import java.util.Map;

/**
 * @author 木子的昼夜编程
 */
public class StaticTest {
    // 初始化map1
    static Map<String, String> map1 = new HashMap<>();
    static {
        map1.put("01","大帅哥");
        map1.put("02","小奶狗");
        map1.put("03","身体好");
        map1.put("04","大叔");
    }

    // 初始化map2  Java8新特性
    static Map<String, String> map2 = new HashMap<String, String>(){{
        put("01","大帅哥");
        put("02","小奶狗");
        put("03","身体好");
        put("04","大叔");
    }};

    // java9
    Map.of("01", "大帅哥", "02", "小奶狗");//不可变集合

    // Guava工具类
    Map<String, Integer> myMap = ImmutableMap.of("01", "大帅哥", "02", "小奶狗", "03", "身体好");

    
    public static void main(String[] args) {
        System.out.println(map1.get("01"));
        System.out.println(map1.get("02"));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

4、 静态内部类

静态内部类，我就不多说了，做Java的应该都被问过，单例模式

单例模式的一种

package test;

/**
 * @author 木子的昼夜编程
 */
public class Singleton {
    private Singleton() {}

    private static class SingletonHolder {
        public static final Singleton instance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

利用了Java自己的安全的类加载方式来实现单例。

馨：今天又学到了，但是这跟共享单车有啥关系

李：你想想，如果没有共享单车，

如果你需要骑车，你需要先买一个车，然后再骑，这就像我们平时需要使用某个类的方法，我们需要先创建对象（或者注入，也是创建对象），然后再使用，否则会空指针异常

但是共享单车不一样，如果路上有，你就可以扫码骑车，这就像我们使用静态方法或者属性，不需要创建对象，直接使用即可。

馨：哦，好像是这样子的

李：哈哈，突然间想到了这个技术。我们接着爬山吧

馨：好的。