代码块怎么使用？

1. 基本介绍

代码化块又称为初始化块,属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{ }包围起来。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

1. 基本语法

[修饰符]{

代码

};

说明注意:

1)修饰符可选，要写的话，也只能写static

2)代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块

3)代码里可以为任何逻辑语句(输入、输出、方法调用、循环、判断等)

4);号可以写上，也可以省略。

1. 代码块的适用场景

当某个类的构造器足够多构成重载时，为了减少每个构造器需要执行的内容重复，减少代码冗余。举例：

package com.kxy.codeBlock;
class Movie{
	String name;
	double price;
	String director;
	{
		System.out.println("电影开始了");
		System.out.println("广告开始了");
		System.out.println("电影结束了");
	}
	public Movie(String name) {
		super();
		this.name = name;
		System.out.println("Movie(name)构造器被调用...");
	}
	public Movie(String name,double price) {
		super();
		this.name = name;
		this.price = price;
		System.out.println("Movie(name,price)构造器被调用...");
	}
	public Movie(String name, double price, String director) {
		super();
		this.name = name;
		this.price = price;
		this.director = director;
		System.out.println("Movie(name,price,director)构造器被调用...");
	}	
}
public class CodeBlock1 {
	public static void main(String[] args) {
		Movie Movie1=new Movie("你好,李焕英");
		Movie Movie2=new Movie("长津湖",100,"xxx");
		Movie Movie3=new Movie("速度与激情9",49);
	}
}

 

电影开始了
广告开始了
电影结束了
Movie(name)构造器被调用...
电影开始了
广告开始了
电影结束了
Movie(name,price,director)构造器被调用...
电影开始了
广告开始了
电影结束了
Movie(name,price)构造器被调用...

总结：

（1）代码块适合在构造器发生重载的时候使用

（2）代码块优先于构造器执行

（3）代码块会在每一个对象，自动执行

代码块的作用和本质：初始化构造器。

下面来研究和讨论静态代码块和普通代码块的进阶细节：

package com.kxy.codeBlockDetail_;
//代码块进阶：细节01：


class B{
	{
		System.out.println("我是B类里的代码块，我被执行了...");
	}
	public B() {
		super();
		System.out.println("B()构造器被调用了...");
	}
}
public class codeBlockDetail01 {
	public static void main(String[] args) {
		//对于静态代码块：
		//静态代码块是随着类的加载而执行的，那么类什么时候被加载呢？
		//1.当new一个对象的时候，类被加载
		B b=new B();
	
	}
}

我是B类里的代码块，我被执行了...
B()构造器被调用了...

当new一个对象的时候，类被加载。随之执行代码块，再调用构造器。优先级:（代码块>构造器）

package com.kxy.codeBlockDetail_;
//代码块进阶：细节01：

class A {
	static{
		System.out.println("我是A类里的代码块，我被执行了...");
	}

	public A() {
		super();
		System.out.println("A()构造器被调用了...");
	}
}

class B extends A {
	static{
		System.out.println("我是B类里的代码块，我被执行了...");
	}

	public B() {
		super();
		System.out.println("B()构造器被调用了...");
	}
}

public class codeBlockDetail01 {
	public static void main(String[] args) {
		// 对于静态代码块：
		// 静态代码块是随着类的加载而执行的，那么类什么时候被加载呢？
	
		// 2.当子类继承父类时，父类先加载，再加载子类
		B b = new B();
	}
}

我是A类里的代码块，我被执行了...
A()构造器被调用了...
我是B类里的代码块，我被执行了...
B()构造器被调用了...

当存在继承关系时，根据继承的本质，先加载基类，再依次加载子类。

package com.kxy.codeBlockDetail_;
//代码块进阶：细节01：

class B  {
	public static int a=100;
	static{
		System.out.println("我是B类里的代码块，我被执行了...");
	}
	public B() {
		System.out.println("我是B类的构造器，我被调用了...");
	}
}

public class codeBlockDetail01 {
	public static void main(String[] args) {
		// 对于静态代码块：
		// 静态代码块是随着类的加载而执行的，那么类什么时候被加载呢？
		// 1.当new一个对象的时候，类被加载
		// 2.当子类继承父类时，父类先加载，再加载子类
		//3.当访问静态成员时，类被加载
		System.out.println(B.a);
	}
}

我是B类里的代码块，我被执行了...
100

3.当访问静态成员时，类被加载，此时静态代码块先被执行，再输出静态成员。优先级：（静态代码块>静态成员）

总结：

1.当new一个对象的时候，类被加载

2.当子类继承父类时，父类先加载，再加载子类

3.当访问静态成员时，类被加载

静态代码块(static代码块)和普通代码块的区别：

1.执行次数不同：静态代码块只能执行一次，而普通代码块new一个对象就执行一次。

2.静态代码块随着类的加载而执行，普通代码块则是随着创建对象（构造器被调用之前）而执行。

3.当访问类的静态成员时，静态代码块会被执行，而普通代码块不会被执行（原因：静态代码块是随着类的加载而执行的，但是普通代码块和类的加载没有关系，因此当访问静态成员时，普通代码块就不会被执行）。