static关键字作用总结

小咪咪 2023-07-23 15:59 624阅读 0赞

**前言**

之前讲到final关键字的作用是每次面试的时候我必问求职者的两个问题之一，另外一个问题就是文本会写到的static。final和static一样，都是一个小问题可以看到一个人的基础是否扎实以及平时是否有钻研精神。

> ### final Map可以修改内容，final 常量不能修改 ###
> 
> ### 对比集合： ###
> 
> final Map map =new HashMap();  
> final List list =new ArrayList();
> 
> map和list 对应的是栈中存储的地址，final表示地址不能修改，但是地址对应的内存区域的值是可以修改的；
> 
> ### 对比常量： ###
> 
> final String name=”Joke”;  
> final int age=10;
> 
> name和age对应的是栈中存储的地址，同样final表示地址不能修改，但是地址的存储跟常量的值有关，给他重新赋值会指向另外一个对象，地址就改变了
> 
> 如：  
> map集合对应一个hashcode值改变后hashcode不变，但是String常量的值改变了hashcode就也改变了,也就是对应的栈地址变了;

**静态变量和静态方法**

static关键字最基本的用法是：

1、被static修饰的变量属于类变量，可以通过**类名.变量名**直接引用，而不需要new出一个类来

2、被static修饰的方法属于类方法，可以通过**类名.方法名**直接引用，而不需要new出一个类来

被static修饰的变量、被static修饰的方法统一属于类的**静态资源，是类实例之间共享的，换言之，一处变、处处变**。JDK把不同的静态资源放在了不同的类中而不把所有静态资源放在一个类里面，很多人可能想当然认为当然要这么做，但是是否想过为什么要这么做呢？个人认为主要有三个好处：

1、不同的类有自己的静态资源，这可以实现静态资源分类。比如和数学相关的静态资源放在java.lang.Math中，和日历相关的静态资源放在java.util.Calendar中，这样就很清晰了

2、避免重名。不同的类之间有重名的静态变量名、静态方法名也是很正常的，如果所有的都放在一起不可避免的一个问题就是名字重复，这时候怎么办？分类放置就好了。

3、避免静态资源类无限膨胀，这很好理解。

OK，再微微深入一下，也是有些人容易混淆的一个问题：静态方法能不能引用非静态资源？静态方法里面能不能引用静态资源？非静态方法里面能不能引用静态资源？比如就以这段代码为例，是否有错？

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

>     1 public class A
>     2 {
>     3     private int i = 1;
>     4     
>     5     public static void main(String[] args)
>     6     {
>     7         i = 1;
>     8     }
>     9 }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

当然有错，在第7行的地方。不妨这么思考这个问题：

静态资源属于类，但是是独立于类存在的。从JVM的类加载机制的角度讲，**静态资源是类初始化的时候加载的，而非静态资源是类new的时候加载的**。类的初始化早于类的new，比如Class.forName(“xxx”)方法，就是初始化了一个类，但是并没有new它，只是加载这个类的静态资源罢了。所以对于静态资源来说，它是不可能知道一个类中有哪些非静态资源的；但是对于非静态资源来说就不一样了，由于它是new出来之后产生的，因此属于类的这些东西它都能认识。所以上面的几个问题答案就很明确了：

1、静态方法能不能引用非静态资源？不能，new的时候才会产生的东西，对于初始化后就存在的静态资源来说，根本不认识它。

2、静态方法里面能不能引用静态资源？可以，因为都是类初始化的时候加载的，大家相互都认识。

3、非静态方法里面能不能引用静态资源？可以，非静态方法就是实例方法，那是new之后才产生的，那么属于类的内容它都认识。

**静态块**

静态块也是static的重要应用之一。也是用于初始化一个类的时候做操作用的，和静态变量、静态方法一样，**静态块里面的代码只执行一次，且只在初始化类的时候执行**。静态块很简单，不过提三个小细节：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

>     1 public class A
>      2 {
>      3     private static int a = B();
>      4     
>      5     static
>      6     {
>      7         System.out.println("Enter A.static block");
>      8     }
>      9     
>     10     public static void main(String[] args)
>     11     {
>     12         new A();
>     13     }
>     14     
>     15     public static int B()
>     16     {
>     17         System.out.println("Enter A.B()");
>     18         return 1;
>     19     }
>     20 }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

打印结果是：

>     Enter A.B()
>     Enter A.static block

得出第一个结论：**静态资源的加载顺序是严格按照静态资源的定义顺序来加载的**。这和周志明老师《深入理解Java虚拟机：JVM高级特性与最佳实践》中类初始化中的说法“**<clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态语句块（static\{\}块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的**”是一致的。

再看一个例子：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

>     1 public class A
>      2 {
>      3     static
>      4     {
>      5         c = 3;
>      6         System.out.println(c);
>      7     }
>      8     
>      9     private static int c;
>     10 }
> 
>

这段代码的第6行是有错误的“Cannot reference a field before it is defined”。从这个例子得出第二个结论：**静态代码块对于定义在它之后的静态变量，可以赋值，但是不能访问**。

最后一个小例子：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

>     1 public class A
>      2 {
>      3     static
>      4     {
>      5         System.out.println("A.static block");
>      6     }
>      7     
>      8     public A()
>      9     {
>     10         System.out.println("A.constructor()");
>     11     }
>     12 }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

> ![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]
> 
>     1 public class B extends A
>      2 {
>      3     static 
>      4     {
>      5         System.out.println("B.static block");
>      6     }
>      7     
>      8     public B()
>      9     {
>     10         System.out.println("B.constructor()");
>     11     }
>     12     
>     13     public static void main(String[] args)
>     14     {
>     15         new B();
>     16         new B();
>     17     }
>     18 }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

