所谓的代码块就是一段独立的代码空间，那什么是静态代码块呢？说白了，静态代码块就是用static修饰的代码块，关于静态代码块的概念不多说，不过你需要知道它的一个特点，那就是
随着类的加载而执行，而且只执行一次
用代码验证静态代码块随着类的加载而执行，且执行一次
class StaticDemo{
//静态代码块
static {
System.out.println("静态代码块被执行");
}
void show(){
System.out.println("方法被执行");
}
}
public class StaticTest {
/**
- 静态代码块的特点：
- 随着类的加载而执行，而且只执行一次
*/
public static void main(String[] args){
new StaticDemo().show();
new StaticDemo().show();
}
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
执行结果如下
由输出结果我们可以看见，最先被打印的是静态代码块的输出内容，这就说明在加载类的时候是先执行了静态代码块的内容，随后调用了类中的方法，当再次创建实例调用方法的时候只有方法被调用了，而静态代码块不再执行，因此，静态代码块的特点是随着类的加载而执行，而且只执行一次！
与main函数的执行顺序
其实猜也猜得到静态代码块是先于main函数执行的，不过始终是眼见为实，让我们来用代码验证一下吧！
public class StaticTest {
/**
- 静态代码块的特点：
- 随着类的加载而执行，而且只执行一次
- 静态代码块的执行顺序优先于main函数
*/
static {
System.out.println("a");
}
public static void main(String[] hq){
System.out.println("b");
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
我们看执行结果，输出如下
代码验证结果依然是静态代码块优先于main函数执行，其实这是必然的，因为静态代码块是随着类的加载而执行。
为了让你我都更明白静态代码块的执行情况，接下来我们来一个稍微复杂点的，我们看看在继承当中的情况，代码如下
class StaticDemo{
//静态代码块
static {
System.out.println("父类静态代码块被执行");
}
void show(){
System.out.println("父类方法被执行");
}
}
public class StaticTest extends StaticDemo {
/**
- 静态代码块的特点：
- 随着类的加载而执行，而且只执行一次
- 静态代码块额执行顺序优先于main函数
*/
static {
System.out.println("子类静态代码块被执行");
}
void show(){
System.out.println("子类方法被执行");
}
public static void main(String[] hq){
System.out.println("main函数");
StaticTest staticTest = new StaticTest();
}
}
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
我们先来看以上代码，你能猜出以上代码的运行结果是什么吗？还是先看下结果吧
和你想的一样吗？我们知道静态代码块的加载是随着类的加载而执行，当执行main函数之前，StaticTest这个类被加载，而这个类又是继承自StaticDemo，因此会最先执行StaticDemo中的静态代码块，然后再执行StaticTest中的静态代码块，最后再执行main函数中的输出语句。
接下来我们再加上构造方法和非静态代码块，接下来的代码希望你能经常看看，那么静态代码块这块就足够了。
class StaticDemo{
//静态代码块
static {
System.out.println("父类静态代码块被执行");
}
//非静态代码块
{
System.out.println("父类非静态代码块被执行");
}
//构造方法
StaticDemo(){
System.out.println("父类构造方法被执行");
}
}
public class StaticTest extends StaticDemo {
/**
- 静态代码块的特点：
- 随着类的加载而执行，而且只执行一次
- 静态代码块额执行顺序优先于main函数
*/
static {
System.out.println("子类静态代码块被执行");
}
//非静态代码块
{
System.out.println("子类非静态代码块被执行");
}
StaticTest(){
System.out.println("子类构造方法被执行");
}
public static void main(String[] hq){
System.out.println("main函数");
new StaticTest();
}
}
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
你猜猜以上代码执行之后的输出结果是什么？我们来看最终的运行结果
总结
通过以上输出我们能总结出什么呢？
总结：静态代码块会随着类的加载而执行，而且只执行一次。当new StaticTest()开始执行的时候会先去执行父类中的静态代码块，然后再执行子类中的静态代码块，当所有的静态代码块都执行结束后会执行main函数中的输出语句（前提是输出语句在new StaticTest()之前），然后会去执行父类中的非静态代码块，接着是父类中的构造方法，紧接着执行子类中的非静态代码块，最后是子类中的构造方法，完事！
