cuiyi's blog（崔毅 crazycy）

請寫出運(yùn)行結(jié)果
1   abstract   class  Glyph {
 2       Glyph() {
 3             System.out.println( " Glyph() before draw() " );
 4             draw();  // 不明白的地方是這里. 
 5            System.out.println( " Glyph() after draw() " );
 6        } 
 7     abstract   void  draw();
 8  } 
 9  
10   class  RoundGlyph  extends  Glyph {
11     private   int  radius  =   1 ;
12     RoundGlyph( int  r) {
13         radius  =  r;
14         System.out.println( " RoundGlyph.RoundGlyph(), radius =  "   +  radius);
15     } 
16
17    void  draw() {
18       // radius = z; 
19         System.out.println( " RoundGlyph.draw(), radius =  "   +  radius);
20    } 
21  } 
22  
23   public   class  PolyConstructors {
24      public   static   void  main(String[] args) {
25              new  RoundGlyph( 5 );
26        } 
27  }

答案
1  Glyph() before draw()
2  RoundGlyph.draw(), radius  =   0 
3  Glyph() after draw()
4  RoundGlyph.RoundGlyph(), radius  =   5

分析
 1類初始化時構(gòu)造函數(shù)調(diào)用順序：
 2 首先加載類，遇到extends字樣會停止加載當(dāng)前類，加載父類，之后再繼續(xù)加載。
 3 當(dāng)把一個類完全加載后，這個類的靜態(tài)成員將被先加載。之后進(jìn)行如下流程：
 4（1）初始化對象的存儲空間為零或null值；
 5（2）調(diào)用父類構(gòu)造函數(shù)；
 6（3）按順序分別調(diào)用類成員變量和實(shí)例成員變量的初始化表達(dá)式；
 7（4）調(diào)用本身構(gòu)造函數(shù)
 8  
 9構(gòu)造函數(shù)的初始化順序：
101 .當(dāng)執(zhí)行new RoundGlyph( 5 )時，首先會加載‘RoundGlyph. class ’,但是這個時候JVM發(fā)現(xiàn) RoundGlyph  extends （繼承于） Glyph ，所以他會加載Glyph. class 
112 .然后會初始化Glyph類的static成員數(shù)據(jù)，這個類沒有static成員數(shù)據(jù)，所以沒有這一步。
123 .會執(zhí)行Glyph類的構(gòu)造函數(shù)Glyph()
134 .接著初始化RoundGlyph類的成員數(shù)據(jù)，最后調(diào)用RoundGlyph()構(gòu)造函數(shù)來生產(chǎn)對象

題目
 1public   class  Test2  extends  Test1  {
 2    {
 3         System.out.print( "  1  " );
 4    } 
 5    Test2()  {
 6         System.out.print( "  2  " );
 7    } 
 8    static   {
 9        System.out.print( "  3  " );
10    } 
11    {
12        System.out.print( "  4  " );
13    } 
14     public   static   void  main(String[] args)  {
15         new  Test2();
16     } 
17} 
18
19class  Test1  {
20    Test1()  {
21        System.out.print( "  5  " );
22    } 
23    static   {
24        System.out.print( "  6  " );
25    } 
26}

答案
1635142

分析
 1( 1 ) 虛擬機(jī)試圖加載Test2，其父類為Test1
 2 ( 2 ) 虛擬機(jī)加載Test1
 3 ( 3 ) Test1靜態(tài)初始化  ----->  輸出 " 6 " 
 4 ( 4 ) 虛擬機(jī)加載Test2
 5 ( 3 ) Test2靜態(tài)初始化  ----->  輸出 " 3 " 
 6 ( 5 )  new  Test2()構(gòu)造Test2首先構(gòu)造父類Test1
 7 ( 6 ) Test1構(gòu)造  ----->  輸出 " 5 " 
 8 ( 7 ) Test2執(zhí)行初始化語句塊(虛擬機(jī)調(diào)用Test2初始化方法init)  ----->  輸出 " 1 " 和 " 4 " 
 9 ( 8 ) Test2構(gòu)造  ----->  輸出 " 2 " 
