本文目录一览:
关于JAVA中的初始化及类的加载
你不太可能完全用代码证明类加载的动作,因为在你用这个类之前(也就是你想要开始证明一个类加载的过程时)她已经加载了。
现在来说,静态成员会和类加载的时候一起初始化,所以最多最多也只能通过静态成员来证明类的加载。
那么问题就是如何在静态成员被初始化的时候提示消息,两种方法:
第一种是使用静态的字段成员,此成员指定为一个对象初始化,在这个初始化对象的构造函数做通知。代码:
public class StaticLoad{
public static LoadNotify = new LoadNotify();
}
public class LoadNotify{
public LoadNotify(){
System.out.println("Class is Loaded");
}
}
那么使用StaticLoad类的时候,会打出Class is Loaded证明类加载的时候初始化了static成员,调用多次也仅会打出一次。
第二种是使用静态块,代码:
public class StaticLoad{
public static LoadNotify = new LoadNotify();
static {
System.out.println("Class is Loaded");
}
}
此时类加载时也会执行静态块中的代码。
这是进行当类加载的时候进行通知的方法,你可以自己写一写代码,他们仅会打出一次。
对于类的加载顺序,网上有详细的,我这里只说一些简单的:
首先需要用到一个类的时候,虚拟机会从classpath读取此类的代码,到内存的类的代码存储区,然后对于每一个静态字段开辟一个存储区,再存储方法的代码。接着初始化类,所有的静态成员按照顺序初始化(按代码声明顺序从上到下开始),当需要加载其他类的时候加载其他的类。然后完成初始化供虚拟机使用。
当实例化一个类的时候,如果需要加载的话,会按照上面的顺序加载,然后在内存中分配所有实例字段的空间,接着调用构造函数,其中构造函数会(显示或隐式的)调用父类构造函数(此过程向上递归),然后执行剩下的构造代码。最后返回实例化的对象的引用返回构造函数。
java初始化
你说“在java初始化时,顺序为静态变量-静态初始化块-非静态变量-非静态初始化块-构造函数”
请问你在哪知道的,我也希望了解一下
我一直觉得构造函数会在静态初始化块之后
对 非静态变量-非静态初始化块-构造函数 这样的排列倒是有点...
------------------------------------------------------------------
我在javaEye上找了找相关文章:
1在new B一个实例时首先要进行类的装载。(类只有在使用New调用创建的时候才会被java类装载器装入)
2,在装载类时,先装载父类A,再装载子类B
3,装载父类A后,完成静态动作(包括静态代码和变量,它们的级别是相同的,安装代码中出现的顺序初始化)
4,装载子类B后,完成静态动作
类装载完成,开始进行实例化
1,在实例化子类B时,先要实例化父类A
2,实例化父类A时,先成员实例化(非静态代码)
3,父类A的构造方法
4,子类B的成员实例化(非静态代码)
5,子类B的构造方法
确实~
哪位大神可以讲解一下,Java初始化页面做哪
学java应该会更全面一点,扩展性更强,把JAVA学好了再去学其他知识都会比较容易。其实做程序学习的东西并没有明显的界限,除了JAVA还要学习HTML,JS,数据库,框架等等,工作从事JAVA开发可能也会调到其他项目组做安卓开发,只要不断的接受新知识,学习新的技术,能充实自己就好了。
java中初始化
顺序如下:
1、静态的部分在classLoader加载类的时候就会执行,静态块中不能引用非静态的变量(因为这些变量要通过实例化类才能创建,在静态块执行的时候都不存在)。也不存在静态的成员变量,跟后面的两个初始化有质的不同(后两个是初始化成员变量)。
2、定义变量时直接赋的值。
3、构造函数。
java程序的初始化
关于Java初始化,有多文章都用了很大篇幅的介绍。经典的更是用了专门的
一章来介绍Java初始化。但在大量有代码实例后面,感觉上仍然没有真正深入到初始化的本质。
本文以作者对JVM的理解和自己的经验,对Java的初始化做一个比深入的说明,由于作者有水平限制,
以及JDK各实现版本的变化,可能仍然有不少错误和缺点。欢迎行家高手赐教。
要深入了解Java初始化,我们无法知道从程序流程上知道JVM是按什么顺序来执行的。了解JVM的执行
机制和堆栈跟踪是有效的手段。可惜的是,到目前为止。JDK1。4和JDK1。5在javap功能上却仍然存在
着BUG。所以有些过程我无法用实际的结果向你证明两种相反的情况(但我可以证明那确实是一个BUG)
(第三版)在第四章一开始的时候,这样来描述Java的初始化工作:
以下译文原文:
可以这样认为,每个类都有一个名为Initialize()的方法,这个名字就暗示了它得在使用之前调用,不幸
的是,这么做的话,用户就得记住要调用这个方法,java类库的设计者们可以通过一种被称为构造函数的
特殊方法,来保证每个对象都能得到被始化.如果类有构造函数,那么java就会在对象刚刚创建,用户还来
不及得到的时候,自动调用那个构造函数,这样初始化就有保障了。
我不知道原作者的描述和译者的理解之间有多大的差异,结合全章,我没有发现两个最关键的字""
和""。至少说明原作者和译者并没有真正说明JVM在初始化时做了什么,或者说并不了解JVM的初始化
内幕,要不然明明有这两个方法,却为什么要认为有一个事实上并不存在的"Initialize()"方法呢?
""和""方法在哪里?
这两个方法是实际存在而你又找不到的方法,也许正是这样才使得一些大师都犯晕。加上jdk实现上的一
些BUG,如果没有深入了解,真的让人摸不着北。
现在科学体系有一个奇怪的现象,那么庞大的体系最初都是建立在一个假设的基础是,假设1是正确的,
由此推导出2,再继续推导出10000000000。可惜的是太多的人根本不在乎2-100000000000这样的体系都
是建立在假设1是正确的基础上的。我并不会用“可以这样认为”这样的假设,我要确实证明""
和""方法是真真实实的存在的:
packagedebug;
publicclassMyTest{
staticinti=100/0;
publicstaticvoidmain(String[]args){
Ssytem.out.println("Hello,World!");
}
}
执行一下看看,这是jdk1.5的输出:
java.lang.ExceptionInInitializerError
Causedby:java.lang.ArithmeticException:/byzero
atdebug.MyTest.(Test.java:3)
Exceptioninthread"main"
请注意,和其它方法调用时产生的异常一样,异常被定位于debug.MyTest的.
再来看:
packagedebug;
publicclassTest{
Test(){
inti=100/0;
}
publicstaticvoidmain(String[]args){
newTest();
}
}
jdk1.5输入:
Exceptioninthread"main"java.lang.ArithmeticException:/byzero
atdebug.Test.(Test.java:4)
atdebug.Test.main(Test.java:7)
JVM并没有把异常定位在Test()构造方法中,而是在debug.Test.。
当我们看到了这两个方法以后,我们再来详细讨论这两个“内置初始化方法”(我并不喜欢生造一些
非标准的术语,但我确实不知道如何规范地称呼他们)。
内置初始化方法是JVM在内部专门用于初始化的特有方法,而不是提供给程序员调用的方法,事实上
“”这样的语法在源程序中你连编译都无法通过。这就说明,初始化是由JVM控制而不是让程序员
来控制的。
类初始化方法:
我没有从任何地方了解到的cl是不是class的简写,但这个方法确实是用来对“类”进行初
始化的。换句话说它是用来初始化static上下文的。
在类装载(load)时,JVM会调用内置的方法对类成员和静态初始化块进行初始化调用。它们
的顺序按照源文件的原文顺序。
我们稍微增加两行static语句:
packagedebug;
publicclassTest{
staticintx=0;
staticStrings="123";
static{
Strings1="456";
if(1==1)
thrownewRuntimeException();
}
publicstaticvoidmain(String[]args){
newTest();
}
}
然后进行反编译:
javap-cdebug.Test
Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
staticintx;
staticjava.lang.Strings;
publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:return
publicstaticvoidmain(java.lang.String[]);
Code:
0:new#2;//classdebug/Test
3:dup
4:invokespecial#3;//Method"":()V
7:pop
8:return
static{};
Code:
0:iconst_0
1:putstatic#4;//Fieldx:I
4:ldc#5;//String123
6:putstatic#6;//Fields:Ljava/lang/String;
9:ldc#7;//String456
11:astore_0
12:new#8;//classjava/lang/RuntimeException
15:dup
16:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
19:athrow
}
这里,我们不得不说,JDK在javap功能上的实现有一个BUG。static段的16标号,那里标识了异常
的位置发生在""方法中,而实际上这段程序运行时的输出却是:
java.lang.ExceptionInInitializerError
Causedby:java.lang.RuntimeException
atdebug.Test.(Test.java:8)
Exceptioninthread"main"
但我们总可以明白,类初始化正是按照源文件中定义的原文顺序进行。先是声明
staticintx;
staticjava.lang.Strings;
然后对intx和Strings进行赋值:
0:iconst_0
1:putstatic#4;//Fieldx:I
4:ldc#5;//String123
6:putstatic#6;//Fields:Ljava/lang/String;
执行初始化块的Strings1="456";生成一个RuntimeException抛
9:ldc#7;//String456
11:astore_0
12:new#8;//classjava/lang/RuntimeException
15:dup
16:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
19:athrow
要明白的是,""方法不仅是类初始化方法,而且也是接口初始化方法。并不是所以接口
的属性都是内联的,只有直接赋常量值的接口常量才会内联。而
[publicstaticfinal]doubled=Math.random()*100;
这样的表达式是需要计算的,在接口中就要由""方法来初始化。
下面我们再来看看实例初始化方法""
""用于对象创建时对对象进行初始化,当在HEAP中创建对象时,一旦在HEAP分配了空间。最
先就会调用""方法。这个方法包括实例变量的赋值(声明不在其中)和初始化块,以及构造
方法调用。如果有多个重载的构造方法,每个构造方法都会有一个对应的""方法。
同样,实例变量和初始化块的顺序也是按源文件的原文顺序执行,构造方法中的代码在最后执行:
packagedebug;
publicclassTest{
intx=0;
Strings="123";
{
Strings1="456";
//if(1==1)
//thrownewRuntimeException();
}
publicTest(){
Stringss="789";
}
publicstaticvoidmain(String[]args){
newTest();
}
}
javap-cdebug.Test的结果:
Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
intx;
java.lang.Strings;
publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:iconst_0
6:putfield#2;//Fieldx:I
9:aload_0
10:ldc#3;//String123
12:putfield#4;//Fields:Ljava/lang/String;
15:ldc#5;//String456
17:astore_1
18:ldc#6;//String789
20:astore_1
21:return
publicstaticvoidmain(java.lang.String[]);
Code:
0:new#7;//classdebug/Test
3:dup
4:invokespecial#8;//Method"":()V
7:pop
8:return
}
如果在同一个类中,一个构造方法调用了另一个构造方法,那么对应的""方法就会调用另一
个"",但是实例变量和初始化块会被忽略,否则它们就会被多次执行。
packagedebug;
publicclassTest{
Strings1=rt("s1");
Strings2="s2";
publicTest(){
s1="s1";
}
publicTest(Strings){
this();
if(1==1)thrownewRuntime();
}
Stringrt(Strings){
returns;
}
publicstaticvoidmain(String[]args){
newTest("");
}
}
反编译的结果:
Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
java.lang.Strings1;
java.lang.Strings2;
publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:aload_0
6:ldc#2;//Strings1
8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;
11:putfield#4;//Fields1:Ljava/lang/String;
14:aload_0
15:ldc#5;//Strings2
17:putfield#6;//Fields2:Ljava/lang/String;
20:aload_0
21:ldc#2;//Strings1
23:putfield#4;//Fields1:Ljava/lang/String;
26:return
publicdebug.Test(java.lang.String);
Code:
0:aload_0
1:invokespecial#7;//Method"":()V
4:new#8;//classjava/lang/RuntimeException
7:dup
8:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
11:athrow
java.lang.Stringrt(java.lang.String);
Code:
0:aload_1
1:areturn
publicstaticvoidmain(java.lang.String[]);
Code:
0:new#10;//classdebug/Test
3:dup
4:ldc#11;//String
6:invokespecial#12;//Method"":(Ljava/lang/String;)V
9:pop
10:return
}
我们再一次看到了javap实现的bug,虽然有一个"":(Ljava/lang/String;)V签名可以说明
每个构造方法对应一个不同,但Runtime异常仍然被定位到了""()V的方法中:
invokespecial#8;//Methodjava/lang/RuntimeException."":()V,而在main方法中的
调用却明明是"":(Ljava/lang/String;)V.
但是我们看到,由于Test(Strings)调用了Test();所以"":(Ljava/lang/String;)V不再对
实例变量和初始化块进次初始化:
publicdebug.Test(java.lang.String);
Code:
0:aload_0
1:invokespecial#7;//Method"":()V
4:new#8;//classjava/lang/RuntimeException
7:dup
8:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
11:athrow
而如果两个构造方法是相互独立的,则每个构造方法调用前都会执行实例变量和初始化块的调用:
packagedebug;
publicclassTest{
Strings1=rt("s1");
Strings2="s2";
{
Strings3="s3";
}
publicTest(){
s1="s1";
}
publicTest(Strings){
if(1==1)
thrownewRuntimeException();
}
Stringrt(Strings){
returns;
}
publicstaticvoidmain(String[]args){
newTest("");
}
}
反编译的结果:
Compiledfrom"Test.java"
publicclassdebug.Testextendsjava.lang.Object{
java.lang.Strings1;
java.lang.Strings2;
publicdebug.Test();
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:aload_0
6:ldc#2;//Strings1
8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;
11:putfield#4;//Fields1:Ljava/lang/String;
14:aload_0
15:ldc#5;//Strings2
17:putfield#6;//Fields2:Ljava/lang/String;
20:ldc#7;//Strings3
22:astore_1
23:aload_0
24:ldc#2;//Strings1
26:putfield#4;//Fields1:Ljava/lang/String;
29:return
publicdebug.Test(java.lang.String);
Code:
0:aload_0
1:invokespecial#1;//Methodjava/lang/Object."":()V
4:aload_0
5:aload_0
6:ldc#2;//Strings1
8:invokevirtual#3;//Methodrt:(Ljava/lang/String;)Ljava/lang/String;
11:putfield#4;//Fields1:Ljava/lang/String;
14:aload_0
15:ldc#5;//Strings2
17:putfield#6;//Fields2:Ljava/lang/String;
20:ldc#7;//Strings3
22:astore_2
23:new#8;//classjava/lang/RuntimeException
26:dup
27:invokespecial#9;//Methodjava/lang/RuntimeException."":()V
30:athrow
java.lang.Stringrt(java.lang.String);
Code:
0:aload_1
1:areturn
publicstaticvoidmain(java.lang.String[]);
Code:
0:new#10;//classdebug/Test
3:dup
4:ldc#11;//String
6:invokespecial#12;//Method"":(Ljava/lang/String;)V
9:pop
10:return
}