java多個(gè)類(lèi)繼承的方法有哪些？動(dòng)力節(jié)點(diǎn)小編來(lái)給大家舉例說(shuō)明。

假設(shè)有三個(gè)java類(lèi)，ClassA-ClassB-ClassC，ClassC在最底端。先看例子：

public class ClassA {undefined
public void fun1(){undefined
System.out.println(“A-fun1″);
}
public void fun2(){undefined
System.out.println(“A-fun2″);
}
public void fun3(){undefined
System.out.println(“A-fun3″);
}
public ClassA(){undefined
System.out.println(“A-ClassA”);
}
}
public class ClassB extends ClassA{undefined
public void fun1(){undefined
System.out.println(“B-fun1″);
}
public ClassB(){undefined
System.out.println(“B-ClassB”);
}
public ClassB(String str){undefined
System.out.println(“B-ClassB(String)”);
}
}
public class ClassC extends ClassB{undefined
public void fun1(){undefined
System.out.println(“C-fun1″);
}
public void fun2(){undefined
System.out.println(“C-fun2″);
System.out.println(“————-super.fun1()前————————”);
super.fun1();
System.out.println(“—————-super.fun1()后———————”);
}
public ClassC(){undefined
super(“aaa”);
System.out.println(“C-ClassC”);
}
public static void main(String[] agrs){undefined
ClassA c1 = new ClassC();
c1.fun1();
c1.fun2();
c1.fun3();
System.out.println(“————————————-”);
ClassB c2 = new ClassC();
c1.fun2();
c2.fun1();
}
}

輸出：

A-ClassA
B-ClassB(String)
C-ClassC
C-fun1
C-fun2
————-super.fun1()前————————
B-fun1
—————-super.fun1()后———————
A-fun3
————————————-
A-ClassA
B-ClassB(String)
C-ClassC
C-fun2
————-super.fun1()前————————
B-fun1
—————-super.fun1()后———————
C-fun1

c1這個(gè)對(duì)象，執(zhí)行時(shí)的類(lèi)型是ClassC。

首先說(shuō)構(gòu)造方法。如果不寫(xiě)super()，相當(dāng)于默認(rèn)寫(xiě)了個(gè)super()，如果new ClassC()會(huì)從最頂端的類(lèi)開(kāi)始初始化，依次調(diào)用

A-ClassA()

B-ClassB()

C-ClassC()

而此處，我們?cè)贑lassC中寫(xiě)了個(gè)

super(“aaa”);

就會(huì)去調(diào)用B中的帶參數(shù)的構(gòu)造方法，而不再調(diào)用無(wú)參的構(gòu)造方法。所以，當(dāng)new ClassC()時(shí)，

我們得到的結(jié)果是：

A-ClassA

B-ClassB(String)

C-ClassC

特別要注意的是，super()只能在構(gòu)造方法中使用，而且只能在第一行使用。this()也是同樣的道理。

而我們?cè)贑的fun2()中調(diào)用了super.fun1();

則再一次調(diào)用了C的父類(lèi)，也就是B的fun1()，輸出一個(gè)B-fun1。

再來(lái)說(shuō)三個(gè)方法的覆蓋問(wèn)題。

B覆蓋了fun1()，C覆蓋了fun1(),fun2()

也就是說(shuō)，雖然B中沒(méi)有fun2(),而且C繼承了B，但C同樣可以覆蓋fun2()。

說(shuō)明了，凡是整個(gè)繼承系統(tǒng)中有的方法，無(wú)論上一級(jí)類(lèi)是否有，都可以覆蓋。

按照這種寫(xiě)法

ClassA c1 = new ClassC();

B類(lèi)中的方法，如果不是C類(lèi)用了super.fun1()，是絕不可能調(diào)用到的。

也就是，如果不在C類(lèi)的fun2()中寫(xiě)super.fun1()，輸出結(jié)果應(yīng)該是：

A-ClassA
B-ClassB(String)
C-ClassC
C-fun1
C-fun2
A-fun3
————————————-
A-ClassA
B-ClassB(String)
C-ClassC
C-fun2
C-fun1

而從ClassB c2 = new ClassC()來(lái)看，也不可能調(diào)用到C類(lèi)中的方法，因?yàn)閳?zhí)行時(shí)的類(lèi)型為C。

下面再看一個(gè)例子：