10 
11 ================================= 
12 先輸出6：
13 因?yàn)楦割惖腟tatic的變量 / 常量會被子類共享
14 所以，首先輸出6
15 接著，會先初始化自身的static的變量 / 常量
16 
17 然后，在構(gòu)造函數(shù)中，會首先調(diào)用父類的默認(rèn)構(gòu)造函數(shù)（如果沒有顯示調(diào)用super(args)的話）
18 在調(diào)用父類構(gòu)造函數(shù)時，在執(zhí)行構(gòu)造函數(shù)體中的數(shù)據(jù)內(nèi)容時，先執(zhí)行方法外的程序段，如變量申明，或者程序段。然后再調(diào)用構(gòu)造函數(shù)中的程序段。
19 然后再執(zhí)行自身的構(gòu)造函數(shù)，執(zhí)行前，也如上述說：在執(zhí)行本構(gòu)造函數(shù)體中的數(shù)據(jù)內(nèi)容時，先執(zhí)行方法外的程序段，如變量申明，或者程序段。然后再調(diào)用構(gòu)造函數(shù)中的程序段。
20 
21 這就是一個對象的實(shí)例化過程。

題目
 1public class CalC {
 2    void amethod(){
 3        System.out.println("CalC.amethod");
 4    }
 5    CalC(){
 6        amethod();
 7        System.out.println("Hu?");
 8    }
 9    public static void main(String[] args) {
10        // TODO Auto-generated method stub
11        CalC cc = new CalChild();
12        cc.amethod();
13    }
14}
15class CalChild extends CalC{
16    void amethod(){
17        System.out.println("CalChild.amethod");
18    }
19}

答案
1CalChild.amethod
2Hu?
3CalChild.amethod

實(shí)例方法專用于類的對象，但是在內(nèi)存中只有一份實(shí)例方法供類的所有實(shí)例共享，因?yàn)闉槊總€對象都復(fù)制一份所有實(shí)例方法代價很昂貴。
所以系統(tǒng)中專門有這樣一種機(jī)制來保證：當(dāng)你調(diào)用一個方法時，代碼是按專用于這個對象的方式進(jìn)行，這種機(jī)制就是this。

每個實(shí)例方法都有一個名為this的變量，指的是調(diào)用該方法的當(dāng)前對象。這種機(jī)制是當(dāng)你的方法引用了類的一個實(shí)例變量是由編譯器隱含使用的。

即使對實(shí)例變量的每個引用實(shí)質(zhì)上是有 this. 前綴的

當(dāng)調(diào)用一個實(shí)例方法時，this變量將被設(shè)置成引用它所起作用的特定類對象。

所以的對象都共享這個備份，為了區(qū)分開到底是哪個對象在調(diào)用這個方法，關(guān)鍵的地方就是this的使用。this把調(diào)用方法的上下文對應(yīng)到當(dāng)前對象上。

本例分析：
調(diào)用java中的所有成員變量或者成員函數(shù)都隱含了this。所以這個地方就很明了了：構(gòu)造子類，this指針代表的當(dāng)前對象是子類實(shí)例，子類實(shí)例為啥不調(diào)用自己overriding的方法呢？！

參考分析
CalC cc = new CalChild();這一步也叫“異類搜集”，以父類類型聲明變量作為子類對象的引用，此時子類的所有屬性方法都失效，只有子類中重寫父類的這樣一中方法可以被變量調(diào)用，而不調(diào)用父類的同名方法，從而實(shí)現(xiàn)多態(tài)！
此程序前后兩次打印都是一個原理。。

參考java基礎(chǔ)（一）

<示例4>

題目
 1class   super1{   
 2     {   
 3              System.out.println("super1   ok");   
 4      }   
 5      super1()   {   
 6          System.out.println("3");   
 7      }   
 8  }   
 9    
