日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

RELATEED CONSULTING
相關咨詢
選擇下列產品馬上在線溝通
服務時間：8:30-17:00
你可能遇到了下面的問題
關閉右側工具欄

新聞中心

這里有您想知道的互聯(lián)網營銷解決方案
ThinkinJava之構造器的真正調用順序

構造器是OOP的重要組成部分，很多人認為它很容易。只不過是new了一個對象而已。而think in java的作者卻告訴我們，其實這并不容易。

先看下面這個例子。在你沒看結果之前，你覺得你的答案是對的么。

 
 
 
    
  
  
  
  1. package com.tudou.t1;  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. class Meal {  
    4. 
  
  
  
  4.     Meal() {  
    5. 
  
  
  
  5.         System.out.println("meal");  
    6. 
  
  
  
  6.     }  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9. class Bread {  
    10. 
  
  
  
  10.     Bread() {  
    11. 
  
  
  
  11.         System.out.println("Bread");  
    12. 
  
  
  
  12.     }  
    13. 
  
  
  
  13. }  
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15. class Cheese {  
    16. 
  
  
  
  16.     Cheese() {  
    17. 
  
  
  
  17.         System.out.println("Cheese");  
    18. 
  
  
  
  18.     }  
    19. 
  
  
  
  19. }  
    20. 
  
  
  
  20.  
    21. 
  
  
  
  21. class Lettuce {  
    22. 
  
  
  
  22.     Lettuce() {  
    23. 
  
  
  
  23.         System.out.println("Lettuce");  
    24. 
  
  
  
  24.     }  
    25. 
  
  
  
  25. }  
    26. 
  
  
  
  26.  
    27. 
  
  
  
  27. class Lunch extends Meal{  
    28. 
  
  
  
  28.     Lunch() {  
    29. 
  
  
  
  29.         System.out.println("Lunch");  
    30. 
  
  
  
  30.     }  
    31. 
  
  
  
  31. }  
    32. 
  
  
  
  32.  
    33. 
  
  
  
  33. class PortableLunch extends Lunch{  
    34. 
  
  
  
  34.     PortableLunch() {  
    35. 
  
  
  
  35.         System.out.println("PortableLunch");  
    36. 
  
  
  
  36.     }  
    37. 
  
  
  
  37. }  
    38. 
  
  
  
  38.  
    39. 
  
  
  
  39. public class Sandwich extends PortableLunch {  
    40. 
  
  
  
  40.     private Bread b = new Bread();  
    41. 
  
  
  
  41.     private Cheese c = new Cheese();  
    42. 
  
  
  
  42.     private Lettuce l = new Lettuce();  
    43. 
  
  
  
  43.  
    44. 
  
  
  
  44.     public Sandwich() {  
    45. 
  
  
  
  45.         System.out.println("Sandwich");  
    46. 
  
  
  
  46.     }  
    47. 
  
  
  
  47.  
    48. 
  
  
  
  48.     public static void main(String[] args) {  
    49. 
  
  
  
  49.         new Sandwich();  
    50. 
  
  
  
  50.     }  
    51. 
  
  
  
  51. }  
    52.

控制臺的打印結果為：

meal 
Lunch 
PortableLunch 
Bread 
Cheese 
Lettuce 
Sandwich

復雜對象調用構造器的順序應該遵循下面的原則：

1、調用基類[即父類]構造器。這個步驟會不斷反復遞歸下去，首先是構造器這種層次結構的根，然后是下一層導出類[即子類]，等等。直到最底層的導出類。[從最上層的meal一直遞歸到PortableLunch]

2、按聲明順序調用成員的初始化方法。[即上面的Bread,Cheese,Lettuce]

3、調用導出類構造器的主體[即Sandwich]

可見，調用類本身是最后完成初始化的，最先完成初始化的是最頂級的基類，所謂沒有父親，哪來的兒子。處于它們中間的是調用類本身擁有的子對象。因為你不可能在子對象初始化之前用本類調用它，所以它一定在本類調用之前，父類調用之后完成初始化的。

那么這個說法是不是一定成立呢。結果是否定的。你必須知道JVM的編繹原理才可能知道，它究竟是如何工作的。

我們來看下面這個例子，來解釋為什么它不一定。因為在繼承和重寫的時候，這種情況變得有點詭異。

深入探究：

 
 
 
    
  
  
  
  1. package com.tudou.t1;  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. public class ConstrcutorTest2 {  
    4. 
  
  
  
  4.     public static void main(String[] args) {  
    5. 
  
  
  
  5.         new RoundGlyph(5);  
    6. 
  
  
  
  6.     }  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9. class Glyph {  
    10. 
  
  
  
  10.  
    11. 
  
  
  
  11.     void draw() {  
    12. 
  
  
  
  12.         System.out.println("Glyph draw()");  
    13. 
  
  
  
  13.     }  
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15.     Glyph() {  
    16. 
  
  
  
  16.         System.out.println("Glyph before draw();");  
    17. 
  
  
  
  17.         draw();  
    18. 
  
  
  
  18.         System.out.println("Glyph after draw();");  
    19. 
  
  
  
  19.     }  
    20. 
  
  
  
  20. }  
    21. 
  
  
  
  21.  
    22. 
  
  
  
  22. class RoundGlyph extends Glyph {  
    23. 
  
  
  
  23.     private int radius = 1;  
    24. 
  
  
  
  24.  
    25. 
  
  
  
  25.     RoundGlyph(int r) {  
    26. 
  
  
  
  26.         radius = r;  
    27. 
  
  
  
  27.         System.out.println("RoundGlyph(),radius:" + radius);  
    28. 
  
  
  
  28.     }  
    29. 
  
  
  
  29.  
    30. 
  
  
  
  30.     void draw() {  
    31. 
  
  
  
  31.         System.out.println("RoundGlyph.draw(),radius:" + radius);//此處打印是0，而不是1  
    32. 
  
  
  
  32.     }  
    33. 
  
  
  
  33. } 
    34.

控制臺打印結果：

Glyph before draw(); 
RoundGlyph.draw(),radius:0 
Glyph after draw(); 
RoundGlyph(),radius:5

為什么RoundGlyph.draw(),radius:0這里會是0呢。

默認的1哪去了？值自己會變么。其實上面的講述并不完整。，而這正是解決謎題的關鍵所在。初始化的實際過程之前，實際在還有一步。

0：在其他任何事物發(fā)生之前，將分配對象的存舍得空間初始化為二進制的零。

而它后面的初始化順序就是上面的3步。

  1. 調用基類[即父類]構造器。這個步驟會不斷反復遞歸下去，首先是構造器這種層次結構的根，然后是下一層導出類[即子類]，等等。直到最底層的導出類。
  2. 按聲明順序調用成員的初始化方法。
  3. 調用導出類構造器的主體

也就是說，實際上有4步，知道這些你對對象初始化構造器才可能有個清楚的認識。

JAVA有更多的精髓等著人們去挖掘，而不僅僅是知道如何去使用它。

因為你不知道什么時候它會出現(xiàn)意想不到的后果，而這個錯誤，可能你根本就想不出來。

編寫構造器時有一條準則：

用盡可能簡單的方法使對象進入正常狀態(tài)，如果可以的話，避免調用其它方法。

在構造器內唯一能夠安全調用的那些方法是基類中的final或者private方法，這些方法不能被覆蓋，因此也就不會出現(xiàn)令人驚訝的問題。

你可能無法總是遵循這條準則，但是應該朝著它努力。

學任何語言，請打好基礎，它是你以后擴展的人生基石。

原文鏈接：http://blog.csdn.net/yaerfeng/article/details/7294882

【編輯推薦】

  1. 用Java編寫你自己的簡單HTTP服務器
  2. Java一次性查詢幾十萬 幾百萬數(shù)據解決辦法
  3. MindTerm 4.0發(fā)布 基于Java的SSH客戶端
  4. 有可能挑戰(zhàn)Java優(yōu)勢的四種技術
  5. Think in Java之斐波那契數(shù)列

網站欄目：ThinkinJava之構造器的真正調用順序
網頁路徑：http://m.5511xx.com/article/coegdpo.html