结果是

>     A.static block
>     B.static block
>     A.constructor()
>     B.constructor()
>     A.constructor()
>     B.constructor()

这个例子得出第三个结论：**静态代码块是严格按照父类静态代码块->子类静态代码块的顺序加载的，且只加载一次**。

**static修饰类**

这个用得相对比前面的用法少多了，static一般情况下来说是不可以修饰类的，如果static要修饰一个类，说明这个类是一个静态内部类（注意static只能修饰一个内部类），也就是匿名内部类。像线程池ThreadPoolExecutor中的四种拒绝机制CallerRunsPolicy、AbortPolicy、DiscardPolicy、DiscardOldestPolicy就是静态内部类。静态内部类相关内容会在写内部类的时候专门讲到。

**import static**

这个比较冷门，基本很少看见有地方用，使用JUnit可能会用到，写assert的时候会方便些。import static是JDK1.5之后的新特性，这两个关键字连用可以指定导入某个类中的指定静态资源，并且不需要使用类名.资源名，可以直接使用资源名。注意一下，**import static**必须这么写，而不能写成static import。举个例子来看一下：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

>     1 import static java.lang.Math.*;
>     2 
>     3 public class A
>     4 {
>     5     public static void main(String[] args)
>     6     {
>     7         System.out.println(sin(2.2));
>     8     }
>     9 }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

这么写意味着我导入了Math下的所有静态资源，main函数里面我就可以直接用sin(2.2)而不需要使用Math.sin(2.2)了。注意一下，要写**import static java.lang.Math.\***，最后的“.\*”不可少，有了这两个字符才意味着导入的是Math下的所有静态资源，写成import static java.lang.Math是有问题的。当然，我们也可以指定只导入某个静态资源，比如只导入Math下sin这个方法而不导入Math下的所有静态资源：

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

>     1 import static java.lang.Math.sin;
>     2 
>     3 public class A
>     4 {
>     5     public static void main(String[] args)
>     6     {
>     7         System.out.println(sin(2.2));
>     8     }
>     9 }

![复制代码][aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]

这么写也是没问题的。导入静态变量也是一样，有兴趣的可以自己试一下。对于import static，个人的态度是：

1、简化了一些操作，比如静态导入Math下的所有静态资源，在频繁使用Math类下静态资源的地方，可以少些很多“Math.”

2、降低了代码的可读性

建议在某些场景下导入特定的静态资源，不建议使用“.\*”的导入方式。

--------------------

1 public class A
     2 {
     3     static
     4     {
     5         c = 3;
     6         System.out.println(c); // 报错说非法的前向引用（ps: 不能在字段定义之前使用）
     11          // 此处编译可以通过。2
     12          System.out.println(A.c);//输出的是类变量  是可以访问的
     7     }
     8     
     9     private static int c;
    10 }

1 public class A 2 \{ 3 static 4 \{ 5 c = 3; 6 System.out.println(c); 7 \} 8 9 private static int c; 10 \}public class TestStatic \{  
static\{  
c=3;  
// 此处编译不通过。 1  
// System.out.println(c);  
// 此处编译可以通过。2  
System.out.println(TestStatic.c);  
\}  
private static int c;  
\}  
这1和2处的c有何不同？

1: Java是一门解释型语言，(码的代码，编译后，运行时顺序)它并不是按照代码流程一句一句执行下来的，而是在编译阶段先生成中间的.class文件，再去解释.class文件，从而保证了跨平台特性。  
  
我把这段代码生成的.class文件反编译了一下查看一下生成的字节码指令：  
Constant pool:  
\#1 = Class \#2 // com/xrq/test/A  
\#2 = Utf8 com/xrq/test/A  
\#3 = Class \#4 // java/lang/Object  
\#4 = Utf8 java/lang/Object  
\#5 = Utf8 c  
\#6 = Utf8 I  
\#7 = Utf8 <clinit>  
\#8 = Utf8 ()V  
\#9 = Utf8 Code  
\#10 = Fieldref \#1.\#11 // com/xrq/test/A.c:I  
\#11 = NameAndType \#5:\#6 // c:I  
\#12 = Utf8 LineNumberTable  
\#13 = Utf8 LocalVariableTable  
\#14 = Utf8 <init>  
\#15 = Methodref \#3.\#16 // java/lang/Object."<init>":()V  
\#16 = NameAndType \#14:\#8 // "<init>":()V  
\#17 = Utf8 this  
\#18 = Utf8 Lcom/xrq/test/A;  
\#19 = Utf8 SourceFile  
\#20 = Utf8 A.java  
\{  
static \{\};  
flags: ACC\_STATIC  
Code:  
stack=1, locals=0, args\_size=0  
0: iconst\_3  
1: putstatic \#10 // Field c:I  
4: return  
LineNumberTable:  
line 7: 0  
line 3: 4  
LocalVariableTable:  
Start Length Slot Name Signature  
......  
  
后面的就不列了。看到c这个静态变量在编译完毕之后是生成到Constant pool也就是常量池里面的，估计是因为编译的时候是先编译的静态常量，再编译的静态方法（可以看到常量池的内容在上面先生成，方法的内容在下面后生成），所以static块的putstatic这条字节码指令可以拿到静态变量c的直接引用地址。

[aHR0cHM6Ly9jb21tb24uY25ibG9ncy5jb20vaW1hZ2VzL2NvcHljb2RlLmdpZg]: /images/20230528/9156cf1abbb54c5c93ef21ce0e3e3e9c.png