考验你的基础是否牢固的问题……

Question

Tag(1)
Tag(2)
Tag(3)
Tag(33)
f()

Answer 1

为什么结果会是这样，程序从main函数开始，首先执行Card t=new Card();语句，难道不是接着调用构造函数Card（）确保初始化操作吗？如果不是，是什么流程运行这个程序的？
能帮我说明一下吗?在此谢谢了。

Answer 2

Tag(1)Tag(2)Tag(3)Tag(33)f();
原因如下:
   1 javac Order.java
   2 java  Order

Answer 3

Tag(1)Tag(2)Tag(3)Tag(33)f()建议您买本java编程思想或者java核心技术看看
本程序涉及到了java里面最基础的类间访问和类的构造函数的知识点

Answer 4

TIJ中不是解释了吗？
先进行类变量的初始化

Answer 5

Tag(1)
Tag(2)
Tag(3)
Tag(33)
f()
这个叫人怎么说啊！  先从main主函数开始啊！
然后执行Card中的初始化，再进行Card（）方法的实例化操作，最后执行 t.f()

Answer 6

晕死，public class Test2 extends Test1{
static Test3 t3 = new Test3(); //static mumber object
static int i = getInt();       //static mumber get value by function:getInt

//static function return int
static int getInt(){    
System.out.println("Test2 getInt");
return 100;
}

//static block
static{
System.out.println("Test2 static block");

}

//initialization block
{
System.out.println("Test2 initialization block 1");
}

Test4 t4 = new Test4();     //mumber object

//constructor
Test2(){
System.out.println("Test2 constructor");
}

//initialization block
{
System.out.println("Test2 initialization block 2");
}

public static void main(String[] args) {
new Test2();
}
}
class Test1 {
static{
System.out.println("Test1 static block");
}
static int i = getInt();
static int getInt(){
System.out.println("Test1 getInt");
return 100;
}
Test1(){
System.out.println("Test1 constructor");
}

{
System.out.println("Test1 initialization block");
}
}
class Test3 {
Test3(){
System.out.println("Test3 constructor");
}
static{
System.out.println("Test3 static block");
}
{
System.out.println("Test3 initialization block");
}
}class Test4{
Test4(){
System.out.println("Test4 constructor");
}
}
-----------------------------------------------------------------------------------------
以下为输出结果，我分成了几个部分：
Test1 static block
Test1 getInt
------------------------------------------<1>
Test3 static block
Test3 initialization block
Test3 constructor
Test2 getInt
Test2 static block
------------------------------------------<2>
Test1 initialization block
------------------------------------------<3>
Test1 constructor
------------------------------------------<4>
Test2 initialization block 1
Test4 constructor
Test2 initialization block 2
------------------------------------------<5>
Test2 constructor
------------------------------------------<6>由输出结果可以看出一个类的构造形为；
1>基类的static: 包括静态成员，静态成员对象，静态块，按它们在程序中的定义顺序执行，如果有静态成员对象，则必须完成此静态成员对象的所有构造动作(有点像函数调用)2>派生类的static: 包括静态成员，静态成员对象，静态块，按它们在程序中的定义顺序执行，如果有静态成员对象，则必须完成此静态成员对象的所有构造动作(有点像函数调用)
以上两步只会在类加载时执行，因为是静态的嘛接下来的四步就会在每次new出一个对象时执行了，再说原因可能你们会看我不爽了，呵呵
3>基类的非static: 包括成员，成员对象，初始块，按它们在程序中的定义顺序执行，如果有成员对象，则必须完成此成员对象的所有构造动作4>当然是基类的构造函数啦5>派生类的非static: 包括成员，成员对象，初始块，按它们在程序中的定义顺序执行，如果有成员对象，则必须完成此成员对象的所有构造动作6>不用说也是派生类的构造函数啦

Answer 7

用jb执行dug，它会一步一步地走，你看了就全明白了

Answer 8

Tag(1)Tag(2)Tag(3)Tag(33)f()结果就是这样,原因楼上说的已经很清楚了.

Answer 9

Tag(1)Tag(2)Tag(3)Tag(33)f()主要要理解构造函数的执行过程！

Answer 10

fog628 解释得够清楚，学习

Answer 11

呵呵，Thinking in java的范例

Answer 12

不用说，编译不成功，没有结果。
在第7行出错啦！
Tag t1=nwe Tag(1);
改为Tag t1=new Tag(1);才对。其他的暂时不看，晚上有空再来。

Answer 13

class Tag {
  Tag(int m) {
    System.out.print("Tag(" + m + ")");
  }
}class Card {
  Tag t1 = new Tag(1);
  Card() {
    t3 = new Tag(33);
  }
  Tag t2 = new Tag(2);
  void f() {
    System.out.println("f()");
  }
  Tag t3 = new Tag(3);
}public class Order{
  public static void main(String[] args) {
    Card t = new Card();
    t.f();
  }
}
前面的兄弟们都已经分析很清楚了。
只要了解先初始化成员变量 ，包括静态变量，再次才是构造函数 OK

Answer 14

搂主怎么还叫javainthink，哈哈，