10  class   Employee   extends   super1{   
11            private   String   name;   
12            private   double   salary=1500.00;   
13            private   Date   birthday;   
14            public   Employee(String   n,Date   DoB){   
15                System.out.println("2");   
16                name=n;   
17                birthday=DoB;   
18            }   
19            public   Employee(String   n){   
20                this(n,null);   
21                System.out.println("4");   
22            }   
23  } 
24  class   Manager   extends   Employee{   
25      {   
26          System.out.println("Manager   ok");   
27      }   
28      private   String   department;   
29      public   Manager(String   n,String   d){   
30            super(n);   
31            department=d;   
32      }   
33  } 
34    
35  public   class   test1{   
36      public   static   void   main(String   args[]){   
37            new   Manager("Smith","sales");   
38      }   
39  }  

答案
1super1   ok
23
32
44
5Manager   ok

你總是可以從派生類構(gòu)造器中調(diào)用一個適當(dāng)?shù)幕A(chǔ)類構(gòu)造器，對基礎(chǔ)類構(gòu)造器的調(diào)用必須放在派生類構(gòu)造器的首位。

如果派生類構(gòu)造器第一個語句不是對基礎(chǔ)類構(gòu)造器的調(diào)用，則編譯器將替你插入一個對默認(rèn)基礎(chǔ)類構(gòu)造器的調(diào)用：super（）

如果你自己定義了自己的構(gòu)造函數(shù)，則編譯器認(rèn)為是你會負(fù)責(zé)一個對象構(gòu)造的全部細(xì)節(jié)問題，包括對默認(rèn)構(gòu)造器的任何要求，編譯器不將管理。

如果你構(gòu)造函數(shù)中要使用super（） super（…） this（） this（…）等字樣，則必須放在第一行。

如果你沒有顯示指定super（） super（…）字樣，系統(tǒng)會在構(gòu)造函數(shù)第一行自動插入super（）字樣；如果你指定了，系統(tǒng)將按你指定的進(jìn)行而不是默認(rèn)的了。

<練習(xí)1>

題目
 1class   B{   
 2      B(){   
 3          System.out.println("B()");   
 4      }   
 5  }   
 6  class   C   extends   B{   
 7      C(){   
 8          System.out.println("C()");   
 9  }   
10    
11  public   class   A{   
12      public   static   void   main(String[]   arg){   
13          new   C();   
14      }   
15  } 

答案
B()   
C()

<練習(xí)2>

題目
 1class   A   {   
 2      public   A()   {   
 3          System.out.println("A's   c   is   here   ");   
 4      }   
 5      void   println()  {   
 6          System.out.println("A's   v   is   here   ");   
 7      }   
 8  }   
 9 class   B   extends   A  {   
10      public   B()   {   
11          System.out.println("B's   c   is   here   ");   
12      }   
13      void   println()  {   
14          System.out.println("B's   v   is   here   ");   
15      }   
16  }   
17  public   class   Chp_4_2  {   
18      public   static   void   main(String[]   args)  {   
19          B   b   =   new   B();  
20      }   
21 }

分析
子類的構(gòu)造函數(shù),除非顯示的寫上super或者super(Object),第一行會被插入super()的

因?yàn)閏lass  B  extends  class  A  ，所以你可以這樣看B的構(gòu)造方法   
public   B()   {  
  super();   
  System.out.println("B's c is here");   
}   
所以A's c is here會輸出

<練習(xí)3>

題目
 1public class JRun1 {
 2public JRun1() {
 3System.out.println(" 構(gòu)造函數(shù)");
 4}
 5static{
 6System.out.println("static{}");
 7}
 8{
 9System.out.println("{}");
10}
11public static void main(String[] args) {
12System.out.println("main()");
13new JRun1();
14}
15}

答案
static{}
main()
{}
構(gòu)造函數(shù)

題目
import java.util.Calendar;

