从今天开始进行基本功的提升，（本人很菜，写的可能不好，欢迎大家提出意见，此外，引用别人的东西，我会全部标识出），我不知道，这个过程会什么时候结束，总之，我会努力的把这个过程记录下来。不想提升技术的程序员不是好程序员。
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);
}
}
这里通过一段简单的代码，引入今天的内容。首先简单了解标题中的各个概念
静态代码块
- 用static声明，每个静态代码块只会执行一次，在JVM加载类的时候会执行静态代码块，注意优先于主函数。
- 静态代码块负责初始化类，因此不能存在于任何方法体内，不存在被对象调用。
- 静态代码块可以有多个，其执行顺序是，先定义，先执行。
构造代码块
- 用{}声明，构造代码块的作用是给对象进行初始化。
- 和静态代码块不同，构造代码块在创对象时被调用，因此，调用次数可能不止一次，也仅仅只能被对象调用，且执行顺序优先于构造函数。
- 构造代码块的作用是给所有对象进行统一的初始化，因为优先级高于构造函数。
构造函数
- 创建对象时，就会调用对应的构造函数，注意实际中构造函数可能不止一个，因此调用不同的构造函数，就会初始化不同实例对象。
- 对象创建时，构造函数只能调用一次。
- 同构造代码块一样，只能被对象调用，不能被类调用。
通过概念的介绍就会清晰地知道上述代码的运行结果
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
继承时，执行顺序
- 执行父类静态代码块，并初始化父类的静态成员变量
- 执行子类静态代码块，并初始化子类的静态成员变量
- 依次执行父类的构造代码块，构造函数，并初始化父类普通的成员变量
- 依次执行子类的构造代码块，构造函数，并初始化子类普通的成员变量
/**
* @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普通代码块，构造代码块，静态代码块区别，执行顺序的代码实例
网友评论