java多类继承例子_java多个类继承的方法问题实例

java多个类继承的方法问题实例。

假设有三个类，ClassA-ClassB-ClassC，ClassC在最底端。先看例子：

public class ClassA {

public void fun1(){

System.out.println(“A-fun1″);

}

public void fun2(){

System.out.println(“A-fun2″);

}

public void fun3(){

System.out.println(“A-fun3″);

}

public ClassA(){

System.out.println(“A-ClassA”);

}

}

public class ClassB extends ClassA{

public void fun1(){

System.out.println(“B-fun1″);

}

public ClassB(){

System.out.println(“B-ClassB”);

}

public ClassB(String str){

System.out.println(“B-ClassB(String)”);

}

}

public class ClassC extends ClassB{

public void fun1(){

System.out.println(“C-fun1″);

}

public void fun2(){

System.out.println(“C-fun2″);

System.out.println(“————-super.fun1()前————————”);

super.fun1();

System.out.println(“—————-super.fun1()后———————”);

}

public ClassC(){

super(“aaa”);

System.out.println(“C-ClassC”);

}

public static void main(String[] agrs){

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这个对象，执行时的类型是ClassC。

首先说构造方法。如果不写super()，相当于默认写了个super()，如果new ClassC()会从最顶端的类开始初始化，依次调用

A-ClassA()

B-ClassB()

C-ClassC()

而此处，我们在ClassC中写了个

super(“aaa”);

就会去调用B中的带参数的构造方法，而不再调用无参的构造方法。所以，当new ClassC()时，

我们得到的结果是：

A-ClassA

B-ClassB(String)

C-ClassC

特别要注意的是，super()只能在构造方法中使用，而且只能在第一行使用。this()也是同样的道理。

而我们在C的fun2()中调用了super.fun1();

则再一次调用了C的父类，也就是B的fun1()，输出一个B-fun1。

再来说三个方法的覆盖问题。

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

也就是说，虽然B中没有fun2(),而且C继承了B，但C同样可以覆盖fun2()。

说明了，凡是整个继承系统中有的方法，无论上一级类是否有，都可以覆盖。

按照这种写法

ClassA c1 = new ClassC();

B类中的方法，如果不是C类用了super.fun1()，是绝不可能调用到的。

也就是，如果不在C类的fun2()中写super.fun1()，输出结果应该是：

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()来看，也不可能调用到C类中的方法，因为执行时的类型为C。

下面再看一个例子：

public class Class1 {

int a = 1;

static int b = 2;

private int i = 1;

int j = 4;

{

System.out.println(“normal—Class1–(a==”+a+”)–(b==”+b+”)”);

}

static{

//System.out.println(“static—MClass1–”+a+”–”+b);//这里不认识非静态变量

System.out.println(“static—Class1–(b==”+b+”)”);

}

public Class1(){

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(){

System.out.println(“fun1—Class1–(i==”+i+”)”);

System.out.println(“fun1—Class1–(j==”+j+”)”);

}

}

public class Class2 extends Class1{

int c = 1;

static int d = 2;

{

System.out.println(“normal—Class2–(a==”+a+”)–(b==”+b+”)”);

System.out.println(“normal—Class2–(c==”+c+”)–(d==”+d+”)”);

}

static{

//System.out.println(“static—MClass1–”+a+”–”+b);//这里不能调用非静态变量

System.out.println(“static—Class2–(b==”+b+”)”);

System.out.println(“static—Class2–(d==”+d+”)”);

}

public Class2(){

System.out.println(“construct—Class2–(a==”+a+”)—(b==”+b+”)”);

System.out.println(“construct—Class2–(c==”+c+”)—(d==”+d+”)”);

}

}

public class Class3 extends Class2{

int e = 1;

static int f = 2;

private int i = 2;

int j = 3;

{

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{

//System.out.println(“static—MClass1–”+a+”–”+b);//这里不能调用非静态变量

System.out.println(“static—Class3–(b==”+b+”)”);

System.out.println(“static—Class3–(d==”+d+”)”);

System.out.println(“static—Class3–(f==”+f+”)”);

}

public Class3(){

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(){

System.out.println(“fun1—Class3–(i==”+i+”)”);

System.out.println(“fun1—Class3–(j==”+j+”)”);

}

public static void main(String[] agrs){

new Class3();

}

}

输出结果：

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)

这里有两个知识点要说明：

1、类的初始化顺序是：

(静态变量、静态初始化块)>(变量、初始化块)>构造器

而根据上面的输出结果看出，三个类的静态初始化块执行完了，再依次是：

Class1的非静态初始化块

Class1的构造器

Class2的非静态初始化块

Class2的构造器

Class3的非静态初始化块

Class3的构造器

值得注意的是，静态的方法和初始化块中都不能直接调用非静态变量！

2、写了一个小插曲，如果Class1中的fun1()被Class2中的fun1()覆盖，当Class1初始化(也就是调用Class1的构造器)时，

在Class1的构造器中调用this.fun1();会调到谁的？

两个类都有两个变量i、j，其中i是private

在Class1的构造器中调用this.i和this.j又会调到谁的？

记住一点，如果是调用方法，就看执行时的类型，如果是调用变量，就看编译时的类型。

所以说，fun1()会调用到 Class3的，而i、j会调用到Class1的。

又由于，所有的变量和方法都会最先在内存中开辟空间，变量初始值默认为0或null，

例如定义了int i=3 相当于写了先int i=0后面再写i=3;

当Class1初始化时，Class3并没有完成初始化，仅完在了int i=0这个步骤。

所以，在Class1初始化时调用Class3的fun1()输出Class3的i和j的值均为0。

而在Class1的构造器中输出i和j是属于Class1的，在执行构造器前就已经完成了赋值，所以。。。

其实，这儿不写this效果是一样的。