Java 初始化块

最新推荐文章于 2023-12-22 17:33:02 发布
最新推荐文章于 2023-12-22 17:33:02 发布
阅读量283 收藏 2
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BOKEhhh/article/details/107456938
版权

【参考】《疯狂Java讲义》

目录

普通初始化块

初始化块对Java对象进行初始化操作

 一个类里面可以有多个初始化块

初始化块里的代码可包含任何可执行性语句

初始化块是Java类的一种成员

实例初始化块、声明实例变量指定的默认值的执行顺序

 编译后的初始化块

静态初始化块（类初始化块）

定义

 初始化块执行顺序问题

继承问题

 类初始化块和声明类变量时所指定的初始值的顺序

改正

普通初始化块

初始化块对Java对象进行初始化操作

如果没有new一个类的对象，那么这个类的初始化块不会执行：

public class Test {
	public static void main(String[] args) {
		System.out.println(">>>开始执行主函数");
	}
}

class A{
	{
		System.out.println(">>>执行A类的初始化块");
	}
}

输出结果：

>>>开始执行主函数

 可见，A类的初始化块没有执行，因为整个程序没有new一个A类的对象。

初始化块会在构造器之前执行，因为先加载类，才能构造对象：

public class Test {
	public static void main(String[] args) {
		System.out.println(">>>这是主函数里的一个语句");
		A a1 = new A();
	}
}

class A{
	{
		System.out.println(">>>执行A类的初始化块");
	}
	
	public A() {
		System.out.println(">>>执行A类的无参构造函数");
	}
}

输出结果：

>>>这是主函数里的一个语句
>>>执行A类的初始化块
>>>执行A类的无参构造函数

要new一个这个类的对象，才能执行这个类的初始化块，例如，改变上面程序主函数中输出语句和new语句的顺序：

public class Test {
	public static void main(String[] args) {
		A a1 = new A();
		System.out.println(">>>这是主函数里的一个语句");
	}
}

class A{
	{
		System.out.println(">>>执行A类的初始化块");
	}
	
	public A() {
		System.out.println(">>>执行A类的无参构造函数");
	}
}

输出结果：

>>>执行A类的初始化块
>>>执行A类的无参构造函数
>>>这是主函数里的一个语句

初始化块对Java对象进行初始化操作，所以，如果new了2个对象，那么会执行2次初始化块：

public class Test {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new A();
	}
}

class A{
	{
		System.out.println(">>>执行A类的初始化块");
	}
	
	public A() {
		System.out.println(">>>执行A类的无参构造函数");
	}
}

 输出结果：

>>>执行A类的初始化块
>>>执行A类的无参构造函数
>>>执行A类的初始化块
>>>执行A类的无参构造函数

 一个类里面可以有多个初始化块

 一个类里面可以有多个初始化块，前面定义的初始化块先执行，后面定义的初始化块后执行：

public class Test {
	public static void main(String[] args) {
		A a1 = new A();
	}
}

class A{
	{
		System.out.println(">>>执行A类的第1个初始化块");
	}
	
	{
		System.out.println(">>>执行A类的第2个初始化块");
	}
	
	public A() {
		System.out.println(">>>执行A类的无参构造函数");
	}
}

输出结果：

>>>执行A类的第1个初始化块
>>>执行A类的第2个初始化块
>>>执行A类的无参构造函数

同样，如果new了2个对象：

public class Test {
	public static void main(String[] args) {
		A a1 = new A();
		A a2 = new A();
	}
}

class A{
	{
		System.out.println(">>>执行A类的第1个初始化块");
	}
	
	{
		System.out.println(">>>执行A类的第2个初始化块");
	}
	
	public A() {
		System.out.println(">>>执行A类的无参构造函数");
	}
}

 输出结果：

>>>执行A类的第1个初始化块
>>>执行A类的第2个初始化块
>>>执行A类的无参构造函数
>>>执行A类的第1个初始化块
>>>执行A类的第2个初始化块
>>>执行A类的无参构造函数

虽然Java允许一个类里定义2个实例初始化块，但这没有任何意义。因为实例初始化块是在创建Java对象时隐式执行的，而且它们总是全部执行，因此完全可以把多个实例初始化块合并成一个实例初始化块，从而可以让程序更加简洁，可读性更强。 

初始化块里的代码可包含任何可执行性语句

 初始化块里的代码可以包含任何可执行性语句，包括定义局部变量、调用其他对象的方法，以及使用分支、循环语句等。

public class Test {
	public static void main(String[] args) {
		A a1 = new A();
		System.out.println("new好的对象的score值：" + a1.score);
	}
}

class A{
	static String name = "JAVASE";
	int id = 3;
	int number;
	int score;
	
