1. interface AA
   
2. {
   
3.         public static final int NUM = 8;
   
4.         public abstract void show();        //定义了一个show方法，
   
5. }
   
6. interface BB
   
7. {
   
8.         public static final int NUM = 81;
   
9.         public abstract void show();        //定义了一个show方法
   
10. }
    
11. interface DD
    
12. {
    
13.         public static final int NUM = 89;
    
14.         public abstract void function();
    
15. }
    
16. class CC implements AA,BB,DD
    
17. {
    
18.         public void show()        //类CC实现接口时，实现的是哪个接口的show方法？
    
19.         {
    
20.                 System.out.println(DD.NUM);
    
21.         }
    
22.        
    
23.         public void function()
    
24.         {
    
25.                 System.out.println("搞一次啊");
    
26.         }
    
27. }
    
28. /*问题：
    
29. *         这里有三个接口，其中AA接口和BB接口定义了同名方法，
    
30. * 那么类CC实现AA，BB两个接口时，实现的是哪个接口的方法？？有什么规则？
    
31. * 能不能实现特定接口的方法？
    
32. */

复制代码

你那个能编译通过么？？
编译器都不知道该实现哪个show方法
不要这样干啊~~{:soso_e127:}
如果你想简单点的话，可以把AA和BB中的两个show方法的参数列表改成不同的，这样实现这两个show方法的时候就实现了重载，简单的多
不然的话，需要定义内部类去实现一个接口，然后再使用里面的方法，相当费工夫，不值得

朋友，你的程序，是可以通过编译器的。
在CC这类中实现了show这个方法。说明，此方法是实现AA和BB接口中的show方法，并没有有什么特别的规则。根据java中实现接口的规则，可以这样理解。

java固定了 不能这么用  一个类的多个接口不允许出现同名函数(参数也相同的)，无论返回类型是否相同。这是不允许存在的,会编译失败,一定要避免这种情况的出现

但是你可以私有化成内部类。来进行实现

1. interface AA {
   
2.         public static final int NUM = 8;
   
3. 
   
4.         public abstract void show(); // 定义了一个show方法，
   
5. }
   
6. 
   
7. interface BB {
   
8.         public static final int NUM = 81;
   
9. 
   
10.         public abstract void show(); // 定义了一个show方法
    
11. }
    
12. 
    
13. interface DD {
    
14.         public static final int NUM = 89;
    
15. 
    
16.         public abstract void function();
    
17. }
    
18. 
    
19. class CC implements AA, BB, DD {
    
20. 
    
21.         private class MyInnerAA implements AA {
    
22.                 @Override
    
23.                 public void show() {// 建立一个私有内部类，用来实现
    
24.           System.out.println("AA");
    
25.                 }
    
26.         }
    
27. 
    
28.         private class MyInnerBB implements BB {
    
29.                 @Override
    
30.                 public void show() {// 建立一个私有内部类，用来实现
    
31.           System.out.println("BB");
    
32.                 }
    
33.         }
    
34. 
    
35.         private class MyInnerDD implements DD {{// 建立一个私有内部类，用来实现
    
36.         @Override
    
37.                 public void function() {
    
38.                         System.out.println("DD");
    
39. System.out.println(DD.NUM);
    
40.         }
    
41.         }
    
42. 
    
43.         public void function()
    
44. 
    
45.         {
    
46. 
    
47.                 System.out.println("搞一次啊");
    
48. 
    
49.         }
    
50. 
    
51. }
    

复制代码

克零岚 发表于 2013-3-7 11:55
java固定了 不能这么用  一个类的多个接口不允许出现同名函数(参数也相同的)，无论返回类型是否相同。这是 ...

可是我的编译没有失败啊。而且通过了，这个要怎么解释呢:funk:

赵家阳 发表于 2013-3-7 13:07
可是我的编译没有失败啊。而且通过了，这个要怎么解释呢

恩呢，编译没问题，查了查，若实现的两个接口的同名的方法返回值类型和参数（参数类型，参数数量，参数顺序）都相同的话，可以这样实现接口的方法，但你的代码运行时还有错，你没有main主方法，会出现运行时错误找不到主方法
public static void main(String[] args) {
                CC c=new CC();
                c.show();
        }

实现的是所有接口中的show方法
反正重写就可以了，每个类都回分别察看一下实现类当中是否复写了抽象方法
每个类只要在实现类当中找到了复写的方法，那就没问题啊。。。。。
就像有三个人都命令你在广场上建一座老虎的雕像，所有细节要求都一样
这时候你只要建立一座雕像，这三个人之间是不知道，他们同时要求你做同一个雕像
所以只要每个人过来看到的雕像，就是让你做的雕像，那么这三个人就都满意了。。。。。。

克零岚 发表于 2013-3-7 11:55
java固定了 不能这么用  一个类的多个接口不允许出现同名函数(参数也相同的)，无论返回类型是否相同。这是 ...

编译能不能通过  自己试试看   OK的   不允许的是  不同返回值的 同名函数（参数相同）  

克零岚 发表于 2013-3-7 15:36
恩呢，编译没问题，查了查，若实现的两个接口的同名的方法返回值类型和参数（参数类型，参数数量，参数顺 ...

1. package com.itheima.Lession;
   
2. public class ImpleDemo {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 CC c = new CC();
   
6.                 c.show();
   
7.                 int aa = c.show(18);
   
8.                 System.out.println(aa);
   
9.         }
   
10. }
    
11. interface AA
    
12. {
    
13.         public static final int NUM = 8;
    
14.         public abstract int show(int b);        //定义了一个show方法，
    
15.         public abstract void show();
    
16. }
    
17. interface BB
    
18. {
    
19.         public static final int NUM = 81;
    
20.         public abstract void show();        //定义了一个show方法
    
21. }
    
22. interface DD extends AA,BB
    
23. {
    
24.         public static final int NUM = 89;
    
25.         public abstract void function();
    
26.        
    
27.         public abstract int show(int bb);        //和AA接口中一样
    
28. }
    
29. class CC implements BB,AA,DD
    
30. {
    
31.         public void show()        //类CC实现接口时，实现的是哪个接口的show方法？
    
32.         {
    
33.                 System.out.println(DD.NUM);
    
34.         }
    
35.         public int show(int a)        //带有参数
    
36.         {
    
37.                 return a;
    
38.         }
    
39.        
    
40.         public void function()
    
41.         {
    
42.                 System.out.println("搞一次啊");
    
43.         }
    
44. }
    
45. 
    
46. /**这是我在eclipse里面的代码，运行结果是：
    
47. * 89
    
48. * 18
    
49. *
    
50. * 我的推测：
    
51. *         类实现接口中的同名函数时，总是寻找离implements关键字最近的接口来实现。这个你可以
    
52. * 把BB,AA,DD来回调换顺序，在eclipse中可以查看的到（见图片）
    
53. */
    
54. 
    
55. 这是完整的代码
    
56. 
    

复制代码

克零岚 发表于 2013-3-7 15:36
恩呢，编译没问题，查了查，若实现的两个接口的同名的方法返回值类型和参数（参数类型，参数数量，参数顺 ...

这个我知道。我当时复制代码时没有把main函数粘进来。不过完整的代码还有说明我都放在9楼。

赵家阳 发表于 2013-3-8 10:02
这个我知道。我当时复制代码时没有把main函数粘进来。不过完整的代码还有说明我都放在9楼。 ...

现在我的理解是两个接口共用一个实现，接口不是实体，只是声明。在JAVA中多次声明在原则是没有问题的，只要能保证只有一次实现就可以了。