java構造函數順序

Ⅰ java基礎 類中方法，構造函數的列印順序

7、游離塊：
游離塊比構造器更先被調用；游離塊定義方法如下：
{
語句；
}

Ⅱ Java 構造方法初始化順序

初始化子類，調用子類有參的時候默認情況下也是先去調用父類的無參構造，除非你在子類的構造方法中使用super來指明調用父類中的哪個構造方法。

Ⅲ java繼承中構造函數的調用順序

在java中，用子類去創建一個對象的時候會首先調用父類的無參構造函數，然後再去調用自己的構造函數！這就是你的那段程序結果出現的原因！

Ⅳ java中主函數和構造函數誰先載入

當然是先主函數。
程序的入口就是主函數。
至於構造函數。。只有要用到這個類的時候
。就是new出這個類以後才會載入，
我去。後邊的人為什麼要說構造函數呢。。。主函數可是static的靜態的呀
。。在最剛開始載入的時候就載入了的！

Ⅳ java構造函數的運行時序

首先假設有如下的一些輔助類，這些類被其他類使用作為靜態變數或非靜態變數：

Java代碼 收藏代碼
1.public class C {
2. public C() {
3. System.out.println("C");
4. }
5.}
6.
7.public class E {
8. public E() {
9. System.out.println("E");
10. }
11.}
12.
13.public class F {
14. public F() {
15. System.out.println("F");
16. }
17.}
18.
19.public class G {
20. public G() {
21. System.out.println("G");
22. }
23.}
24.
25.
26.public class H {
27. public H() {
28. System.out.println("H");
29. }
30.}

1)繼承自Object的類的構造函數的執行順序：
假設有如下的一個類I,I的定義如下：

Java代碼 收藏代碼
1.public class I {
2. public G g = new G();
3. public static E statice0 = new E();
4. static {
5. statice0 = new E();
6. System.out.println("判斷static執行的順序");
7. }
8. public static E statice1;
9. public static F f1;
10. static {
11. System.out.println("測試在static塊中執行的順序1");
12. statice1 = new E();
13. f1 = new F();
14. }
15. static {
16. System.out.println("測試在static塊中執行的順序2");
17. f1 = new F();
18. statice1 = new E();
19. }
20. public static H h = new H();
21.
22. public E e;
23. {
24. System.out.println("aaa");
25. e = new E();
26. }
27.
28. public I(int i) {
29. statice0 = new E();
30. f1 = new F();
31. e = new E();
32. }
33.
34. public static void main(String[] args) {
35. I i = new I(1);
36. }
37.}

執行結果：
E
E
判斷static執行的順序
測試在static塊中執行的順序1
E
F
測試在static塊中執行的順序2
F
E
H
G
aaa
E
F
H
E
從這個結果來可以知道，從Object派生的類將會按照如下的書序執行：
1、靜態變數，如果有靜態塊的話，則按照靜態塊中變數new的順序執行靜態變數構造函數。如果沒有靜態塊的話，則按照聲明的順序執行。
2、非靜態變數，如果有非靜態變數初始化塊的話，則按照new的順序執行構造函數，如果沒有初始化塊則按照聲明的順序執行。
3、執行構造函數，所有的變數按照new的順序執行構造函數。

2）如果是從非Object類結成的類
看如下的類：

Java代碼 收藏代碼
1.public class A {
2. private static E e = new E();
3. private F f = new F();
4.
5. public A() {
6. Syst www.hnne.com em.out.println("A");
7. }
8.}
9.
10.public class B extends A {
11. private static D d = new D();
12. private C c = new C();
13.
14. public B() {
15. System.out.println("B");
16. }
17.
18. public static void main(String[] args) {
19. B b = new B();
20. }
21.}
22.
23.
24.public class C {
25. public static E e = new E();
26. public C() {
27. System.out.println("C");
28. }
29.}

執行B中的main，則會列印出如下的結果：
E
H
G
D
F
A
E
C
B

首先分析各個類的調用情況，在父類A中有一個E的靜態變數，和一個F的非靜態變數，B類繼承自A，B有一個D的靜態變數和C的非靜態變數，D中又有一個H的靜態變數和g的非靜態變數。
從執行得到的結果可以得到如下的結論：
1、首先執行父類中的靜態變數的構造函數，在執行構造函數之前執行靜態變數的類中的靜態變數的構造函數。因此在上例中首先輸出：E
2、執行本類的靜態變數的構造函數，同上，需要執行靜態變數的類中的靜態變數的構造函數。上例中會在執行了A中的E的靜態變數後執行D的靜態變數的構造函數，在此之前需要執行D中的靜態變數H的構造函數，然後執行D中的非靜態變數G的構造函數。列印出：H G D
3、執行父類中的非靜態變數的構造函數。列印出：f
4、執行父類的構造函數。列印出： A
5、執行本類的非靜態變數的構造函數，列印出：E C
6、執行本類中的構造函數，按照new的順序執行構造函數。列印出：B

Ⅵ 請問Java中構造函數的執行順序是否與虛擬機有關

與JVM無關，JVM對上層提供的功能是統一的，這才成就了java的「一次編譯到處運行」。
對於構造函數的執行順序，按Thinking in java（4th）中的講解，為：
1.調用基類構造器；
2.按聲明順序調用成員的初始化方法；
3.調用導出類構造器的主體。