	{
		this.number = 10;
		showName();
		System.out.println("id = " + this.id);
		System.out.println("初始化块里面的score值：" + this.score);
		showScore();
	}
	
	public static void showName() {
		System.out.println("name = " + name);
	}
	
	public void showScore() {
		System.out.println(this.score);
	}
	
	public A() {
		score = 20;
	}
}

输出结果：

name = JAVASE
id = 3
初始化块里面的score值：0
0
new好的对象的score值：20

初始化块里的score值和new好的对象的score值，是因为先执行初始化块，再执行构造器，构造器给score赋值20。

初始化块是Java类的一种成员

初始化块是Java类里可出现的第4种成员（前面依次有成员变量、方法和构造器）。

初始化块虽然也是Java类的一种成员，但它没有名字，也就没有标识，因此无法通过类、对象来调用初始化块。实例初始化块只在创建Java对象时隐式执行，而且在构造器执行之前自动执行。类初始化则在类初始化阶段自动执行。

实例初始化块、声明实例变量指定的默认值的执行顺序

实例初始化块、声明实例变量指定的默认值都可认为是对象的初始化代码，它们的执行顺序与源程序中的排列顺序相同。


public class Test {
	public static void main(String[] args) {
		System.out.println(new A().id);
	}
}

class A{
	int id = 3;
	{
		this.id = 4;
	}
}

 输出结果：

4

交换一下顺序：


public class Test {
	public static void main(String[] args) {
		System.out.println(new A().id);
	}
}

class A{
	{
		this.id = 4;
	}
	int id = 3;
}

 输出结果：

3

 可见，实例初始化块、声明实例变量指定的默认值是按代码中的排序顺序执行的。

 编译后的初始化块

实际上实例初始化块是一个假象，使用javac命令编译Java类后，该Java类中的实例初始化块会消失—实例初始化块中代码会被“还原”到每个构造器中，且位于构造器所有代码的前面。

静态初始化块（类初始化块）

定义

如果定义初始化块时使用了static修饰符，则这个初始化块就变成了类初始化块，也被称为静态初始化块（实例初始化块负责对对象执行初始化，类初始化块则负责对类进行初始化）。类初始化块是类相关的，系统将在类初始化阶段执行类初始化块，而不是在创建对象时才执行。因此类初始化块总是比实例初始化块先执行。

同样，没有new对象，也都不执行：


public class Test {
	public static void main(String[] args) {
		System.out.println(">>>开始执行主函数");
	}
}

class A{
	{
		System.out.println(">>>执行A类的实例初始化块");
	}
	static {
		System.out.println(">>>执行A类的类初始化块（静态初始化块）");
	}
}

输出结果：

>>>开始执行主函数

new了对象会执行：


public class Test {
	public static void main(String[] args) {
		A a1 = new A();
	}
}

class A{
	{
		System.out.println(">>>执行A类的实例初始化块");
	}
	static {
		System.out.println(">>>执行A类的类初始化块（静态初始化块）");
	}
}

 输出结果：

>>>执行A类的类初始化块（静态初始化块）
>>>执行A类的实例初始化块

 初始化块执行顺序问题


public class Test {
	
	{
		System.out.println(">>>执行Test类的实例初始化块");
	}
	static {
		System.out.println(">>>执行Test类的类初始化块（静态初始化块）");
	}
	
	public static void main(String[] args) {
		System.out.println(">>>开始执行主函数");
	}
}

输出结果：

>>>执行Test类的类初始化块（静态初始化块）
>>>开始执行主函数


public class Test {
	public static void main(String[] args) {
		System.out.println(">>>开始执行主函数");
	}
	
	{
		System.out.println(">>>执行Test类的实例初始化块");
	}
	static {
		System.out.println(">>>执行Test类的类初始化块（静态初始化块）");
	}
}

 输出结果：

>>>执行Test类的类初始化块（静态初始化块）
>>>开始执行主函数

 类初始化块只会执行一次：


public class Test {
	public static void main(String[] args) {
		System.out.println(">>>开始执行主函数");
		Test t1 = new Test();
		Test t2 = new Test();
	}
	
	{
		System.out.println(">>>执行Test类的实例初始化块");
	}
	static {
		System.out.println(">>>执行Test类的类初始化块（静态初始化块）");
	}
}

输出结果：

>>>执行Test类的类初始化块（静态初始化块）
>>>开始执行主函数
>>>执行Test类的实例初始化块
>>>执行Test类的实例初始化块

继承问题


public class Test {
	public static void main(String[] args) {
		System.out.println(">>>开始执行主函数");
		Bottom t1 = new Bottom();
		Bottom t2 = new Bottom();
	}
}

