第十天

代码初始化块是类的成员之一，每次类的创建会隐式的调用它。本质上是一个代码块，或方法体。

初始化块分为静态初始化块和普通初始化块。其好处是减少多个构造器内重用的代码；

特点1：

普通初始化块：创建对象时隐式调用

静态初始化块：类加载时隐式调用

 

package coursetest;
public class TestMain {
        public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("coursetest.Test");//作用就是将参数指定的类加载到JVM
         Test test = new Test();         // 初始化 Test类
        }                                      
}
class Test{
    //初始化块有两种，普通的初始化块，静态的初始化块
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("普通的初始化块");
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("静态的初始化块");
    }
}
//输出结果：静态的初始化块
//          普通的初始化块

特点2：

静态初始化块只调用一次（类加载时），而普通初始化块可以调用多次，随着对象的创建而加载

 

package coursetest;
public class TestMain {
        public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("coursetest.Test");//作用就是将参数指定的类加载到JVM
         Test test = new Test();         // 初始化 Test类
         new Test();//输出结果：静态的初始化块
         new Test();//普通的初始化块
         new Test();//普通的初始化块
         new Test();//普通的初始化块
         new Test();//普通的初始化块
        }           //普通的初始化块                           
}                   //普通的初始化块
class Test{
    //初始化块有两种，普通的初始化块，静态的初始化块
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("普通的初始化块");
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("静态的初始化块");
    }
}

特点3：

一个类中可以有多个静态初始化块和多个普通初始化块；静态初始化块的执行要早于普通初始化块；同一个类型的初始化块的执行顺序取决于定义的先后顺序！

 

package coursetest;
public class TestMain {
        public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("coursetest.Test");//作用就是将参数指定的类加载到JVM
         Test test = new Test();         // 初始化 Test类
        }                                   
}                  
class Test{
    //初始化块有两种，普通的初始化块，静态的初始化块
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("普通的初始化块1");
    }
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("普通的初始化块2");
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("静态的初始化块1");
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("静态的初始化块2");
    }
}//结果如下
//静态的初始化块1
//静态的初始化块2
//普通的初始化块1
//普通的初始化块2

特点4：

在一个类中如果有多个不同的初始化块，初始化属性，构造器，

执行顺序是：静态初始化块 > 普通初始化块 > 构造器

 

package coursetest;
public class TestMain {
        public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("coursetest.Test");//作用就是将参数指定的类加载到JVM
         Test test = new Test();         // 初始化 Test类
        }                                   
}                  
class Test{
    //初始化块有两种，普通的初始化块，静态的初始化块
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("普通的初始化块1");
    }
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("普通的初始化块2");
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("静态的初始化块1");
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("静态的初始化块2");
    }
    public Test() {
        System.out.println("Test的构造器！");
    }
}//结果如下
//静态的初始化块1
//静态的初始化块2
//普通的初始化块1
//普通的初始化块2
//Test的构造器！

特点5：

在父子类中，执行顺序是：

爷爷类的静态初始化块>

父类静态初始化块>

子类静态初始化块>

爷爷类普通初始化块>构造器>

父类普通初始化块>构造器>

子类普通初始化块>构造器

 

package coursetest;
public class TestMain {
        public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("coursetest.Test2");//作用就是将参数指定的类加载到JVM
        new Test2();         // 初始化 Test类
        }                                   
}                  
class Test{
    //初始化块有两种，普通的初始化块，静态的初始化块
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("普通的初始化块");
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("静态的初始化块");
    }
    public Test() {
        System.out.println("Test的构造器！");
    }
}
class Test1 extends Test{
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("Test1的普通的初始化块");
    }
    public Test1() {
        System.out.println("Test1的构造器！");
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("Test1的静态的初始化块");
    }
}
class Test2 extends Test1{
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("Test2的普通的初始化块");
    }
    public Test2() {
        System.out.println("Test2的构造器！");
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("Test2的静态的初始化块");
    }
}
//结果如下
//静态的初始化块
//Test1的静态的初始化块
//Test2的静态的初始化块
//普通的初始化块
//Test的构造器！
//Test1的普通的初始化块
//Test1的构造器！
//Test2的普通的初始化块
//Test2的构造器！

特点6：

静态初始化块中遵循静态成员的特点，只能直接访问静态成员！也就是在静态初始化块只能修改静态成员。

普通初始化块可以初始化普通的变量，也可以初始化静态，构造器可以初始化普通的变量，也可以初始化静态。

package coursetest;
public class TestMain {
        public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("coursetest.Test");//作用就是将参数指定的类加载到JVM
          Test test = new Test();
          System.out.println(test.a+","+Test.b);
        }                                   
}                  
class Test{
    int a;
    static int b;
    //初始化块有两种，普通的初始化块，静态的初始化块
    {  //在有对应Test类被实例化，new关键调用它的构造器的时候，new一次就会执行一次，可以执行多次
        System.out.println("普通的初始化块");
        b=11;
        a=22;
    }
    static {   //初始化块是在程序被加载到内存中的时候，静态的初始化块就会被执行，只会执行一次
        System.out.println("静态的初始化块");
        //a=33;//不允许        静态初始化只能直接访问静态成员
        b=44;
    }
    public Test() {
        a=55;
        b=66;
        System.out.println("Test的构造器！");
    }
}
//结果如下
//静态的初始化块
//普通的初始化块
//Test的构造器！
////55,66

问题：clean一下  或者有同名