结合接口时名字争辨难点

  从前未曾在意到落成八个接口可能会存在方法争论的题材,在《Thinking in
Java》中观察一个有意思的例子,其本质是重载和重写的难题,关于重载和重写的定义和分歧可参照另一篇文章Java基础一:面向对象的特色。首先看例子:

 1   interface I1 {
 2         void f();
 3     }
 4 
 5     interface I2 {
 6         int f(int i);
 7     }
 8 
 9     interface I3 {
10         int f();
11     }
12 
13     class C {
14         public int f(){
15             return 1;
16         }
17     }
18 
19     class C2 implements I1,I2{//重载
20         @Override
21         public void f() {}
22 
23         @Override
24         public int f(int i) {
25             return 0;
26         }
27     }
28 
29     class C3 extends C implements I2{
30         @Override
31         public int f(int i) {//重载
32             return 0;
33         }
34     }
35 
36     class C4 extends C implements I3{
37         @Override
38         public int f() {   //重写
39             return 0;
40         }
41     }
42 
43 //    class C5 extends C implements I1{}
44 //
45 //    interface I4 extends I1,I3{}
46 
47   public static void main(String[] args){
48         MethodCollision methodCollision = new MethodCollision();
49         C4 c4 = methodCollision.new C4();
50         System.out.println(c4.f());//输出0
51     }

   其中接口I1中设有方法void f(),I2中存在int f(int i),I3中存在int
f()
,类C中存在int f()的方法。

  C2类已毕接口I1和I2,其中落到实处的艺术void f()int f(int
i)
负有差其他署名,属于重载;

  C3类完结接口I2、继承C,C3兑现I2中的int f(int i),并继承C中的int
f()
措施,它们有着差距的签署,属于重载;

  C4类落成接口I3、继承C,C4落实I3中的int f(),并继承C中的int
f()
措施,它们具有相同的签约,并且再次回到值类型也一律,属于重写(从程序输出0可以声明);

  C5类完成接口I1、继承C,理论上,C5类会独家达成和继承I1方法void
f()
和C方法int
f()
,它们持有相同的签署,分裂的回来值类型,既不是重写,也不可能重载,故编译器提示错误;

  I4接口继承I1和I3,同样理论上接轨void f()int
f()
,但既不是重写,也无力回天重载,编译器报错。


  另一个好玩问题是,我如若将接口I1中的void
f()
改为int f()**,会时有爆发什么样功能啊?

 1     interface I1 {
 2         int f();
 3     }
 4 
 5     interface I2 {
 6         int f(int i);
 7     }
 8 
 9     interface I3 {
10         int f();
11     }
12 
13     class C {
14         public int f(){
15             return 1;
16         }
17     }
18 
19     class C2 implements I1,I2{//重载
20         @Override
21         public int f() {
22             return 0;
23         }
24 
25         @Override
26         public int f(int i) {
27             return 0;
28         }
29     }
30 
31     class C3 extends C implements I2{
32         @Override
33         public int f(int i) {//重载
34             return 0;
35         }
36     }
37 
38     class C4 extends C implements I3{
39         @Override
40         public int f() {   //重写
41             return 0;
42         }
43     }
44 
45     class C5 extends C implements I1{}//不重写该函数,继承自C的方法即为实现
46 
47     interface I4 extends I1,I3{}
48 
49     class C6 implements I4{//I1和I3的方法一样,实现类只实现一个
50         @Override
51         public int f() {
52             return 0;
53         }
54     }
55 
56     public static void main(String[] args){
57         MethodCollision methodCollision = new MethodCollision();
58         C4 c4 = methodCollision.new C4();
59         System.out.println(c4.f());//0
60 
61         C5 c5 = methodCollision.new C5();
62         System.out.println(c5.f());//1
63     }

   其中接口I1中存在方法int f(),I2中存在int f(int i),I3中存在int
f()
,类C中存在int f()的方法。

  C2类完成接口I1和I2,其中落到实处的主意int f()int f(int
i)
具备分歧的署名,属于重载;

  C3类完毕接口I2、继承C,属于重载;

  C4类完结接口I3、继承C,属于重写(从程序输出0可以表达);

  C5类达成接口I1、继承C,C5类会独家已毕和后续I1方法int
f()
和C方法int
f()
,其与C4类是一样的,它是重写吧?不是,因为其一连自C的函数已经落实了该接口,没有重写(从程序输出1足以表明);

  I4接口继承I1和I3,同时继续I1和I3的int
f()
,它们拥有相同的章程签名和再次回到值类型,所以I4具有一个int
f()
(可透过C6完毕类看出);

  C6类已毕接口I4,具有一个兑现函数int f()。

 总结:

  • 类不得以多重继承,接口能够多重继承;
  • 重组接口时,可能会设有方法重载和重写的难题,并且可能会引入代码的杂乱,下落代码可读性,故尽量幸免那种景况;
  • 通过该例,可以学习继承、接口落成、重载和重写概念,其中一些是类继承的办法也可以用作达成接口的落到实处方式。

 

相关文章