linkin大话面向对象--初始化块

java使用构造器来对单个对象进行初始化操作，使用构造器先完成整个java对象的状态初始化，然后将java对象返回给程序，从而让整个java对象的信息更加完整。与构造器作用非常类似的是初始化块，它也可以对java对象进行初始化操作。

初始化块是构造器的补充，初始化块总是在构造器执行之前执行。

初始化块的基本用法：如果有一段初始化处理代码对所有的对象完全相同，且无需接受任何参数，就可以把这段代码提取到初始化块中。

如果初始化块使用了static修饰，就变成了类初始化块。类初始化块总是比普通初始化先执行，并且只执行一遍。

类初始化块的基本用法：优先于主方法执行，优先于构造代码块执行，不管有创建多少对象，静态代码块只执行一次，可用于给静态变量赋值。

/**
 *
 * @version 1L
 * @author  LinkinPark
 * @since   2014-10-28
 * @motto   梦似烟花心似水，同学少年不言情
 * @desc    ^初始化块代码执行顺序：类初始化块-->普通初始化块-->构造器
 */
public class Linkin {
    private String name;
    static{
        System.out.println("这里是静态代码块。。。");
    }
    {
        System.out.println("这里是普通代码块。。。");
    }
    public Linkin(){
        System.out.println("这里是无参的构造器。。。");
    }
    public Linkin(String name){
        this();
        System.out.println("这里是有参数的构造器。。。");
    }
    public static void main(String[] args) {
        Linkin linkin = new Linkin("LinkinPark");
        Linkin linkin1 = new Linkin();
    }
}

/**
 *
 * @version 1L
 * @author  LinkinPark
 * @since   2014-10-28
 * @motto   梦似烟花心似水，同学少年不言情
 * @desc    ^初始化块代码执行顺序：类初始化块-->普通初始化块-->构造器
 */
public class Linkin extends Person{
    static{
        System.out.println("这里是Linkin静态代码块。。。");
    }
    {
        age = 2;
        System.out.println("这里是Linkin普通代码块。。。");
    }
    int age = 1;
    public Linkin(){
        System.out.println("这里是Linkin无参的构造器。。。");
    }
    public static void main(String[] args) {
        Linkin linkin = new Linkin();
        //java中允许先使用变量，在声明，这面的age开始的时候是2，后来变为了1
        System.out.println(linkin.age);
        Linkin linkin1 = new Linkin();
        //name刚开始是LinkinPark 后来是binger
        System.out.println(Person.name);
    }
}

class Person{
    static{
        name = "LinkinPark";
        System.out.println("这里是Person静态代码块。。。");
    }
    static String name = "binger";
    {
        System.out.println("这里是Person普通代码块。。。"+name);
    }
    public Person(){
        System.out.println("这里是Person无参的构造器。。。");
    }
}

• 一个对象的创建过程

1. 当构造一个对象的时候，系统先构造父类对象，再构造子类对象。

    2. 构造一个对象的顺序：(注意：构造父类对象的时候也是这几步)

       递归地创建父类的 static 成员(即使只调用其子类静态成员，也会先创建父类静态成员)；

       顺序地创建本类的 static 成员(只要调用这个类的属性或方法都需创建一次)；

       递归地创建父类对象(先创建父类非静态成员，再调用父类构造方法)；

       顺序地创建本类非静态成员(包括属性和方法)；

       调用本类的构造方法(它可调用本类或父类的成员，也可调用本类的其他构造方法)。

       创建完成了

• 什么时候类加载

第一次需要使用类信息时加载。

    类加载的原则：延迟加载，能不加载就不加载。

• 触发类加载的几种情况：

(1)、调用静态成员时，会加载静态成员真正所在的类及其父类。         通过子类调用父类的静态成员时，只会加载父类而不会加载子类。

    (2)、第一次 new 对象的时候 加载(第二次再 new 同一个类时，不需再加载)。 

    (3)、加载子类会先加载父类。        注：如果静态属性有 final 修饰时，则不会加载，当成常量使用。

           例：public static final int a =123;        但是如果上面的等式右值改成表达式(且该表达式在编译时不能确定其值)时则会加载类。

           例：public static final int a = math.PI        如果访问的是类的公开静态常量，那么如果编译器在编译的时候能确定这个常量的值，就不会被加载；        如果编译时不能确定其值的话，则运行时加载

• 类加载的顺序：

1.加载静态成员/代码块：

 先递归地加载父类的静态成员/代码块(Object的最先)；再依次加载到本类的静态成员。

 同一个类里的静态成员/代码块，按写代码的顺序加载。

 如果其间调用静态方法，则调用时会先运行静态方法，再继续加载。同一个类里调用静态方法时，可以不理会写代码的顺序。

 调用父类的静态成员，可以像调用自己的一样；但调用其子类的静态成员，必须使用“子类名.成员名”来调用。

2.加载非静态成员/代码块：

 先递归地加载父类的非静态成员/代码块(Object的最先)；再依次加载到本类的非静态成员。

 同一个类里的非静态成员/代码块，按写代码的顺序加载。同一个类里调用方法时，可以不理会写代码的顺序。

 但调用属性时，必须注意加载顺序。一般编译不通过，如果能在加载前调用，值为默认初始值(如：null 或者 0)。

 调用父类的非静态成员(private 除外)，也可以像调用自己的一样。

3.调用构造方法：

 先递归地调用父类的构造方法(Object的最先)；默认调用父类空参的，也可在第一行写明调用父类某个带参的。

 再依次到本类的构造方法；构造方法内，也可在第一行写明调用某个本类其它的构造方法。

  注意：如果加载时遇到 override 的成员，可看作是所需创建的类型赋值给当前类型。

 其调用按多态用法：只有非静态方法有多态；而静态方法、静态属性、非静态属性都没有多态。

 假设子类override父类的所有成员，包括静态成员、非静态属性和非静态方法。

 由于构造子类时会先构造父类；而构造父类时，其所用的静态成员和非静态属性是父类的，但非静态方法却是子类的；

 由于构造父类时，子类并未加载；如果此时所调用的非静态方法里有成员，则这个成员是子类的，且非静态属性是默认初始值的。