⑴ java 初始化
補充：java要求方法級別的變數都要初始化。這是java的特點。用來提高代碼的安全性（內存定址）。
請參考：
http://..com/question/20192637.html
--------------------
程序沒有編譯問題，運行也很正常，運行結果為：
1 2 3 4 8 7 6 5The minimum is 1
⑵ java組件初始化
問題一：
書上的簡寫方法
JButton jb=new JButton("OK"); //先創建
add(jb); //再添加
--------
add(new JButton("OK")); //合體寫法
問題二：
class test extends Frame
類test繼承了Frame類，於是test類就是Fream類了（代表）
在用構造方法構造一個自己的對象public test { }
問題三：
public class HelloWorld extends JFrame
public HelloWorld()
{
super();//調用本類的父類的構造函數
this.setSize(300, 200);//設置本類創建的對象（窗體)的大小
this.getContentPane().setLayout(null);//設置對象的版面
this.add(getJLabel(), null);//
this.add(getJTextField(), null);//
this.add(getJButton(), null);//
//上面3句是調用本類的3個方法來創建對象，用add()方法添加到面版上
//this. 是調用自己類創建的對象的方法或者屬性
this.setTitle("HelloWorld");
}
private javax.swing.JLabel getJLabel() {
...
...
}
//類里的一個方法，返回值是JLable類型。是個private(私有），只有自己類的對象才能調用。
他的作用就是創建一個JLabel的對象並返回
在上面的this.add(getJTextField(), null);你就懂了吧，調用getJTextField()方法得到一個JTextField對象，在添加到面版
分啊
⑶ java語言，什麼是初始化啊初始化和實例化一樣嗎
java中不管對象也好，還是基本數據類型也好，你聲明它的時候，它們都稱為變數，在你使用變數前給變數進行賦值，這就是變數的初始值，因此叫變數初始化。
實例化是指對象的創建，一般是指通過 new 關鍵字（當然還有其他途徑，比如反射），在堆中為對象分配內存，這就是實例化。舉個非常簡單的例子，你知道飛機會飛，但飛機在你腦海里只是個概念，當真的把飛機製造出來，變成實實在在的，存在於物質世界（java中稱內存）的東西時，你才能用它來飛。如果在物質世界（內存）中根本就不存在，那就無法使用。因此，實例化可以說將概念（類），變成實際存在（內存中存在）的過程就稱為實例化。
⑷ Java中對象如何初始化
初始化數組有三種方式，以下都是去初始化一個String類型長度2的數組：
方式一：
123String[] strs = new String[2];strs[0] = "0";strs[1] = "1";
方式二：
1String[] strs = new String[]{"0", "1"};
方式三：
1String[] strs = {"0", "1"};
三種方式，都有自己的使用場景，在合適場景使用即可。
⑸ 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:p
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:p
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:p
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:p
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:p
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:p
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:p
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:p
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:p
4:ldc#11;//String
6:invokespecial#12;//Method"":(Ljava/lang/String;)V
9:pop
10:return
}
⑹ java中怎麼數組初始化
一維數組
1)
int[] a; //聲明,沒有初始化
2)
int[] a=new int[5]; //初始化為默認值,int型為0
3)
int[] a={1,2,3,4,5};
//初始化為給定值
4)
int[] a=new int[]{1,2,3,4,5}; //同(3)
int[] a=new int[5]{1,2,3,4,5};
//錯誤,如果提供了數組初始化操作，則不能定義維表達式
5)
int[] a;
a=new int[5]; //正確,同(2)一樣
int[] a;
a={1,2,3,4,5}; //錯誤數組常量只能在初始化操作中使用，如（3)
6) int a[];
a[0]=1;
//錯誤,因為數組沒有初始化,不能賦值a[1]=2; 二維數組
1)
int[][] a;
//聲明,沒有初始化
2) int[][] a=new int[2][3];
//初始化為默認值,int型為0
3)
int[][] a={{1,2},{2,3},{3,4}};
//初始化為給定值
int[][] a={{1,2},{2,3},{3,4,5}};
//沒有錯,數組空間不是連續分配的，所以不要求每一維的大小相同
4)
int[][] a=new int[2][];
a[0]=new int[3];
//a[0]其實就是一個數組a[1]=new int[4];
//每一維的大小可以不一樣
;
5)
int[][] a=new
int[][]{{1,2},{2,3},{3,4,5}};
//同(3)
⑺ java 對象的初始化方式有幾種
初始化常用的方法就是創建對象初始化：
類名 對象名 =new 類名();
⑻ 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:p
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:p
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:p
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:p
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:p
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:p
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:p
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:p
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:p
4:ldc#11;//String
6:invokespecial#12;//Method"":(Ljava/lang/String;)V
9:pop
10:return
}
⑼ java初始化
靜態代碼塊是按著順序執行的，緊接著的賦值語句不報錯是因為上一句已經錯了，如果你把上一句注釋掉，賦值語句就會報錯了。你可以試試。
⑽ java如何初始化類（JAVA初級菜鳥）
test1 a;是定義一個變數，為什麼要在後面加一個(1)，如果想賦值的話這樣寫：test1 a=new test1(1); 這樣a就是一個test1類型的示例了。