1.使用示例

2.静态代码块介绍

   在类中通过static修饰然后大括号里面的内容就是静态代码块。见13.1实例

      static {

}

    静态代码块在类被加载的时候执行，并且他只会执行一次，优先于其他所有代码块以及构造方法执行，如果有多个静态代码块则按编写顺序执行。

     静态代码块在项目启动的时候执行， 静态代码块不能存在方法，主要放一些项目启动就需要加载的配置或者固定资源以及属性。

   比如我们可以放一些固定的正则表达式规则等。

   3. 构造代码块介绍

    在类中没有关键字修饰的大括号里面的内容就是构造代码块。见13.1实例

        {

        }

     构造代码块在构造方法之前静态代码块之后执行，因为构造方法分带参和不带参，所以构造代码块一般执行他们通用功能。

       构造代码块在创建对象的时候都会被调用，每次创建都会执行。

       比如我们可以通过在构造代码块里面统计对象创建次数。    

 4.有参构造方法和无参构造方法介绍

       在类中方法名和类名一致，并无返回值类型的内容就是构造方法。见13.1实例

            类名Test

             public Test(){

}

             public Test(String name){

}

       构造方法在我们创建对象的时候都会被调用，静态代码块以及构造代码块之后执行，当我们创建对象时候传入参数即调用有参构  造方法，不传参数时候调用无参构造方法。

       每一个类会默认有一个隐式的无参构造方法，我们可以直接使用，创建对象，但是当我们新写了带参构造方法时候，这个隐式的无参构造方法就会失效，我们就只能通过这个带参构造方法创建对象。如果我们想不传参创建对象，就得新加一个无参构造方法。

       构造方法的作用主要是用来创建对象，或者创建对象并传入前置一些属性初始化的值。

5.普通代码块介绍

普通代码块又叫局部代码块是放在方法体中，在所有代码块之后执行，并只有调用该方法的时候才会执行。主要是存一些局部变量，因为他会随着方法体的退出而消失，所以他能够减少变量的生命周期，提高内存的使用效率。

     比如一些只有在某个方法才会用到的属性，计算房屋面积的方法中的一些单位等。

6.总结

  执行顺序：

  静态代码块》构造代码块》构造方法》普通代码块

  生命周期

   静态代码块》构造代码块=构造方法》普通代码块

   代码块的作用主要是把一些程序运行中通用固定的操作给抽出来放在一起执行，具体业务场景选择性的使用各种代码块。

1、执行顺序

静态代码块>构造代码块>构造方法

原因：

• 静态代码块（static{}）在类加载的时候执行一次，是最早被执行的。
• 构造代码块（{}内的部分）在每一次创建对象时执行，始终在构造方法前执行。
• 构造方法在新建对象时调用（ 就是new的时候 ）。

注意：

• 静态代码块在类加载的时候就执行，所以它的优先级高于入口main()方法。
• 当三种形式不止一次出现，同优先级是按照先后顺序执行。

程序代码示例：

public class StaticTest {
    public static StaticTest t1 = new StaticTest();
    public static StaticTest t2 = new StaticTest();

    {
        System.out.println("构造块");
    }

    static {
        System.out.println("静态块");
    }

    public static void main(String[] args) {
        StaticTest t = new StaticTest();
    }
}

执行main方法打印结果：

为什么会出现这种打印结果？

拓展知识点：静态域

静态域：分为静态变量，静态方法，静态块。当执行到静态域时，按照静态域的顺序加载。并且静态域只在类的第一次加载时执行。

注意：加载了静态域的一部分，这时候不能再加载另一个静态域了，静态域必须当成一个整体来看待，否则加载会错乱。比如上面的代码，有静态变量和静态代码块儿，当加载了静态变量后，就不能加载静态代码块儿了。

根据代码执行顺序：

（1）执行程序入口main方法时，首先加载类StaticTest
注意：加载类时并不会调用构造块和构造方法，只有静态域会执行
（2）加载类StaticTest，执行静态域的第一个静态变量，StaticTest t1 = new StaticTest();，输出构造块和构造方法（空）。打印出构造块。
（3）由于每次new对象时，会执行一次构造块和构造方法，构造块总是在构造方法前执行，（当然，第一次new时，会先执行静态域，静态域〉构造块〉构造方法）所以执行StaticTest t1 = new StaticTest();时，执行了下面代码：

 	{
        System.out.println("构造块");
    }

（4）同理，StaticTest t1 = new StaticTest();加载完后，以此执行第二个静态变量StaticTest t2 = new StaticTest();，执行构造块代码块。
（5）执行static静态块，完成对整个静态域的加载
（6）最后，再执行main方法，new StaticTest();，执行构造块。

附加：代码中添加了构造方法

public class StaticTest {
    public static StaticTest t1 = new StaticTest();
    public static StaticTest t2 = new StaticTest();

    {
        System.out.println("构造块");
    }

    static {
        System.out.println("静态块");
    }

    public StaticTest() {
        System.out.println("构造方法代码");
    }