public class Class1 {undefined
int a = 1;
static int b = 2;
private int i = 1;
int j = 4;
{undefined
System.out.println(“normal—Class1–(a==”+a+”)–(b==”+b+”)”);
}
static{undefined
//System.out.println(“static—MClass1–”+a+”–”+b);//這里不認(rèn)識(shí)非靜態(tài)變量
System.out.println(“static—Class1–(b==”+b+”)”);
}
public Class1(){undefined
System.out.println(“construct—Class1–(a==”+a+”)—(b==”+b+”)”);
System.out.println(“fun1—Class1–(this.i==”+this.i+”)”);
System.out.println(“fun1—Class1–(this.j==”+this.j+”)”);
this.fun1();
}
public void fun1(){undefined
System.out.println(“fun1—Class1–(i==”+i+”)”);
System.out.println(“fun1—Class1–(j==”+j+”)”);
}
}
public class Class2 extends Class1{undefined
int c = 1;
static int d = 2;
{undefined
System.out.println(“normal—Class2–(a==”+a+”)–(b==”+b+”)”);
System.out.println(“normal—Class2–(c==”+c+”)–(d==”+d+”)”);
}
static{undefined
//System.out.println(“static—MClass1–”+a+”–”+b);//這里不能調(diào)用非靜態(tài)變量
System.out.println(“static—Class2–(b==”+b+”)”);
System.out.println(“static—Class2–(d==”+d+”)”);
}
public Class2(){undefined
System.out.println(“construct—Class2–(a==”+a+”)—(b==”+b+”)”);
System.out.println(“construct—Class2–(c==”+c+”)—(d==”+d+”)”);
}
}
public class Class3 extends Class2{undefined
int e = 1;
static int f = 2;
private int i = 2;
int j = 3;
{undefined
System.out.println(“normal—Class3–(a==”+a+”)–(b==”+b+”)”);
System.out.println(“normal—Class3–(c==”+c+”)–(d==”+d+”)”);
System.out.println(“normal—Class3–(e==”+e+”)–(f==”+f+”)”);
}
static{undefined
//System.out.println(“static—MClass1–”+a+”–”+b);//這里不能調(diào)用非靜態(tài)變量
System.out.println(“static—Class3–(b==”+b+”)”);
System.out.println(“static—Class3–(d==”+d+”)”);
System.out.println(“static—Class3–(f==”+f+”)”);
}
public Class3(){undefined
System.out.println(“construct—Class3–(a==”+a+”)—(b==”+b+”)”);
System.out.println(“construct—Class3–(c==”+c+”)—(d==”+d+”)”);
System.out.println(“construct—Class3–(e==”+e+”)—(f==”+f+”)”);
i=222;
j=333;
}
public void fun1(){undefined
System.out.println(“fun1—Class3–(i==”+i+”)”);
System.out.println(“fun1—Class3–(j==”+j+”)”);
}
public static void main(String[] agrs){undefined
new Class3();
}
}

輸出結(jié)果：

static—Class1–(b==2)
static—Class2–(b==2)
static—Class2–(d==2)
static—Class3–(b==2)
static—Class3–(d==2)
static—Class3–(f==2)
normal—Class1–(a==1)–(b==2)
construct—Class1–(a==1)—(b==2)
fun1—Class1–(this.i==1)
fun1—Class1–(this.j==4)
fun1—Class3–(i==0)
fun1—Class3–(j==0)
normal—Class2–(a==1)–(b==2)
normal—Class2–(c==1)–(d==2)
construct—Class2–(a==1)—(b==2)
construct—Class2–(c==1)—(d==2)
normal—Class3–(a==1)–(b==2)
normal—Class3–(c==1)–(d==2)
normal—Class3–(e==1)–(f==2)
construct—Class3–(a==1)—(b==2)
construct—Class3–(c==1)—(d==2)
construct—Class3–(e==1)—(f==2)

這里有兩個(gè)知識(shí)點(diǎn)要說(shuō)明：

1.類(lèi)的初始化順序是：

(靜態(tài)變量、靜態(tài)初始化塊)>(變量、初始化塊)>構(gòu)造器

而根據(jù)上面的輸出結(jié)果看出，三個(gè)類(lèi)的靜態(tài)初始化塊執(zhí)行完了，再依次是：

Class1的非靜態(tài)初始化塊

Class1的構(gòu)造器

Class2的非靜態(tài)初始化塊

Class2的構(gòu)造器

Class3的非靜態(tài)初始化塊

Class3的構(gòu)造器

值得注意的是，靜態(tài)的方法和初始化塊中都不能直接調(diào)用非靜態(tài)變量!

2.寫(xiě)了一個(gè)小插曲，如果Class1中的fun1()被Class2中的fun1()覆蓋，當(dāng)Class1初始化(也就是調(diào)用Class1的構(gòu)造器)時(shí)，

在Class1的構(gòu)造器中調(diào)用this.fun1();會(huì)調(diào)到誰(shuí)的?

兩個(gè)類(lèi)都有兩個(gè)變量i、j，其中i是private

在Class1的構(gòu)造器中調(diào)用this.i和this.j又會(huì)調(diào)到誰(shuí)的?

記住一點(diǎn)，如果是調(diào)用方法，就看執(zhí)行時(shí)的類(lèi)型，如果是調(diào)用變量，就看編譯時(shí)的類(lèi)型。

所以說(shuō)，fun1()會(huì)調(diào)用到 Class3的，而i、j會(huì)調(diào)用到Class1的。

又由于，所有的變量和方法都會(huì)最先在內(nèi)存中開(kāi)辟空間，變量初始值默認(rèn)為0或null，

例如定義了int i=3 相當(dāng)于寫(xiě)了先int i=0后面再寫(xiě)i=3;

當(dāng)Class1初始化時(shí)，Class3并沒(méi)有完成初始化，僅完在了int i=0這個(gè)步驟。

所以，在Class1初始化時(shí)調(diào)用Class3的fun1()輸出Class3的i和j的值均為0。

而在Class1的構(gòu)造器中輸出i和j是屬于Class1的，在執(zhí)行構(gòu)造器前就已經(jīng)完成了賦值

其實(shí)，這兒不寫(xiě)this效果是一樣的。

以上就是關(guān)于“Java繼承多個(gè)類(lèi)的例子”介紹，大家如果對(duì)此比較感興趣，想了解更多相關(guān)知識(shí)，不妨來(lái)關(guān)注一下動(dòng)力節(jié)點(diǎn)的Java教程，里面的課程內(nèi)容細(xì)致全面，通俗易懂，很適合小白學(xué)習(xí)，希望對(duì)大家的學(xué)習(xí)能夠有所幫助哦。