class Root{
	static {
		System.out.println(">>>Root的类初始化块");
	}
	{
		System.out.println(">>>Root的普通初始化块");
	}
	public Root() {
		System.out.println(">>>Root的无参构造器");
	}
}

class Mid extends Root{
	static {
		System.out.println(">>>Mid的类初始化块");
	}
	{
		System.out.println(">>>Mid的普通初始化块");
	}
	public Mid() {
		System.out.println(">>>Mid的无参构造器");
	}
}

class Bottom extends Mid{
	static {
		System.out.println(">>>Bottom的类初始化块");
	}
	{
		System.out.println(">>>Bottom的普通初始化块");
	}
	public Bottom() {
		System.out.println(">>>Bottom的无参构造器");
	}
}

输出结果：

>>>开始执行主函数
>>>Root的类初始化块
>>>Mid的类初始化块
>>>Bottom的类初始化块
>>>Root的普通初始化块
>>>Root的无参构造器
>>>Mid的普通初始化块
>>>Mid的无参构造器
>>>Bottom的普通初始化块
>>>Bottom的无参构造器
>>>Root的普通初始化块
>>>Root的无参构造器
>>>Mid的普通初始化块
>>>Mid的无参构造器
>>>Bottom的普通初始化块
>>>Bottom的无参构造器


public class Test {
	public static void main(String[] args) {
		System.out.println(">>>开始执行主函数");
		Bottom t1 = new Bottom();
		Bottom t2 = new Bottom();
	}
}

class Root{
	static {
		System.out.println(">>>Root的类初始化块");
	}
	{
		System.out.println(">>>Root的普通初始化块");
	}
	public Root() {
		System.out.println(">>>Root的无参构造器");
	}
}

class Mid extends Root{
	static {
		System.out.println(">>>Mid的类初始化块");
	}
	{
		System.out.println(">>>Mid的普通初始化块");
	}
	public Mid() {
		System.out.println(">>>Mid的无参构造器");
	}
	public Mid(String msg) {
		System.out.println(">>>Mid的带参数构造器 ： +" + msg);
	}
}

class Bottom extends Mid{
	static {
		System.out.println(">>>Bottom的类初始化块");
	}
	{
		System.out.println(">>>Bottom的普通初始化块");
	}
	public Bottom() {
		super("JAVAEE");
		System.out.println(">>>Bottom的无参构造器");
	}
}

 输出结果：

>>>开始执行主函数
>>>Root的类初始化块
>>>Mid的类初始化块
>>>Bottom的类初始化块
>>>Root的普通初始化块
>>>Root的无参构造器
>>>Mid的普通初始化块
>>>Mid的带参数构造器 ： +JAVAEE
>>>Bottom的普通初始化块
>>>Bottom的无参构造器
>>>Root的普通初始化块
>>>Root的无参构造器
>>>Mid的普通初始化块
>>>Mid的带参数构造器 ： +JAVAEE
>>>Bottom的普通初始化块
>>>Bottom的无参构造器

 类初始化块和声明类变量时所指定的初始值的顺序

类初始化块和声明类变量时所指定的初始值都是该类的初始化代码，它们的执行顺序与源程序中的排列顺序相同：


public class Test {
	public static void main(String[] args) {
		System.out.println(A.id);
	}
}

class A{
	static int id = 11;
	static {
		id = 22;
	}
}

输出结果：

22

如果换一下顺序：


public class Test {
	public static void main(String[] args) {
		System.out.println(A.id);
	}
}

class A{
	static {
		id = 22;
	}
	static int id = 11;
}

 输出结果：

11

改正

前面的说法有点小问题，不是只有new对象了才会执行类初始化块，如果主函数就在这个类里面，那么不管new不new，都会执行他的类初始化块，因为要执行这个类的主函数，要先加载这个类。

但还是要new一个对象才能执行普通初始化块。