    public static void main(String[] args) {
        StaticTest t = new StaticTest();
    }
}

执行main方法的打印结果：

总结：
1、每调用一次构造方法，则执行一次构造块
2、静态块只在类加载的时候加载一次
3、有多个静态变量或块时，按声明顺序加载

2、java中父类和子类代码执行顺序

父类和子类代码执行顺序：

父类静态代码块 =》 子类静态代码块 =》 父类代码块 =》 父类构造方法 =》 子类代码块 =》 子类构造方法

程序代码如下：
1、创建Father和Son类，让Son继承Father
2、编写Father和Son的代码

/**
 * 父类（抽象类）
 */
public abstract class Father {

    static {
        System.out.println("父类静态代码执行了");
    }

    {
        System.out.println("父类非静态代码执行了");
    }

    public Father() {
        System.out.println("父类构造函数代码执行了");
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}

/**
 * 子类（具体类）
 */
public class Son extends Father {

    static {
        System.out.println("子类静态代码执行了");
    }

    {
        System.out.println("子类非静态代码执行了");
    }

    public Son() {
        System.out.println("子类构造函数代码执行了");
    }
}

打印结果：

注意：由于代码的执行顺序不同，经常通过执行顺序进行后端初始化。

拓展链接：
java的static关键字

总结一下：

1.执行顺序：静态代码块>构造代码块>构造方法
理由：静态代码块（static{}）在类加载的时候执行一次。
构造代码块（{}内的部分）在每一次创建对象时执行，始终在构造方法前执行。
构造方法在新建对象时调用（ 就是new的时候 ）。
注意： a.静态代码块在类加载的时候就执行，所以它的优先级高于入口main()方法。
b.当三种形式不止一次出现，同优先级是按照先后顺序执行。

来看一道题巩固一下：

public class B
{
    public static B t1 = new B();
    public static B t2 = new B();
    {
        System.out.println("构造块");
    }
    static
    {
        System.out.println("静态块");
    }
    public static void main(String[] args)
    {
        B t = new B();
    }
}

所以这段代码的输出结果是？

构造块，构造块，静态块，构造块

解释：

1.程序入口main方法要执行首先要加载类B
2.静态域：分为静态变量，静态方法，静态块。这里面涉及到的是静态变量和静态块，当执行到静态域时，按照静态域的顺序加载。并且静态域只在类的第一次加载时执行
3.每次new对象时，会执行一次构造块和构造方法，构造块总是在构造方法前执行（当然，第一次new时，会先执行静态域，静态域〉构造块〉构造方法）
注意：加载类时并不会调用构造块和构造方法，只有静态域会执行
4.根据前三点，首先加载类B，执行静态域的第一个静态变量，static b1=new B，输出构造块和构造方法（空）。ps:这里为什么不加载静态方法呢？因为执行了静态变量的初始化，意味着已经加载了B的静态域的一部分，这时候不能再加载另一个静态域了，否则属于重复加载 了（静态域必须当成一个整体来看待。否则加载会错乱） 于是，依次static b2 =new B，输出构造块，再执行静态块，完成对整个静态域的加载，再执行main方法，new b
链接：https://www.nowcoder.com/questionTerminal/ab6eb06face84c4e81ab5bc6f0f7f258
来源：牛客网

开始时JVM加载B.class，对所有的静态成员进行声明，t1 t2被初始化为默认值，为null，又因为t1 t2需要被显式初始化，所以对t1进行显式初始化，初始化代码块→构造函数（没有就是调用默认的构造函数），咦！静态代码块咋不初始化？因为在开始时已经对static部分进行了初始化，虽然只对static变量进行了初始化，但在初始化t1时也不会再执行static块了，因为JVM认为这是第二次加载类B了，所以static会在t1初始化时被忽略掉，所以直接初始化非static部分，也就是构造块部分（输出’‘构造块’’）接着构造函数（无输出）。接着对t2进行初始化过程同t1相同（输出’构造块’），此时就对所有的static变量都完成了初始化，接着就执行static块部分（输出’静态块’），接着执行，main方法，同样也，new了对象，调用构造函数输出（‘构造块’）
总结：
1、每调用一次构造方法，则执行一次构造块
2、静态块只在类加载的时候加载一次
3、有多个静态变量或块时，按声明顺序加载
下面再看一道题：

public class HelloB extends HelloA {
	
	 public HelloB(){
		 System.out.println("B的构造方法");
	 }
	 {
	     System.out.println("B的构造代码块");
	 }
	 static{
	     System.out.println("B的静态代码块");
	 }
	 //public static HelloB hB = new HelloB();
	 public static void main(String[] args){
	     new HelloB();//调用B的构造方法
	 }
}

class HelloA{
	 public HelloA(){
		 System.out.println("A的构造方法");
	 }
	 {
	     System.out.println("A的构造代码块");
	 }
	 static{
	     System.out.println("A的静态代码块");
	 }
} 

输出的结果大家都应该是知道的：

A的静态代码块
B的静态代码块
A的构造代码块
A的构造方法
B的构造代码块
B的构造方法