1. package Test_Lianxi;
   
2. 
   
3. /*
   
4.         泛型定义在接口
   
5. */
   
6. //首先定义一个泛型接口
   
7. 
   
8. interface Inter <T> {
   
9.         void show(T t);
   
10. }
    
11. /*
    
12. //然后定义一个类，实现该泛型接口，并【指定具体类型】
    
13. class InterIm implements Inter<String>{
    
14.         public void show(String t){
    
15.                 System.out.println("show:"+t);
    
16.         }
    
17.         //在该方法中是可以再定义泛型方法来接收其他类型  【1】和【2】对比   就是我的这个问题讨论的地方
    
18.         public <W> void show1(W w){
    
19.                 System.out.println("show:"+w);
    
20.         }
    
21. }
    
22. */
    
23. //实现接口的时候仍然不确定类型。
    
24. class InterImp <T> implements Inter<T> {   //【2】
    
25.         public void show(T t){
    
26.                 System.out.println("show:"+t);
    
27.         }
    
28. }
    
29. 
    
30. 
    
31. 
    
32. public class Test7 {
    
33.         public static void main(String[] args)
    
34.         {        /*
    
35.                 //1确定类型
    
36.                 InterIm im = new  InterIm();
    
37.                 im.show("String-"+"jian");
    
38.                 im.show1("stati-"+9);
    
39.                 */
    
40.                 //2未知类型
    
41.                 InterImp<Integer> imp = new InterImp<Integer>();
    
42.                 imp.show(9);
    
43. 
    
44.                 InterImp<String> imp1 = new InterImp<String>();
    
45.                 imp1.show("jian");
    
46.         }
    
47. }
    

复制代码

这是毕老师15天-11 的视频内容，主要是讲泛型实现接口
首先定义一个泛型接口
然后定义了一个方法，实现了该泛型接口，并指定为String类型。
然后复写了接口中的方法，

这个时候创建实例的时候， 但是只能是String类型。
不能是其他类型。
这个时候我自作主张 在该类中添加了一个方法，泛型方法，实现了其他类型的接收。

然后老师继续讲了 在定义类实现接口的时候也不知道具体类型的情况下如何定义类。

大家请看，输出，
老师最后给出的方法，当需要其他类型的时候，还需要在创建一个实例，
而我上面添加的自定义泛型方法，则可以直接接收。

这种做法合适吗，

interface Inter <T> {
        void show(T t);
}

这个接口中的<T> 是全局变量类型，整个类中都可以使用

        public <W> void show1(W w){
                System.out.println("show:"+w);
        }
这个方法中的 <W> 只在该方法中有效。

说不上哪个好，根据需求使用。