public class SingletonTest{
    private static final SingletonTest instance = new SingletonTest();
    private static final int BIZZ = 100;
    {
        System.out.println(BIZZ);
    }
    private int size = 0;
    private static int YEAR = Calendar.getInstance().get(Calendar.YEAR);
    {
        System.out.println("after generate instance line");
    }
    private SingletonTest() {
        System.out.println("Constructor");
        size = YEAR - 1930;
    }
    public int getSize() {
        return size;
    }
    public static void main(String[] args) {
        System.out.println(instance.getSize());
    }
} 

答案
100
after generate instance line
Constructor
-1930

題目
 1 import java.util.Calendar;
 2 
 3 public class SingletonTest{
 4     private static final SingletonTest instance = new SingletonTest();
 5     private int size = 0;
 6     private static int YEAR = Calendar.getInstance().get(Calendar.YEAR);
 7     {
 8         System.out.println("after generate instance line");
 9     }
10     private SingletonTest() {
11         System.out.println("Constructor");
12         size = YEAR - 1930;
13     }
14     public int getSize() {
15         return size;
16     }
17     public static void main(String[] args) {
18         System.out.println(instance.getSize());
19     }
20 } 

答案
1 after generate instance line
2 Constructor
3 -1930

題目
 1 import java.util.Calendar;
 2 
 3 public class SingletonTest{
 4     private static final int BIZZ = 100;
 5     {
 6         System.out.println(BIZZ);
 7     }
 8     private int size = 0;
 9     private static int YEAR = Calendar.getInstance().get(Calendar.YEAR);
10     private static final SingletonTest instance = new SingletonTest();
11     {
12         System.out.println("after generate instance line");
13     }
14     private SingletonTest() {
15         System.out.println("Constructor");
16         size = YEAR - 1930;
17     }
18     public int getSize() {
19         return size;
20     }
21     public static void main(String[] args) {
22         System.out.println(instance.getSize());
23     }
24 } 

 <練習(xí)>

題目
 1public class Parent {
 2  public void test(){ }
 3  public Parent(){
 4         test();
 5     }
 6  public static void main(String[] args){
 7         new Child();
 8     }
 9}
10
11class Child extends Parent{
12        private int instanceValue = 20;
13    public void test(){
14            System.out.println("instance value is: " + instanceValue);
15       }
16  }
17看輸入結(jié)果是什么？

答案
0

分析
 1（網(wǎng)友）花之劍：定義實(shí)例變量instanceValue（默認(rèn)為０）－＞調(diào)用父類無參構(gòu)造方法－＞調(diào)用子類的test()（因多態(tài)性，test被重寫）－＞構(gòu)造方法結(jié)束－＞實(shí)例變量的初始化，此時instanceValue＝20
 2
 3（網(wǎng)友）花之劍：
 41.如果子類無自己的構(gòu)造方法，子類默認(rèn)繼承父類無形參構(gòu)造方法
 5順序應(yīng)該是：
 6定義實(shí)例變量instanceValue（默認(rèn)為０）－＞調(diào)用父類無參構(gòu)造方法－＞調(diào)用子類的test()（因多態(tài)性，test被重寫）－＞構(gòu)造方法結(jié)束－＞實(shí)例變量的初始化，此時instanceValue＝20
 72.如果子類有自己的構(gòu)造方法，子類構(gòu)造方法第一行默認(rèn)super().
 8順序應(yīng)該是：
 9定義實(shí)例變量instanceValue（默認(rèn)為０）－＞調(diào)用父類無參構(gòu)造方法－＞調(diào)用子類的test()（因多態(tài)性，test被重寫）－＞父類無形參構(gòu)造方法結(jié)束－>實(shí)例變量的初始化，此時instanceValue＝20 -->子類的構(gòu)造方法。
10
11public class Parent{
12  public void test(){}
13  public Parent(){
14    test();
15  }
16  public static void main(String[] args){
17    new Child();
18  }
19}
20
21class Child extends Parent{
22  private int instanceValue = 20;
23  public Child(){
24     //super();
25     System.out.println("instance value is: " + instanceValue);
26  }
27  public void test(){
28     System.out.println("instance value is: " + instanceValue);
29  }
30}