大家运行一下哈。。

1. 
   
2. 
   
3. class Fu<String>
   
4. {
   
5.         public void show()
   
6.         {
   
7.                 System.out.println("zilei");
   
8.         }
   
9. }
   
10. class Zi extends Fu
    
11. {
    
12.         public void show()
    
13.         {
    
14.                 System.out.println("fulei");
    
15.         }
    
16. }
    
17. class Jk
    
18. {
    
19.         
    
20.         public void method(Fu<? super Zi> a)
    
21.         {
    
22.                 a.show();
    
23.         }
    
24. }
    
25. class Demo4
    
26. {
    
27.         public static void main(String[] args)
    
28.         {
    
29.                 new Jk().method(new Fu());
    
30.                 new Jk().method(new Zi());
    
31.         }
    
32. }

复制代码

两个的答案不同，  有点晕了。。。

1. class Fu<String>
   
2. {
   
3.         public void show()
   
4.         {
   
5.                 System.out.println("zilei");
   
6.         }
   
7. }
   
8. class Zi extends Fu
   
9. {
   
10.         public void show()
    
11.         {
    
12.                 System.out.println("fulei");
    
13.         }
    
14. }
    
15. class Jk
    
16. {
    
17.        
    
18.         public void method(Fu<? extends Zi> a)
    
19.         {
    
20.                 a.show();
    
21.         }
    
22. }
    
23. class Demo4
    
24. {
    
25.         public static void main(String[] args)
    
26.         {
    
27.                 new Jk().method(new Fu());
    
28.                 new Jk().method(new Zi());
    
29.         }
    
30. }

复制代码

应该相同么？

:L第一个方法传进去了个父类对象，当然调用的是父类的方法。第二个传进去的是一个子类对象，调用的就是子类的方法了，父类的方法被覆盖了。关泛型什么事。

我把我自己给绕进去了 :Q:Q:Q:Q:Q:Q:Q:Q

表示运行的结果都是一样的

不是类的泛型，在方法返回值前要加上泛型。