java程序的执行过程

//
程序执行过程：
1. Load到内存区。
在硬盘上有一块程序代码，要想运行，编译好的东西load到内存。然后操作系统代码找到

main方法，然后执行。

2. 找到main方法开始执行。
3. 执行过程中的内存管理。
一般分为四部分：
a. code segment: 存放代码，代码区
b. data segment: 静态变量，字符串常量
c. stack(栈): 局部变量
d. heap(堆): new出来的东西

1.Java程序执行包括加载类和实例化类两个阶段。
2.加载类阶段与实例化类阶段都是按照先父类后子类的顺序进行。
3. 加载类完成，立即形成Class类的一个对象，名字就是所加载类的类名，然后，该Class类的对象完成所加载类的静态成员的初始化。
4.JVM 启动的时候就加载了Class类，并且分配空间，完成了相关的初始化。
5.一个类的静态成员并不存在于new出来的堆区空间中，而是存在该类对应的Class类对象的空间里。


1.将程序编译成字节码的不是JDK；
JDK的全拼是java development kit，就是java开发工具包。
包括一些函数库或编译程序之类的。
将程序编译成字节码的应该是JVM。
2.你在从main函数开始，执行一个程序的时候，一个JVM实例也随之产生，
它的任务就是执行java程序，可以说JVM开始于一个main函数。
JVM启动后执行你的java程序，JVM加载并解析你在程序里写的类（已经被编译成.class了）。
3.静态变量在类被加载的时候被初始化。


///
class parent
{
int i = 9;//定义初始化
int j;
parent()
{
System.out.println("i = " + i);
j = 39;
System.out.println("j = " + j);
}
static int x = prt("static parent.x initialized.");//静态定义初始化
static int prt(String s)
{
System.out.println(s);
return 47;
}
}

public class getToKnowConstructingOrder extends parent
{
int k = prt("getToKnowConstructingOrder.k initialized.");//定义初始化
getToKnowConstructingOrder()
{
prt("k = " + k);
prt("j = " + j);
}
static int y = prt("getToKnowConstructingOrder.y initialized.");//静态定义初始化
static int prt(String s)
{
System.out.println(s);
return 63;
}
public static void main(String[] args)
{
prt("getToKnowConstructingOrder constructor.");
getToKnowConstructingOrder s = new getToKnowConstructingOrder();
}
}

执行结果：static parent.x initialized. 1

getToKnowConstructingOrder.y initialized. 2

getToKnowConstructingOrder constructor. 3

i = 9 4

j = 39 5

getToKnowConstructingOrder.k initialized. 6

k = 63 7

j = 39 8

详细运行过程分析：首先，要执行getToKnowConstructingOrder里面的main，需要加载main所在的.class文件，在加载的过程中，JVM发现getToKnowConstructingOrder有父类的，所以转入首先加载parent类的.class文件，形成parent类对象，实现对parent类中静态成员的初始化，于是出现了结果1，然后parent类的.class文件加载完毕，重新回来继续完成加载getToKnowConstructingOrder类的.class文件，形成getToKnowConstructingOrder类对象，该对象对getToKnowConstructingOrder类中的静态成员完成初始化，出现了结果2。

由于执行main函数需要的所有类的.class文件都已经完成了加载，开始执行main函数，于是出现了结果3，要实例化一个getToKnowConstructingOrder实例(即完成非静态成员的定义初始化，接着完成调用构造函数)，必须先实例化一个parent类(即完成非静态成员的定义初始化，接着完成调用构造函数)，于是出现了结果4，5，此时父类的实例化完成，回来接着进行子类的实例化，于是出现了结果6，7，8。

这里还有一些细节：子类不会自动调用父类的静态方法，除非用super.prt()。

Java程序执行包括加载类和实例化类两个阶段。

加载类阶段与实例化类阶段都是按照先父类后子类的顺序进行。