具體可參考下面的這個類代碼的源碼即運行顯示（出自《java編程思想》）
//: polymorphism/Sandwich.java
// Order of constructor calls.
package polymorphism;
import static net.mindview.util.Print.*;

class Meal {
Meal() { print("Meal()"); }
}

class Bread {
Bread() { print("Bread()"); }
}

class Cheese {
Cheese() { print("Cheese()"); }
}

class Lettuce {
Lettuce() { print("Lettuce()"); }
}

class Lunch extends Meal {
Lunch() { print("Lunch()"); }
}

class PortableLunch extends Lunch {
PortableLunch() { print("PortableLunch()");}
}

public class Sandwich extends PortableLunch {
private Bread b = new Bread();
private Cheese c = new Cheese();
private Lettuce l = new Lettuce();
public Sandwich() { print("Sandwich()"); }
public static void main(String[] args) {
new Sandwich();
}
}
/* Output: //以下為代碼的運行顯示
Meal()
Lunch()
PortableLunch()
Bread()
Cheese()
Lettuce()
Sandwich()
*///:~

Ⅶ java中創建對象了，顯示初始化值和構造函數初始化對象的區別先後執行順序是什麼

兩個都可以初始化值，本質上沒有區別，不同的是執行的先後。構造方法初始化值時需要包含有參的構造方法，創建對象時使用Object obj = new Object(arg1,arg2)的形式，你說的顯示初始化值應該是使用set方法吧，比如obj.setArg1(arg1)的形式。執行順序肯定是構造方法的形式要在前了，因為在對象創建之後就會給屬性賦值，而set方法形式賦值只會在你調用set方法時才會賦值。
再插一點題外話：其實在對象創建時成員變數已經初始化了，只是初始化的都是變數對應類型的默認值，比如int類型的默認值是0，引用類型默認值是null，boolean類型默認值是false。

Ⅷ java 調用靜態方法和構造函數和靜態塊執行的先後順序

java中首先是靜態塊先執行，靜態方法，最後是構造函數。示例如下：

publicclassExA{
static{
System.out.println("父類--靜態代碼塊");
}

publicExA(){
System.out.println("父類--構造函數");
}

{
System.out.println("父類--非靜態代碼塊");
}

publicstaticvoidmain(String[]args){
newExB();
}
}

classExBextendsExA{
static{
System.out.println("子類--靜態代碼塊");
}
{
System.out.println("子類--非靜態代碼塊");
}

publicExB(){
System.out.println("子類--構造函數");
}
}

執行結果
=====
父類--靜態代碼塊
子類--靜態代碼塊
父類--非靜態代碼塊
父類--構造函數
子類--非靜態代碼塊
子類--構造函數

Ⅸ java 類中定義一個類，這兩個類構造函數先後問題

JAVA初始化順序
1、調用順序:
JAVA類首次裝入時，會對靜態成員變數或方法進行一次初始化,但方法不被調用是不會執行的，靜態成員變數和靜態初始化塊級別相同，非靜態成員變數和非靜態初始化塊級別相同。
先初始化父類的靜態代碼--->初始化子類的靜態代碼-->
(創建實例時,如果不創建實例,則後面的不執行)初始化父類的非靜態代碼--->初始化父類構造函數--->初始化子類非靜態代碼--->初始化子類構造函數
其他說明:
2
、類只有在使用New調用創建的時候才會被JAVA類裝載器裝入
3、創建類實例時，首先按照父子繼承關系進行初始化
4、類實例創建時候，首先初始化塊部分先執行，然後是構造方法；然後從本類繼承的子類的初始化塊執行，最後是子類的構造方法
5、類消除時候，首先消除子類部分，再消除父類部分
你這里C繼承A，所以順序是：
A的屬性初始化-->A的構造-->C的屬性初始化(此時new
B()調用了B的構造)-->C的構造

Ⅹ 構造函數的調用順序

構造代碼塊的作用同樣是給對象進行初始化。對象一建立就運行構造代碼塊了，而且優先於構造函數執行。這里要強調一下，有對象建立，才會運行構造代碼塊，類不能調用構造代碼塊的，而且構造代碼塊與構造函數的執行順序是前者先於後者執行。

構造代碼塊與構造函數的區別是：構造代碼塊是給所有對象進行統一初始化，而構造函數是給對應的對象初始化，因為構造函數是可以多個的，運行哪個構造函數就會建立什麼樣的對象，但無論建立哪個對象，都會先執行相同的構造代碼塊。也就是說，構造代碼塊中定義的是不同對象共性的初始化內容。

(10)java構造函數順序擴展閱讀

1）使用new操作符創建對象。如果含有靜態成員變數：

靜態成員變數的靜態代碼塊 -> 靜態成員變數的代碼塊 -> 靜態成員變數的構造方法） -> 靜態代碼塊 -> 代碼塊 -> 構造函數

2）如果不含靜態成員變數：

靜態代碼塊 -> （靜態成員變數的靜態代碼塊 -> 靜態成員變數的代碼塊 -> 靜態成員變數的構造方法） -> 代碼塊 -> 構造函數。靜態代碼塊只執行一次，而每次創建對象都會調用共同的構造代碼塊，而構造函數也只在創建對象時執行該對象的構造函數。