java笔记（07，类的初始化与构造函数详解）

 

Last modified：2013-04-09 23:45:39

**********************************

 

 关于构造函数：

一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。如果类被public修饰，那么默认的构造函数也带public修饰符。如果类没有被public修饰，那么默认的构造函数，也没有public修饰。

默认构造函数的权限是随着类的变化而变化的。 

 

静态代码块：

格式：

static 

{

静态代码块中的执行语句；

}

 

特点：随着类的加载而执行，只执行一次，并优先于主函数。（当运行到类中东西时，类才加载。）

用于给类进行初始化。（第一次加载类时就会执行是类的初始化，而构造代码块是给所有对象的共性内容进行初始化，是在建立对象的时候才执行。）

 

（类初始化和对象初始化的区别？）

Person  p  =  new  Person("zhangsan",20);

 

这句话都做了什么事情？

0，栈内存分配main中的p空间。

1，因为new用到了Person.class文件，所以会先找到Person.class文件加载到内存中。

2，执行该类中的static代码块，给Person.class类进行初始化。

3，在堆内存中开辟空间，分配内存地址。

4，在堆内存中建立对象的特有属性，并进行默认初始化。

5，对属性进行显示初始化。

6，对对象进行构造代码块初始化。

7，对对象进行对应的构造函数初始化。

8，将内存地址赋给栈内存中的p变量。

初始化顺序：类初始化>>属性默认初始化>>属性显示初始化 >>构造代码块初始化 >>构造函数初始化。

 

 

Java构造函数详解:

构造函数:又叫构造方法，是一种特殊的函数，之所以说他特殊是因为他没有返回值，在创建对象的时候调用。在非构造函数中不可以调用构造函数，构造函数间可以相互调用（通过this关键字）。子类的构造函数也可调用父类的构造方法（通过super关键字）。注意：当构造函数间相互调用时必须在第一行调用！如果编写类时没有定义构造函数，那么系统会默认添加一个空参数的构造函数。

———————————————————————————————————————

当创建一个类时，如 Student stu = new Student();

jvm到底做了些什么？

1.栈内存分配main中的stu空间。

2.因为new用到了Studetn.class文件，所以会先找到Student.class文件加载到内存中。

3.执行父类静态代码块。（类初始化）

4.执行子类静态代码块。（类初始化）

5.在堆内存中建立对象的特有属性，并进行默认初始化。

6.父类显示初始化。**

7.执行父类构造代码块。

8.执行父类构造函数。

9.子类显示初始化。**

10.执行子类构造代码块。

11.执行子类构造函数。

———————————————————————————————————————

验证代码如下：

 

 

class fu{
　　	
       other1 o = new other1();
　　 	
        static{ 	 	
              System.out.println("父类的静态代码块"); 	
         }
　　
　　 {  		
              System.out.println("父类的构造代码块");	 
        }
　　 	
        fu(){ 	
               System.out.println("父类的构造函数"); 	
         }
}

class other1{ 	
        other1(){  		
               System.out.println("父类显示初始化"); 	
         }
}

class other2{	 
         other2(){ 		 
               System.out.println("子类显示初始化"); 	
          }
}

class zi extends fu{ 	
          
          other2 o = new other2(); 	
          
          static{	 
                 System.out.println("子类的静态代码块");	
           }

　　     {	  
                 System.out.println("子类的构造代码块");	
            }

 　　     zi(){ 		 
                  System.out.println("子类的构造函数");	 
             }
}

class Constructor{	
             public static void main(String[] args){ 		 
                     zi zilei = new zi(); 	
             }
}

  ---------------------------------

 

运行结果：
父类的静态代码块
子类的静态代码块

//(执行到这里时，JVM会给子父类的所有属性分配空间并进行默认初始化)
父类显示初始化
父类的构造代码块
父类的构造函数
子类显示初始化
子类的构造代码块
子类的构造函数
----------------------------------

 

 

class X{        
        int xmask = 1;        
        int mask;        
        X(){               
               mask = xmask;                                   
               System.out.println("mask="+mask);//1                
               method();//调用了可以被子类重载的方法，获取的ymask=0；                                            //ymask尚未完成显示初始化。        
            }
        void method(){                
               System.out.println("父类的method方法,xmask="+xmask);
        }
}

 class Y extends X{        
         int ymask = 2;        
         Y(){                
               mask += ymask;                  
               System.out.println("mask="+mask);//3                
               method();         
          }        
          void method(){                
                 System.out.println("子类的method方法,ymask="+ymask);        
          }
}

class Demo4{       
        public static void main(String[] args){                
                  Y test = new Y();        
         }
}

 

---------------------------------

运行结果：
mask=1
子类的method方法,ymask=0
mask=3
子类的method方法,ymask=2

---------------------------------
分析：
子类和父类的构造函数都调用了method方法，
执行的都是子类的method方法，
但是method输出的结果却不一样；
总结：在设计对象构造阶段调用的这些方法必须考虑上面这些因素。
构造函数应该避免调用那些可覆盖的方法，即不是私有的，静态的或final的方法。
如果调用了这些方法，必须在文档中特别说明。

———————————————————————————————————————