Kadie_kk
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 初始化块详解
流楚丶格念的博客
07-07 3041
初始化块是类的第4种成员(成员变量、方法、构造器)，与构造器作用有些类似，用于对JAVA对象进行初始化操作。例如： 上述代码输出结果为： 可见，JAVA创建对象时，首先执行初始化块。如果一个类中定义了多个初始化块，则按照顺序执行(这其实没有什么意义，因为初始化块都可以合并为一个)。并且，初始化块在构造器（构造函数）之前执行。二者的区别是：与静态方法、静态成员变量类似，在初始化块之前加上static就变成了静态初始化块。普通初始化块是对象的，负责初始化具体对象； 静态初始化块是类的，负责初始化类。与静态方法相
Java中的初始化块
QueenJade的收录
11-03 8533
在Java中,有两种初始化块:静态初始化块和非静态初始化块. 静态初始化块:使用static定义,当类装载到系统时执行一次.若在静态初始化块中想初始化变量,那仅能初始化类变量,即static修饰的数据成员. 非静态初始化块:在每个对象生成时都会被执行一次,可以初始化类的实例变量. 非静态初始化块会在构造函数执行时,且在构造函数主体代码执行之前被运行. 括号里的是初始化块，这里面的代
JAVA初始化块
tus00000的博客
03-05 322
作用于构造器基本相同，但优先级更高（在执行构造器代码前执行） 语法： 修饰符 { 可执行语句; } 一个例子： class a { int a; { a = 5; } } 修饰符只能是static（静态初始化块）或省略。由于初始化块没有名字，所以只能被隐式地执行。 执行时机： 假设一个类中有两个构造器，这两个构造器中有相同的代码，我们就可以把相同的代码提取出来，加到初始化块中，这样...
java初始化块
qq_983030560的博客
07-11 229
java初始化块讲解
Java初始化块Java初始化块.doc
06-09
总结起来，Java初始化块是Java中用于对象和类初始化的重要工具，它们在不同场景下提供了一种灵活的方式来控制对象和类的状态。理解初始化块的工作原理对于编写高效且无错误的Java代码至关重要。在编写代码时，应谨慎...
Java初始化块及执行过程解析
08-25
"Java初始化块及执行过程解析" Java 初始化块是 Java 语言中的一种特殊语法结构，用于对 Java 对象进行初始化操作。初始化块可以分为两种：静态初始化块和普通初始化块。静态初始化块用于对类进行初始化，而普通...
【Java语言基础】初始化块
01-21
文章目录【Java语言基础】初始化块使用初始化块静态初始化块总结代码 【Java语言基础】初始化块 初始化块又称为代码块。属于类中的第四大成员。本质上是一个方法，它也有方法体，但没有方法名，没有参数，没有返回，...
Java中初始化块详解及实例代码
08-31
"Java初始化块详解及实例代码" Java中初始化块是Java语言中的一种特殊的代码块，它可以在类加载或对象创建时执行某些操作。本文将详细介绍Java中初始化块的概念、种类、特点和应用场景。 什么是初始化块 初始化块...
Java初始化块
chengfu
08-27 423
非静态初始化块会在每个对象生成时被执行一次，可以初始化类的实例变量。 非静态初始化块会在构造函数执行时，在构造函数主体代码执行之前被运行。 静态初始化块会在对象装载到系统的时候执行一次，它仅能初始化类变量，即static修饰的数据成员。
初学Java,初始化块(十三)
javatoyou
02-06 341
初始化块是什么？在Java中就是在构造器之前执行的一段代码，它的用处是，如果一段初始化处理代码对所有对象完全相同，且无须接受任何参数，就可以把这段提取到初始化块中．在C#中，没有初始化块 public class Person { //定义一个初始化块 { int a = 6; //在初始化块中 if (a >4) { System.out.println("P...
java的初始化块
weixin_50179223的博客
10-11 1899
代码初始化块是类的成员之一，每次类的创建会隐式的调用它。本质上是一个代码块，或方法体。 初始化块分为静态初始化块和普通初始化块。其好处是减少多个构造器内重用的代码； 特点1： 普通初始化块：创建对象时隐式调用 静态初始化块：类加载时隐式调用 特点2：静态初始化块只调用一次（类加载时），而普通初始化块可以调用多次，随着对象的创建而加载 特点3： 一个类中可以有多个静态初始化块和多个普通初始化块；静态初始化块的执行要早于普通初始化块；同一个类型的初始化块的执行顺序取决于定义的先后顺序！ 特点4： 在一个类
Java的初始化块
weixin_42556307的博客
05-19 347
1、初始化块就是所有构造器中相同语句构成的一段代码。它在创建java对象时隐式执行，而且在构造器之前执行。 2、java源程序编译时，会将初始化块的代码“还原”到每一个构造器中，并且位于构造器所有代码的前面。 3、初始化块只有一个修饰符static，用来表示该初始化块是否是静态初始化块。 4、在整个类初始化过程中：首先执行静态初始化块，此时不仅仅只执行本类的静态初始化块，还会一直上溯到java.lang.Object类，先执行java.lang.Object类的静态初始化块，然后执行其父类的静态初始化块，最
Java之初始化块
最新发布
weixin_63490470的博客
12-22 395
在Java中，初始化块是一种特殊的代码块，它在对象的构造器执行之前执行。初始化块可以用来初始化实例变量或执行任何需要在构造器执行之前完成的操作。初始化块有两种类型：实例初始化块和静态初始化块。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值