java接口的继承和实现_java的继承和接口实现

Java是面向对象的语言，而运行时多态性是面向对象程序设计代码重用的一个最强大机制，动态性的概念也可以被说成“一个接口，多个方法”。 Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制，下面就继承和接口实现两方面谈谈java运行时多态 性的实现。

一、通过继承中超类对象引用变量引用子类对象来实现

举例说明：

1.           //定义超类superA

2.           class superA

3.           {

4.           int i = 100;

5.           void fun()

6.           {

7.           System.out.println(“This is superA”);

8.           }

9.           }

10.       //定义superA的子类subB

11.       class subB extends superA

12.       {

13.       int m = 1;  // enamel jewelry

14.       void fun()

15.       {

16.       System.out.println(“This is subB”);

17.       }

18.       }

19.       //定义superA的子类subC

20.       class subC extends superA

21.       {

22.       int n = 1;

23.       void fun()

24.       {

25.       System.out.println(“This is subC”);

26.       }

27.       }

28.       class Test

29.       {

30.       public static void main(String[] args)

31.       {

32.       superA a;

33.       subB  b = new subB();

34.       subC  c = new subC();

35.       a=b;  //

36.       a.fun();  (1)

37.       a=c;

38.       a.fun();  (2)

39.       }

40.       }

41.

运行结果为：

This is subB

This is subC

上述代码中subB和subC是超类superA的子类，我们在类Test中声明了3个引用变量a, b, c，通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问：“为什么(1)和(2)不输出：This is superA”。java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是

在超类中定义过的，也就是说被子类覆盖的方法。

所以，不要被上例中(1)和(2)所迷惑，虽然写成a.fun()，但是由于(1)中的a被b赋值，指向了子类subB的一个实例，因而(1)所调 用的fun()实际上是子类subB的成员方法fun()，它覆盖了超类superA的成员方法fun()；同样(2)调用的是子类subC的成员方法 fun()。

另外，如果子类继承的超类是一个抽象类，虽然抽象类不能通过new操作符实例化，但是可以创建抽象类的对象引用指向子类对象，以实现运行时多态性。具体的实现方法同上例。

不过，抽象类的子类必须覆盖实现超类中的所有的抽象方法，否则子类必须被abstract修饰符修饰，当然也就不能被实例化了。

二、通过接口类型变量引用实现接口的类的对象来实现

接口的灵活性就在于“规定一个类必须做什么，而不管你如何做”。我们可以定义一个接口类型的引用变量来引用实现接口的类的实例，当这个引用调用方法时，它会根据实际引用的类的实例来判断具体调用哪个方法，这和上述的超类对象引用访问子类对象的机制相似。

举例说明：

1.           //定义接口InterA

2.           interface InterA

3.           {

4.           void fun();

5.           }

6.           //实现接口InterA的类B

7.           class B implements InterA

8.           {

9.           public void fun()

10.       {

11.       System.out.println(“This is B”);

12.       }

13.       }

14.       //实现接口InterA的类C

15.       class C implements InterA

16.       {

17.       public void fun()

18.       {

19.       System.out.println(“This is C”);

20.       }

21.       }

22.       class Test

23.       {

24.       public static void main(String[] args)

25.       {

26.       InterA  a;

27.       a= new B();

28.       a.fun();

29.       a = new C();

30.       a.fun();

31.       }

32.       }

33.

输出结果为：

This is B

This is C

上例中类B和类C是实现接口InterA的两个类，分别实现了接口的方法fun()，通过将类B和类C的实例赋给接口引用a而实现了方法在运行时的动态绑定，充分利用了“一个接口，多个方法”展示了Java的动态多态性。

需要注意的一点是：Java在利用接口变量调用其实现类的对象的方法时，该方法必须已经在接口中被声明，而且在接口的实现类中该实现方法的类型和参数必须与接口中所定义的精确匹配。

结束语：以上就是java运行时多态性的实现方法，大家在编程过程中可以灵活运用，但是在性能要求较高的代码中不提倡运用运行时多态，毕竟Java的运行时动态方法调用较之普通的方法调用的系统开销是比较大的。