类的成员之四：代码块(初始化块)

b站学习视频以及笔记-尚硅谷_Java零基础教程

java入门必备-适合初学者的全套完整版教程(宋红康主讲)

类的成员之四：代码块(初始化块)

类的成员之四：代码块(初始化块)（重要性较属性、方法、构造器差一些）

1. 代码块的作用：用来初始化类、对象的信息

2. 分类：代码块要是使用修饰符，只能使用static

3. 分类：静态代码块 vs 非静态代码块

静态代码块：

内部可以输出语句
随着类的加载而执行,而且只执行一次
作用：初始化类的信息
如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

非静态代码块：

内部可以输出语句
随着对象的创建而执行
每创建一个对象，就执行一次非静态代码块
作用：可以在创建对象时，对对象的属性等进行初始化
如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

public class BlockTest {
	public static void main(String[] args) {
		
		
		//先加载静态代码块
		//hello,static block-2
		//hello,static block-1
		//我是一个快乐的人
		String desc = Person.desc;
		
		System.out.println(desc);
		//我是一个爱学习的人
		
		Person p1 = new Person();
		//创建对象后加载非静态类
				//hello, block - 2
				//hello, block - 1
				//吃饭
				//我是一个快乐的人
		Person p2 = new Person();
				//hello, block - 2
				//hello, block - 1
				//吃饭
				//我是一个快乐的人
		System.out.println(p1.age);//1
		System.out.println(p1.desc);//我是一个不爱学习的人
		System.out.println(desc);//我是一个爱学习的人
		
		Person.info();//我是一个快乐的人
	}
}


class Person{
	//属性
	String name;
	
	int age;

	static String desc = "我是一个人";
	
	//构造器
	public Person(){
		
	}
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	
	//非static的代码块
	{
		System.out.println("hello, block - 2");
	}
	{
		System.out.println("hello, block - 1");
		//调用非静态结构
		age = 1;
		eat();
		//调用静态结构
		desc = "我是一个不爱学习的人";
		info();
	}
	//static的代码块
	static{
		System.out.println("hello,static block-2");
	}
	static{
		System.out.println("hello,static block-1");
		//调用静态结构
		desc = "我是一个爱学习的人";
		info();
		//不可以调用非静态结构
//		eat();
//		name = "Tom";
	}
	
	//方法
	public void eat(){
		System.out.println("吃饭");
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	public static void info(){
		System.out.println("我是一个快乐的人！");
	}
	
}

4. 实例化子类对象时，涉及到父类、子类中静态代码块、非静态代码块、构造器的加载顺序：

由父及子，静态先行。

题一：

//总结：由父及子，静态先行
class Root{
	static{
		System.out.println("Root的静态初始化块");//①
	}
	{
		System.out.println("Root的普通初始化块");//⑧
	}
	public Root(){
		super();//⑦
		System.out.println("Root的无参数的构造器");//⑨
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid的静态初始化块");//②
	}
	{
		System.out.println("Mid的普通初始化块");//⑩
	}
	public Mid(){
		super();//⑥
		System.out.println("Mid的无参数的构造器");//11
	}
	public Mid(String msg){
		//通过this调用同一类中重载的构造器
		this();//⑤
		System.out.println("Mid的带参数构造器，其参数值："
			+ msg);//12
	}
}
class Leaf extends Mid{
	static{
		System.out.println("Leaf的静态初始化块");//③
	}
	{
		System.out.println("Leaf的普通初始化块");//13
	}	
	public Leaf(){
		//通过super调用父类中有一个字符串参数的构造器
		super("小涛");//④
		System.out.println("Leaf的构造器");//14
	}
}
public class LeafTest{
	public static void main(String[] args){
		//Root的静态初始化块
		//Mid的静态初始化块
		//Leaf的静态初始化块
//		new Leaf(); 
//		Root的普通初始化块
//		Root的无参数的构造器
//		Mid的普通初始化块
//		Mid的无参数的构造器
//		Mid的带参数构造器，其参数值：小涛
//		Leaf的普通初始化块
//		Leaf的构造器
		

		System.out.println();
		new Leaf();
		//Root的普通初始化块
		//Root的无参数的构造器
		//Mid的普通初始化块
//		Mid的无参数的构造器
//		Mid的带参数构造器，其参数值：小涛
		//Leaf的普通初始化块
//		Leaf的构造器
	}
}

结果：

题二：

package com.atguigu.java3;

class Father {
	static {
		System.out.println("11111111111");
	}
	{
		System.out.println("22222222222");
	}

	public Father() {
		System.out.println("33333333333");

	}

}

public class Son extends Father {
	static {
		System.out.println("44444444444");
	}
	{
		System.out.println("55555555555");
	}
	public Son() {
		System.out.println("66666666666");
	}


	public static void main(String[] args) { // 由父及子 静态先行
		//因为main()方法也是个静态方法，所以在调用该方法时会加载该方法的所在类，
		//加载Son类就会继续加载他的父类Father,就会先加载静态代码块
		//11111111111
		//44444444444
		System.out.println("77777777777");
		//77777777777
		System.out.println("************************");
		
		new Son();
		//new一个对象时，由于上面静态代码块只加载一次，所以在这里就会加载父类的普通代码块和构造器，
		//然后加载子类的普通代码块和构造器
		//22222222222
		//33333333333
		//55555555555
		//66666666666
		System.out.println("************************");
		new Son();
		//new一个对象时，由于上面静态代码块只加载一次，所以在这里就会加载父类的普通代码块和构造器，
		//然后加载子类的普通代码块和构造器
		//22222222222
		//33333333333
		//55555555555
		//66666666666
		System.out.println("************************");
		new Father();
		//直接加载父类的普通代码块和构造器
		//22222222222
		//33333333333

	}

}

结果：

5. 属性的赋值顺序

①默认初始化

②显式初始化/(同级)⑤在代码块中赋值//就看谁写在后面，赋的值最后结果就为谁。

③构造器中初始化

④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值

执行的先后顺序：① - ② / ⑤ - ③ - ④

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();
        System.out.println(order.orderId);//4,代码块初始化和显示初始化就看谁写在后面
        System.out.println(order.test);//3
    }
}

class Order{


    int orderId = 3;
    {
        orderId = 4;
    }
	static int test = 4;
	static{
		 test = 3;
	}

}