泛型的高级应用

缺乏、安全感 2022-07-14 02:29 205阅读 0赞

泛型的高级应用

泛型的高级应用分为三种：一、？二、extends 三、super

一、泛型中的通配符“？”相当于多态中的Object，泛型中要兼容所有的类型要用“？”使用通配符“？”后，里面的元素只能调用Object的函数。

二、泛型的上限：extends，限定父类

上限的应用场合：，往集合当中加入元素

三、泛型的下限：super

多个子类的公共部分即他们的父类

下限的应用场合：从集合当中把元素读取出来，进行操作（调用所有集合中的元素的父类的方法）

我们要注意的是：泛型没有多态，因为泛型只有编译期。![Center][]

![Center 1][]

下面我们通过实例代码来理解：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** cn.hncu.generic.three;  
2.    
3.  **import** java.util.ArrayList;  
4.  **import** java.util.Iterator;  
5.  **import** java.util.List;  
6.    
7.    
8.  /\*\* 
9.   \* @author 军街 
10.  \*泛型的高级应用(1? 2super 3extends) 
11.  \*这个例子是写通配符 ?的 
12.  \*/  
13. **public** **class** GenericAdvDemo1 \{  
14.       
15.     **public** **static** **void** main(String\[\] args) \{  
16.         List<String> list=**new** ArrayList<String>();  
17.         list.add("\*\*\*");  
18.         list.add("aaa");  
19.         list.add("hello word");  
20.         print(list);  
21.         List<Integer> list2=**new** ArrayList<Integer>();  
22.         list2.add(100);  
23.         list2.add(111);  
24.         list2.add(123);  
25.         print(list2);  
26.           
27.           
28.     \}  
29.   
30.     **private** **static** **void** print(List<?> list) \{  
31.         Iterator<?> it=list.iterator();  
32.         **while**(it.hasNext())\{  
33.             System.out.println(it.next());  
34.         \}  
35.     \}  
36.   
37. \}

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** cn.hncu.generic.three;  
2.    
3.  **import** java.util.ArrayList;  
4.  **import** java.util.Iterator;  
5.  **import** java.util.List;  
6.    
7.  /\*\* 
8.   \* @author 军街 
9.   \*泛型的高级应用 extends 
10.  \*/  
11. **public** **class** GenericAdcDemo2 \{  
12.     **public** **static** **void** main(String\[\] args) \{  
13.         List<Person> list=**new** ArrayList<Person>();  
14.         list.add(**new** Person("Jack", 20));  
15.         list.add(**new** Person("Cv", 21));  
16.         list.add(**new** Person("WWW", 22));  
17.         print(list);  
18.           
19.         List<Student> list2=**new** ArrayList<Student>();  
20.         list2.add(**new** Student("qqq", 22, 1));  
21.         list2.add(**new** Student("eee", 23, 2));  
22.         list2.add(**new** Student("qwer", 20, 3));  
23.         print(list2);  
24.     \}  
25.     **public** **static** **void** print(List<? **extends** Person> list)\{  
26.         Iterator<? **extends** Person> it=list.iterator();  
27.         **while**(it.hasNext())\{  
28.             System.out.println(it.next());  
29.         \}  
30.     \}  
31. \}  
32. **class** Person\{  
33.     String name;  
34.     **int** age;  
35.     **public** Person(String name, **int** age) \{  
36.         **super**();  
37.         **this**.name = name;  
38.         **this**.age = age;  
39.     \}  
40.     **public** String getName() \{  
41.         **return** name;  
42.     \}  
43.     **public** **int** getAge() \{  
44.         **return** age;  
45.     \}  
46.     @Override  
47.     **public** String toString() \{  
48.         **return** "Person \[name=" + name + ", age=" + age + "\]";  
49.     \}  
50.       
51. \}  
52. **class** Student **extends** Person\{  
53.     **private** **int** no;  
54.   
55.     **public** Student(String name, **int** age, **int** no) \{  
56.         **super**(name, age);  
57.         **this**.no = no;  
58.     \}  
59.   
60.     @Override  
61.     **public** String toString() \{  
62.         **return** "Student \[no=" + no + ", name=" + name + ", age=" + age + "\]";  
63.     \}  
64.   
65.       
66.       
67. \}

**T 和 ?的区别**

？表示任意的都可以，T则是作为参数定义的。

java 泛型中 T 和 问号（通配符）的区别 类型本来有：简单类型和复杂类型，引入泛型后把复杂类型分的更细了；
     
      
       现在List<Object>, List<String>是两种不同的类型;且无继承关系；
       泛型的好处如： 开始版本   public void write(Integer i, Integer[] ia);
      public void write(Double  d, Double[] da);
     泛型版本   public <T> void write(T t, T[] ta);
     简便了代码
      定义泛型
     
      
       1.定义在类后面 紧跟类名后面   public class TestClassDefine<T, S extends T>{}
     定义泛型 T, S, 且S 继承 T
       2.定义在方法装饰符后面 紧跟修饰符后面（public）   public <T, S extends T> T testGenericMethodDefine(T t, S s){}
     定义泛型 T, S, 且S 继承 T
      实例化泛型
     
      
       1.实例化定义在类上的泛型
      第一声明类变量或者实例化时。例如 List<String> list; list = new ArrayList<String>; 第二继承类或者实现接口时。例如  public class MyList<E> extends ArrayList<E> implements List<E> {...} 
    
     
      
       2.实例化定义方法上的泛型<br/>
      当调用范型方法时，编译器自动对类型参数(泛型)进行赋值，当不能成功赋值时报编译错误 通配符(?) 上面有泛型的定义和赋值；当在赋值的时候，上面一节说赋值的都是为具体类型，当赋值的类型不确定的时候，我们用通配符(?)代替了： 如 List<?> unknownList; List<? extends Number> unknownNumberList; List<? super Integer> unknownBaseLineIntgerList; 
     
      
      
       在Java集合框架中，对于参数值是未知类型的容器类，只能读取其中元素，不能向其中添加元素， 因为，其类型是未知，所以编译器无法识别添加元素的类型和容器的类型是否兼容，唯一的例外是NULL

[Center]: /images/20220714/a1b0625263bf4f469e3470388ef24feb.png
[Center 1]: /images/20220714/b8a46f423f7b4ecfad21700f53ad0b86.png
[view plain]: http://blog.csdn.net/new___smile/article/details/50992106#