Java基础提升1

从今天开始进行基本功的提升，（本人很菜，写的可能不好，欢迎大家提出意见，此外，引用别人的东西，我会全部标识出），我不知道，这个过程会什么时候结束，总之，我会努力的把这个过程记录下来。不想提升技术的程序员不是好程序员。

Java 静态代码块，构造代码块，构造函数

/**
 * @ClassName: TestA
 * @Description: TODO
 * @Author: kevin
 * @Date: 2019-03-20 19:24
 * @Version: 1.0
 **/
public class TestA {

    static int value = 1;

    static {
        System.out.println("This is TestA 静态代码块");
        value++;
        System.out.println(value);
    }

    {
        System.out.println("This is TestA 构造代码块");
    }
    public TestA() {
        System.out.println("This is TestA 无参构造函数");
    }

    public TestA(String str) {
        System.out.println("This is TestA 有参构造函数: str = " + str);
    }

    public static void main(String[] args) {
        System.out.println("===============");
        TestA a = new TestA();
        System.out.println("---------------");
        TestA b = new TestA("B");
    }
    
    static {
        value *= 2;
        System.out.println(value);
    }
}

这里通过一段简单的代码，引入今天的内容。首先简单了解标题中的各个概念

静态代码块

1. 用static声明，每个静态代码块只会执行一次，在JVM加载类的时候会执行静态代码块，注意优先于主函数。
2. 静态代码块负责初始化类，因此不能存在于任何方法体内，不存在被对象调用。
3. 静态代码块可以有多个，其执行顺序是，先定义，先执行。

构造代码块

1. 用{}声明，构造代码块的作用是给对象进行初始化。
2. 和静态代码块不同，构造代码块在创对象时被调用，因此，调用次数可能不止一次，也仅仅只能被对象调用，且执行顺序优先于构造函数。
3. 构造代码块的作用是给所有对象进行统一的初始化，因为优先级高于构造函数。

构造函数

1. 创建对象时，就会调用对应的构造函数，注意实际中构造函数可能不止一个，因此调用不同的构造函数，就会初始化不同实例对象。
2. 对象创建时，构造函数只能调用一次。
3. 同构造代码块一样，只能被对象调用，不能被类调用。

通过概念的介绍就会清晰地知道上述代码的运行结果

This is TestA 静态代码块
2
4
===============
This is TestA 构造代码块
This is TestA 无参构造函数
---------------
This is TestA 构造代码块
This is TestA 有参构造函数: str = B

静态变量，静态代码块，变量，构造代码块，构造函数，执行的顺序

静态变量，静态代码块 > 变量，构造代码块 > 构造函数

/**
 * @ClassName: TestB
 * @Description: TODO
 * @Author: kevin
 * @Date: 2019-03-20 20:06
 * @Version: 1.0
 **/
public class TestB {
    public static String staticZone = "这是静态变量";

    public String variable;

    public String variable2 = "haha";

    static {
        System.out.println("这是静态代码块");
        System.out.println(staticZone);
    }

    {
        System.out.println("这是构造代码块");
        System.out.println(variable);
        System.out.println(variable2);
        System.out.println(staticZone);
    }

    public TestB() {
        System.out.println("这是无参构造函数");
    }

    public TestB(String str) {
        System.out.println("This is TestB 有参构造函数: str = " + str);
    }

    public static void main(String[] args) {
        System.out.println("========");
        TestB a = new TestB();
        System.out.println("--------");
        TestB b = new TestB("B");
    }
}

运行结果

这是静态代码块
这是静态变量
========
这是构造代码块
null
haha
这是静态变量
这是无参构造函数
--------
这是构造代码块
null
haha
这是静态变量
This is TestB 有参构造函数: str = B

继承时，执行顺序

1. 执行父类静态代码块，并初始化父类的静态成员变量
2. 执行子类静态代码块，并初始化子类的静态成员变量
3. 依次执行父类的构造代码块，构造函数，并初始化父类普通的成员变量
4. 依次执行子类的构造代码块，构造函数，并初始化子类普通的成员变量

/**
 * @ClassName: A
 * @Description: TODO
 * @Author: kevin
 * @Date: 2019-03-20 20:28
 * @Version: 1.0
 **/
public class A {

    static {
        System.out.println("This is A 静态代码块");
    }

    {
        System.out.println("This is A 构造代码块");
    }
    public A() {
        System.out.println("This is A 无参构造函数");
    }

    public A(String str) {
        System.out.println("This is A 有参构造函数: str = " + str);
    }

}


/**
 * @ClassName: B
 * @Description: TODO
 * @Author: kevin
 * @Date: 2019-03-20 20:30
 * @Version: 1.0
 **/
public class B extends A {

    static {
        System.out.println("This is B 静态代码块");
    }

    {
        System.out.println("This is B 构造代码块");
    }
    public B() {
        System.out.println("This is B 无参构造函数");
    }

    public B(String str) {
        System.out.println("This is B 有参构造函数: str = " + str);
    }

    public B(String str, int tmp) {
        super(str);
        System.out.println("This is B 有参构造函数: str = " + str + " tmp = " + tmp);
    }

    public static void main(String[] args) {
        System.out.println("===============");
        B a = new B();
        System.out.println("---------------");
        B b = new B("B");
        System.out.println("---------------");
        B C = new B("C", 6);
    }
}

执行结果，注意实例对象c的执行过程有别于实例对象b。

This is A 静态代码块
This is B 静态代码块
===============
This is A 构造代码块
This is A 无参构造函数
This is B 构造代码块
This is B 无参构造函数
---------------
This is A 构造代码块
This is A 无参构造函数
This is B 构造代码块
This is B 有参构造函数: str = B
---------------
This is A 构造代码块
This is A 有参构造函数: str = C
This is B 构造代码块
This is B 有参构造函数: str = C tmp = 6

参考文章链接
Java提高篇——静态代码块、构造代码块、构造函数以及Java类初始化顺序
Java普通代码块，构造代码块，静态代码块区别，执行顺序的代码实例