程序的执行顺序

Question

[b]
 有如下一个关于类继承的例子，但是弄不清程序里的调用执行顺序，如何理解 new Wolf()这个语句来创建对象，因为平时都是用 Wolf W = new Wolf()这种格式来创建的。
  class Creature
  {
      public  Creature()
      {
          System.out.println("Creature 无参数的构造方法");
       }
    }   class Animal  extends  Creature
   {
       public  Animal(String  name)
        {
          System.out.println("Animal 带一个参数的构造方法，该动物的name为" + name);
         }
        
        public Animal(String name, int age)
         {
           //使用this调用同一个重载的构造方法
            this(name);
            System.out.println("Animal 带两个参数的构造方法，其age为" + age);
          }
      }     public class Wolf extends  Animal
        {
           public Wolf()
            {
               //显式调用父类有两个参数的构造方法
               super("土狼", 3);
               System.out.println("Wolf无参数的构造方法");
             }
            public static void main(String[] args)
             {
                 new Wolf();
              }
          }
   

Answer 1

注释部分为执行顺序class Creature
  {
  public Creature()
  {
  System.out.println("Creature 无参数的构造方法");//1
  }
  }  class Animal extends Creature
  {
  public Animal(String name)
  {
  System.out.println("Animal 带一个参数的构造方法，该动物的name为" + name);//2
  }
   
  public Animal(String name, int age)
  {
  //使用this调用同一个重载的构造方法
  this(name);
  System.out.println("Animal 带两个参数的构造方法，其age为" + age);//3
  }
  }  public class Wolf extends Animal
  {
  public Wolf()
  {
  //显式调用父类有两个参数的构造方法
  super("土狼", 3);
  System.out.println("Wolf无参数的构造方法");//4
  }
  public static void main(String[] args)
  {
  new Wolf();
  }
  }

Answer 2

首先从new Wolf();这句开始表明要调用Wolf的构造函数，里面有个super("土狼", 3);所以又会调用到Animal的构造函数public Animal(String name, int age)，由于里面有一句this(name);所以又会到public Animal(String name)，当然这个函数里面就会有个默认的super()；所以会到
public Creature()
  {
  System.out.println("Creature 无参数的构造方法");
  }
这个方法里面咯。然后就是依次打印了。
System.out.println("Creature 无参数的构造方法");
System.out.println("Animal 带一个参数的构造方法，该动物的name为" + name);
System.out.println("Animal 带两个参数的构造方法，其age为" + age);
System.out.println("Wolf无参数的构造方法");

Answer 3

new Wolf();
就是创建一个Wolf实例
Wolf W = new Wolf()
创建一个Wolf实例，并将实例引用给W.因为面试官想考你的是执行过程。所以省略Wolf W = ...，因为new Wolf()就足够达到执行Wolf构造函数的目的。执行过程，所有类在构造时都会默认先调用父类的构造。
据上，所以执行过程为
1、System.out.println("Creature 无参数的构造方法");
2、System.out.println("Animal 带一个参数的构造方法，该动物的name为" + name);
3、System.out.println("Animal 带两个参数的构造方法，其age为" + age);
4、System.out.println("Wolf无参数的构造方法");

Answer 4

new Wolf()会产生一个匿名对象
如果一个对象只使用一次，那么就可以将其定义为匿名对象。匿名对象比正常的实例化对象少了一个栈内存的引用关系，所以匿名对象是一个只开辟了堆内存的实例对象。

Answer 5

执行结果：Creature 无参数的构造方法
Animal 带一个参数的构造方法，该动物的name为土狼
Animal 带两个参数的构造方法，其age为3
Wolf无参数的构造方法
new wolf()表示创建一个无名实例，与wolf w=new wolf();等效

Answer 6

如何理解 new Wolf()这个语句来创建对象，因为平时都是用 Wolf W = new Wolf()这种格式来创建的。new Wolf() 这种用法也挺多的. 这种用法就是没有对象的引用名, 对象使用完后就不会再显示调用了. 象楼主的例子,对象产生过程中,就干了许多事情,这些事情做完了, 对象也产生好了, 但也不再用了,程序结束了.

Answer 7

关于构造方法的调用问题(父子类之间)：class Super{
static{System.out.println("静态代码块执行...");}
{System.out.println("非静态代码块执行...");}
public Super(){System.out.println("父类无参构造执行...");}
public Super(int test){System.out.println("父类全参构造执行...");}
}
class Sub extends Super{
public Sub(){System.out.println("子类无参构造执行...");}
public Sub(int test){System.out.println("子类全参构造执行...");}
}
class SubTest extends Super{
public SubTest(){//子类无参构造，显调父类有参构造
super(1);
System.out.println("子类无参构造执行");}
public SubTest(int test){
super(1);
System.out.println("子类全参构造执行...");
}
}
public class Test{
public static void main(String[] args) {
// 实例化子类，无参构造
Sub s=new Sub();

//实例化子类，全参构造
Sub s1=new Sub(1);

System.out.println("********华丽分割线********");
//实例化子类，无参构造
SubTest ts=new SubTest();

//实例化子类，全参构造
SubTest ts1=new SubTest(1);
}
}输出：
静态代码块执行...
非静态代码块执行...
父类无参构造执行...
子类无参构造执行...
非静态代码块执行...
父类无参构造执行...
子类全参构造执行...
********华丽分割线********
非静态代码块执行...
父类全参构造执行...
子类无参构造执行
非静态代码块执行...
父类全参构造执行...
子类全参构造执行...看看吧，执行的顺序和调用方法不同的问题...

Answer 8

http://blog.csdn.net/zwnylsf/article/details/7385011,刚总结了这些，不知道对楼主有没有帮助...