构造代码块、静态代码块、局部代码块
构造代码块
作用：可以为所有对象进行同样的初始化(初始化可以代表执行一个方法)
每次调用构造函数，都会执行一次
构造代码块的调用时机：
子类先super()调用父类构造函数，
再对成员变量进行显示初始化，
然后才调用构造代码块，
最后通过构造函数的入参进行初始化！
构造代码块与构造函数功能上的区别：
构造代码块（通用代码块，负责统一方法的调用）
---> 具有初始化对象的通用性，可以为所有对象进行相同的操作；
构造函数（特性代码块，专门对特有数据进行初始化，不负责方法的调用）
---> 具有初始化对象的针对性,针对每个对象做特定的初始化；
这样做的好处：职责分明，结构清晰！
使用构造代码块完成对象初始化的统一操作
注意：成员变量的初始化过程
public class ConstructCode {
private String name;
private String sex = "男";//显示初始化
//构造代码块
{
//每次创建对象都会先调用这个方法
notice();
}
//构造函数：负责对特性的数据进行初始化
public ConstructCode(String name) {
//默认初始化，name=null,sex=null
//--->super();
//--->显示初始化,sex="男",name=null
//--->构造代码块
this.name = name;//最后对name进行初始化
}
public void notice() {
System.out.println("通知：马上进来一个新同学！");
System.out.println("性别:"+sex+"，姓名:"+name);
}
public void welcome() {
System.out.println("welcome:"+this.name);
}
public static void main(String[] args) {
ConstructCode c = new ConstructCode("xiaoqiang");
c.welcome();
}
}
结果：
通知：马上进来一个新同学！
性别:男，姓名:null
welcome:xiaoqiang
==========================================================
静态代码块
作用：为类进行初始化
随着类的加载而执行，只执行一次（类只加载一次）
一般，当一个类中的方法都是静态的，则有可能使用静态代码块完成初始化；
如果类中有非静态方法，一般都通过构造函数进行初始化；
如，ClassA中存在的都是静态方法，方法M()用来返回数据库的基础数据
则，可以在静态代码块中执行数据库的访问操作,随着类的加载，这段代码就自动执行了，很妙！
使用静态代码块进行初始化
import java.util.List;
import java.util.Map;
public class StaticCode {
public static List<Map> baseData;
static
{
//查询数据库
Configuration cfg = new Configuration().configure();
SessionFactory sfactory = cfg.buildSessionFactory();
Session session = sfactory.openSession();
String hql = "select new map(n.name as name,n.age as age,n.birthday as birthday) from ContactPerson n where id > :lid and id < :mid";
baseData = session.createQuery(hql).setParameter("lid", 10)
.setParameter("mid", 20).list();
}
public static Map getBaseData() {
return baseData;
}
}
==========================================================
构造代码块与静态代码块的执行时机
代码块与构造函数谁先执行，代码块能执行多少次？
只有创建对象，构造代码块才会执行，因为构造代码块是在构造函数调用的，每次创建对象都会执行1遍！
public class Child {
int num = 10;
{
//先super()，再显示初始化，再调用构造代码块
System.out.println("构造代码块：num="+num);
num = 20;
}
public Child() {
//此时num的值为默认初始值0
super();
//--->进行显示初始化,此时num的值变为10
//--->执行构造代码块,num被改为了20
System.out.println("Child constructor run, num="+num);
}
public void method() {
System.out.println("Child.method()");
}
}
结果：
构造代码块：num=10
Child constructor run, num=20
静态代码块与主函数谁先执行，静态代码块能执行多少次？
类一旦被加载，其中的静态代码块就会执行，而且只执行1次，因为类就加载1次！
基于这个特定，才应用到对类做一些初始化操作。
public class Test{
{
System.out.println("构造代码块与对象有关系，创建对象才会执行");
}
public static void main(String[] args) {
//静态代码块随着类的加载就会被执行--->先执行静态代码块
//main()被JVM调用才得到执行--->类加载完成后，才可能被JVM调用类中main()方法，所以main()后执行
System.out.println("main running...");
}
/* ---------------------------------------------
|运行结果：
|静态代码块与类有关系，随着类的加载而执行，而且只执行一次，only once!
|main running...
---------------------------------------------
*/
static
{
System.out.println("静态代码块与类有关系，随着类的加载而执行，而且只执行一次，only once!");
}
}
==========================================================
局部代码块
方法内部定义的代码块，称为局部代码块，其中定义的变量的生命周期最短。
作用：
方法中，某段代码之后，都不再使用某个变量（这个变量有可能是一个很大的Map集合，很占内存），则可以将其定义到局部代码块中，及时结束其生命周期，释放空间！
public class particalCodeTest {
public static void say() {
{
int count = 10;
for(int i=0;i<count;i++) {
System.out.println(i);
}
}
//代码块结束，count变量所占空间将被立即释放！
System.out.println("局部代码块中定义的变量，生命周期短，用完即释放");
}
public static void main(String[] args) {
say();
}
}