类中各属性的初始化顺序 ,构造器和初始化块

对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序以此是（静态变量、静态初始化块）>（变量、初始化块）>构造器。我们可以通过下面的测试代码来验证这一点： 

Java代码 

public class InitialOrderTest {       
      
    // 静态变量       
    public static String staticField = "静态变量";       
    // 变量       
    public String field = "变量";       
      
    // 静态初始化块       
    static {       
        System.out.println(staticField);       
        System.out.println("静态初始化块");       
    }       
      
    // 初始化块       
    {       
        System.out.println(field);       
        System.out.println("初始化块");       
    }       
      
    // 构造器       
    public InitialOrderTest() {       
        System.out.println("构造器");       
    }       
      
    public static void main(String[] args) {       
        new InitialOrderTest();       
    }       
}   

    运行以上代码，我们会得到如下的输出结果： 
静态变量 
静态初始化块 
变量 
初始化块 
构造器 

这与上文中说的完全符合。那么对于继承情况下又会怎样呢？我们仍然以一段测试代码来获取最终结果： 


Java代码 
  

class Parent {       
    // 静态变量       
    public static String p_StaticField = "父类--静态变量";       
    // 变量       
    public String p_Field = "父类--变量";       
      
    // 静态初始化块       
    static {       
        System.out.println(p_StaticField);       
        System.out.println("父类--静态初始化块");       
    }       
      
    // 初始化块       
    {       
        System.out.println(p_Field);       
        System.out.println("父类--初始化块");       
    }       
      
    // 构造器       
    public Parent() {       
        System.out.println("父类--构造器");       
    }       
}       
      
public class SubClass extends Parent {       
    // 静态变量       
    public static String s_StaticField = "子类--静态变量";       
    // 变量       
    public String s_Field = "子类--变量";       
    // 静态初始化块       
    static {       
        System.out.println(s_StaticField);       
        System.out.println("子类--静态初始化块");       
    }       
    // 初始化块       
    {       
        System.out.println(s_Field);       
        System.out.println("子类--初始化块");       
    }       
      
    // 构造器       
    public SubClass() {       
        System.out.println("子类--构造器");       
    }       
      
    // 程序入口       
    public static void main(String[] args) {       
        new SubClass();       
    }       
}    

运行一下上面的代码，结果马上呈现在我们的眼前： 
父类--静态变量 
父类--静态初始化块 
子类--静态变量 
子类--静态初始化块 
父类--变量 
父类--初始化块 
父类--构造器 
子类--变量 
子类--初始化块 
子类--构造器 

现在，结果已经不言自明了。大家可能会注意到一点，那就是，并不是父类完全初始化完毕后才进行子类的初始化，实际上子类的静态变量和静态初始化块的初始化是在父类的变量、初始化块和构造器初始化之前就完成了。 

那么对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？实际上这取决于它们在类中出现的先后顺序。我们以静态变量和静态初始化块为例来进行说明。 

同样，我们还是写一个类来进行测试： 


Java代码 
   class TestA {

    public TestA() {
        System.out.println("Test--A");
    }
}

class TestB {
    public TestB() {
        System.out.println("Test--B");
    }
}

public class TestOrder {

    // 静态变量
    public static TestA a = new TestA();

    // 静态初始化块
    static {
        System.out.println("静态初始化块");
    }

    // 静态变量
    public static TestB b = new TestB();

    public static void main(String[] args) {
        new TestOrder();
    }
}





 运行上面的代码，会得到如下的结果： Test--A 静态初始化块 Test--B 大家可以随意改变变量a、变量b以及静态初始化块的前后位置，就会发现输出结果随着它们在类中出现的前后顺序而改变，这就说明静态变量和静态初始化块是依照他们在类中的定义顺序进行初始化的。同样，变量和初始化块也遵循这个规律。 
了解了继承情况下类的初始化顺序之后，如何判断最终输出结果就迎刃而解了


总结：

1,构造器的语法格式

修饰符:public private,protected,default
类名:构造器的名字必须和类名一致
参数列表
2,构造器的返回值类型
  构造器不能定义返回值的类型,如果定义了返回值的类型,编译并不会报错,因为JVM已经把所谓的构造器当做是一个普通的方法.没有返回值类型并不是没有返回值,构造器有返回值的,返回的是当前类的对象,因此构造器的返回值类型总是当前类,因此没有定义返回值的类型.可以理解为构造器的返回值是隐式的.
3默认的构造器, 
   如果程序中没有显示的定义构造器,系统会默认的给程序一个无参的构造器.一旦加了构造器,默认的构造器就不存在了.
4,构造器是创建对象的重要途径,是不是说构造器就完全负责创建对象呢?
不是,构造器是创建对象的重要途径,同构new 关键字来调用构造器也可以返回一个该类实例,但是这个过程并不是完全有构造器执行的.
 实际上,在系统调用构造器的时候,系统会先为该对象分配内存空间,为对象的成员变量赋初值,这个时候对象就已经产生了---这些操作都是在构造器的执行体之前执行的.也就是说,在构造器的执行体执行之前,对象就已经存在了,只是不能被外部的程序调用,构造体执行之后,对象就可以被外部的程序调用了.
5,构造器的重载
         public class ConstructorDemo {
    private int a ;
   
    private String s;
   
    public ConstructorDemo() {
    }
   
    public ConstructorDemo(int a ){
       this.a = a;
    }
   
    public ConstructorDemo (String s,int a){
       this(a);
       this.s = s;
    }
}
6,初始化块(代码块)
初始化块可以当做是Java程序里面的一种成员,代码块又分为:静态代码块和非静态的代码块,一个类中可以有多个代码块,代码块之间执行的顺序是根据代码块在程序中的位置来决定.静态的代码块总是比非静态的代码块先执行
非静态代码块:可以把它当做是类的成员属性来理解.每次创建对象的时候都会执行一遍是属于成员变量
静态的代码块:同样的可以把它理解成类变量,只有在加载类的时候才会执行.
程序对属性进行初始化的顺序是:代码块à属性声明时候指定的初始值à构造器中指定的值
7,初始化块和构造器
   从某种程度上来讲,可以理解为初始化快是构造器的补充,因为初始化快总是在构造器之前执行,同样也可以对对象初始化.
   与构造器不同的是:初始化块只能执行一段固定的代码,不能够像构造器一样接受参数,而且是对类的所有的对象进行初始化.
    跟构造器一样的,程序在执行的时候不仅会执行当前类的初始化快和构造器,会一直追溯到object类的初始化快和构造器.先执行父类的初始化块和构造器(先初始化块,再构造器),然后再执行当前类的初始化块和构造器.