其中接口I1中设有方法,   其中接口I1中存在方法

  I4接口继承I1和I3,同时继续I1和I3的int
f()
,它们持有相同的格局签名和再次回到值类型,所以I4具有2个int
f()
(可透过C6达成类看出);

结合接口时名字争持难点,组合接口争辨难点

  从前并未在意到贯彻几个接口大概会存在方法冲突的题材,在《Thinking in
Java》中看出3个有趣的例子,其本质是重载和重写的难点,关于重载和重写的定义和区分可参看另一篇文章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类完结接口I② 、继承C,C3得以完毕I2中的int f(int i),并继承C中的int
f()
措施,它们具有不一样的签约,属于重载;

  C4类完毕接口I叁 、继承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类完成接口I② 、继承C,属于重载;

  C4类完结接口I③ 、继承C,属于重写(从程序输出0能够证实);

  C5类完毕接口I① 、继承C,C5类会分别已毕和后续I1方法int
f()
和C方法int
f()
,其与C4类是一样的,它是重写吧?不是,因为其三番五次自C的函数已经已毕了该接口,没有重写(从程序输出1方可表达);

  I4接口继承I1和I3,同时继续I1和I3的int
f()
,它们持有同等的措施签名和重回值类型,所以I4具有1个int
f()
(可经过C6达成类看出);

  C6类达成接口I4,具有三个兑现函数int f()。

  C3类落成接口I贰 、继承C,C3落实I2中的int f(int i),并继承C中的int
f()
主意,它们持有不同的签署,属于重载;

 总结:

  • 类不得以多重继承,接口可以多重继承;
  • 构成接口时,恐怕会存在方法重载和重写的难题,并且或然会引入代码的混杂,下落代码可读性,故尽量幸免那种地方;
  • 经过该例,可以学学继承、接口落成、重载和重写概念,其中一些是类继承的点子也足以看作落实接口的兑现格局。

 

http://www.bkjia.com/Javabc/1211736.htmlwww.bkjia.comtruehttp://www.bkjia.com/Javabc/1211736.htmlTechArticle组合接口时名字冲突问题,组合接口冲突问题
在此以前从没在意到贯彻七个接口只怕会设有方法抵触的问题,在《Thinking in
Java》中看出1个有…

 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中设有方法int f(),I2中存在int f(int i),I3中存在int
f()
,类C中存在int f()的方法。

  C2类已毕接口I1和I2,其中落到实处的办法void f()int f(int
i)
抱有不同的签署,属于重载;

  C2类已毕接口I1和I2,其中落实的措施int f()int f(int
i)
富有差距的签署,属于重载;

  C3类完结接口I贰 、继承C,属于重载;

  C6类落成接口I4,具有2个落成函数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     }

  C5类完成接口I① 、继承C,理论上,C5类会独家落成和再三再四I1方法void
f()
和C方法int
f()
,它们有着同等的签名,不相同的归来值类型,既不是重写,也不恐怕重载,故编译器提醒错误;

  C4类落成接口I三 、继承C,属于重写(从程序输出0可以印证);


  另一个有意思难点是,小编假如将接口I1中的void
f()
改为int f()**,会发出什么样意义啊?

  C5类完成接口I壹 、继承C,C5类会分别完结和继承I1方法int
f()
和C方法int
f()
,其与C4类是同等的,它是重写吧?不是,因为其继承自C的函数已经落到实处了该接口,没有重写(从程序输出1足以作证);

  此前从没在意到贯彻八个接口恐怕会存在方法争执的难点,在《Thinking in
Java》中观察一个妙不可言的事例,其本质是重载和重写的标题,关于重载和重写的定义和界别可参看另一篇文章Java基础一:面向对象的风味。首先看例子:

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

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

  C4类达成接口I三 、继承C,C4贯彻I3中的int f(),并继承C中的int
f()
艺术,它们具有同等的签字,并且再次回到值类型也同样,属于重写(从程序输出0可以印证);

相关文章