加载类完成，立即形成Class类的一个对象，名字就是所加载类的类名，然后，该Class类的对象完成所加载类的静态成员的初始化。

JVM启动的时候就加载了Class类，并且分配空间，完成了相关的初始化。

一个类的静态成员并不存在于new出来的堆区空间中，而是存在该类对应的Class类对象的空间里。

/


Java code
<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->
public class Test｛
private static Test tester = new Test(); //step 1
private static int count1; //step 2
private static int count2 = 0; //step 3
public Test(){ //step 4
count1++;
count2++;
System.out.println("" + count1 + count2);
}
public static Test getTester(){ //step 5
return tester;
}

public static void main(String[] args){
Test.getTester();
}
｝


问：以上代码执行的顺序~，输出的结果~

这是我昨天面试时碰到的一题，我尽量还原了原题。先说一下，这里count1未初始化可不是我忘了，原题就是这么搞D~
正好我对这种带有自身类型的字段的情况有些迷糊，索性答曰：“有变量未初始化，编译器可能会报错”~

我想问的是，如果忽略未初始化错误的话，以上代码执行顺序到底如何？


0
顶1
踩 分享到：
羊车问题的讨论---四种思路 .
2012-02-28 08:49:05浏览 140评论(7)分类:编程语言相关推荐
评论
7 楼 buptwhisper 2 小时前
其实这个也好弄清楚的，你在每一个可能的地方打上断点，然后debug，你就大致上懂了。
6 楼 wmswu 2 小时前
这种类型的面试题 还真不少啊.......
5 楼 H小阿飞 3 小时前
程序是没有错误的，对于定义的int类型的字段，未初始化的情况下，默认是0。
至于执行顺序，由于一开始就对Test进行了实例化，所以先执行test()方法，然后执行main方法，最后执行getTester()方法。
如果程序改成private static Test tester;而在main方法中对Test进行实例化：Test.getTester(); tester = new Test();这样的话，test()方法就是最后执行。
上面也说了，int类型的count1未初始化，则默认是0，所以countl和count2 ++ 后，结果都是1，输出结果加了""，所以输出的是一个String类型的字符串，输出结果为11
4 楼 m635674608 3 小时前
燈小嗨 写道
JAVA类首次装入时，开始加载静态变量和静态块，也就是说会首先为静态区域分配内存空间，此时tester、count1、count2都已经分配空间，其中tester为一个引用空间，count1、count2为默认值0。
第二步开始执行 private static Test tester = new Test() 这段代码，调用构造器打印出count1、count2 分别为 1 和 1 。然后依次执行一下代码 private static int count1; private static int count2 = 0; 此时，count2被重置为0，因此如果此时再次打印的话count1、count2的值应该为 1 和 0 。
估计是楼主的题目记忆有问题，这题考察的重点应该在于count被重置后的结果，代码应该不是这样的。

嗯。。这位仁兄解说的正确。。。。。。
3 楼 燈小嗨 3 小时前
JAVA类首次装入时，开始加载静态变量和静态块，也就是说会首先为静态区域分配内存空间，此时tester、count1、count2都已经分配空间，其中tester为一个引用空间，count1、count2为默认值0。
第二步开始执行 private static Test tester = new Test() 这段代码，调用构造器打印出count1、count2 分别为 1 和 1 。然后依次执行一下代码 private static int count1; private static int count2 = 0; 此时，count2被重置为0，因此如果此时再次打印的话count1、count2的值应该为 1 和 0 。
估计是楼主的题目记忆有问题，这题考察的重点应该在于count被重置后的结果，代码应该不是这样的。
2 楼 lixieinstein 3 小时前
结果就是11，编译不会报错，count1没有初始化但是会自动初始化为0
1 楼 smiky 3 小时前
忽略未初始化错误的话会首先加载静态代码及其代码块,在Test.getTester()执行之前会执行new操作,然后在调用此方法
好久没看JAVA基础了,希望没说错