ThinkinJava之构造器的真正调用顺序

构造器是OOP的重要组成部分，很多人认为它很容易。只不过是new了一个对象而已。而think in java的作者却告诉我们，其实这并不容易。

先看下面这个例子。在你没看结果之前，你觉得你的答案是对的么。

 
 
 
  
  
  package com.tudou.t1;  
  
  
   
  
  
  class Meal {  
  
  
      Meal() {  
  
  
          System.out.println("meal");  
  
  
      }  
  
  
  }  
  
  
   
  
  
  class Bread {  
  
  
      Bread() {  
  
  
          System.out.println("Bread");  
  
  
      }  
  
  
  }  
  
  
   
  
  
  class Cheese {  
  
  
      Cheese() {  
  
  
          System.out.println("Cheese");  
  
  
      }  
  
  
  }  
  
  
   
  
  
  class Lettuce {  
  
  
      Lettuce() {  
  
  
          System.out.println("Lettuce");  
  
  
      }  
  
  
  }  
  
  
   
  
  
  class Lunch extends Meal{  
  
  
      Lunch() {  
  
  
          System.out.println("Lunch");  
  
  
      }  
  
  
  }  
  
  
   
  
  
  class PortableLunch extends Lunch{  
  
  
      PortableLunch() {  
  
  
          System.out.println("PortableLunch");  
  
  
      }  
  
  
  }  
  
  
   
  
  
  public class Sandwich extends PortableLunch {  
  
  
      private Bread b = new Bread();  
  
  
      private Cheese c = new Cheese();  
  
  
      private Lettuce l = new Lettuce();  
  
  
   
  
  
      public Sandwich() {  
  
  
          System.out.println("Sandwich");  
  
  
      }  
  
  
   
  
  
      public static void main(String[] args) {  
  
  
          new Sandwich();  
  
  
      }  
  
  
  }

控制台的打印结果为：

meal 
Lunch 
PortableLunch 
Bread 
Cheese 
Lettuce 
Sandwich

复杂对象调用构造器的顺序应该遵循下面的原则：

1、调用基类[即父类]构造器。这个步骤会不断反复递归下去，首先是构造器这种层次结构的根，然后是下一层导出类[即子类]，等等。直到最底层的导出类。[从最上层的meal一直递归到PortableLunch]

2、按声明顺序调用成员的初始化方法。[即上面的Bread,Cheese,Lettuce]

3、调用导出类构造器的主体[即Sandwich]

可见，调用类本身是最后完成初始化的，最先完成初始化的是最顶级的基类，所谓没有父亲，哪来的儿子。处于它们中间的是调用类本身拥有的子对象。因为你不可能在子对象初始化之前用本类调用它，所以它一定在本类调用之前，父类调用之后完成初始化的。

那么这个说法是不是一定成立呢。结果是否定的。你必须知道JVM的编绎原理才可能知道，它究竟是如何工作的。

我们来看下面这个例子，来解释为什么它不一定。因为在继承和重写的时候，这种情况变得有点诡异。

深入探究：

 
 
 
  
  
  package com.tudou.t1;  
  
  
   
  
  
  public class ConstrcutorTest2 {  
  
  
      public static void main(String[] args) {  
  
  
          new RoundGlyph(5);  
  
  
      }  
  
  
  }  
  
  
   
  
  
  class Glyph {  
  
  
   
  
  
      void draw() {  
  
  
          System.out.println("Glyph draw()");  
  
  
      }  
  
  
   
  
  
      Glyph() {  
  
  
          System.out.println("Glyph before draw();");  
  
  
          draw();  
  
  
          System.out.println("Glyph after draw();");  
  
  
      }  
  
  
  }  
  
  
   
  
  
  class RoundGlyph extends Glyph {  
  
  
      private int radius = 1;  
  
  
   
  
  
      RoundGlyph(int r) {  
  
  
          radius = r;  
  
  
          System.out.println("RoundGlyph(),radius:" + radius);  
  
  
      }  
  
  
   
  
  
      void draw() {  
  
  
          System.out.println("RoundGlyph.draw(),radius:" + radius);//此处打印是0，而不是1  
  
  
      }  
  
  
  }

控制台打印结果：

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

为什么RoundGlyph.draw(),radius:0这里会是0呢。

默认的1哪去了？值自己会变么。其实上面的讲述并不完整。，而这正是解决谜题的关键所在。初始化的实际过程之前，实际在还有一步。

0：在其他任何事物发生之前，将分配对象的存舍得空间初始化为二进制的零。

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

调用基类[即父类]构造器。这个步骤会不断反复递归下去，首先是构造器这种层次结构的根，然后是下一层导出类[即子类]，等等。直到最底层的导出类。
按声明顺序调用成员的初始化方法。
调用导出类构造器的主体

也就是说，实际上有4步，知道这些你对对象初始化构造器才可能有个清楚的认识。

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

因为你不知道什么时候它会出现意想不到的后果，而这个错误，可能你根本就想不出来。

编写构造器时有一条准则：

用尽可能简单的方法使对象进入正常状态，如果可以的话，避免调用其它方法。

在构造器内唯一能够安全调用的那些方法是基类中的final或者private方法，这些方法不能被覆盖，因此也就不会出现令人惊讶的问题。

你可能无法总是遵循这条准则，但是应该朝着它努力。

学任何语言，请打好基础，它是你以后扩展的人生基石。

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

【编辑推荐】

用Java编写你自己的简单HTTP服务器
Java一次性查询几十万几百万数据解决办法
MindTerm 4.0发布基于Java的SSH客户端
有可能挑战Java优势的四种技术
Think in Java之斐波那契数列

网站栏目：ThinkinJava之构造器的真正调用顺序
当前网址：http://www.shufengxianlan.com/qtweb/news37/376937.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：创新互联

猜你还喜欢下面的内容