Java面向对象11-泛型与通配符

泛型：就是一种不确定的数据类型。
比如：ArrayList E就是泛型。 这种不确定的数据类型需要在使用这个类的时候才能够确定出来。
泛型可以省略，如果省略，默认泛型是Object类型。


自定义泛型类
 1 package com;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 //自定义泛型类
 7 public class order {
 8     private String orderName;
 9     private int orderId;
10     private T t;
11     List list = new ArrayList();
12     public void add(){
13         list.add(t);
14     }
15     public T getT(){
16         return t;
17     }
18     public void setT(T t){
19         this.t = t;
20     }
21     public String getOrderName() {
22         return orderName;
23     }
24     public void setOrderName(String orderName) {
25         this.orderName = orderName;
26     }
27     public int getOrderId() {
28         return orderId;
29     }
30     public void setOrderId(int orderId) {
31         this.orderId = orderId;
32     }
33     @Override
34     public String toString() {
35         return "order [orderId=" + orderId + ", orderName=" + orderName
36                 + ", t=" + t + "]";
37     }
38     
39     
40 }

注意：

1.在静态方法中不能使用泛型，因为静态方法早于对象创建执行

2.异常类不能是泛型的

泛型在继承方面的体现

类A是类B的父类，G和G二者不具备子父类关系，二者是并列关系。

补充：类A是类B的父类，A 是 B的父类

通配符？的使用：

 1 import org.w3c.dom.ls.LSInput;
 2 
 3 import java.util.Iterator;
 4 import java.util.List;
 5 
 6 public class test {
 7     public static void main(String[] args) {
 8         List list1 = null;
 9         List list2 = null;
10 
11         List<?> list = null;
12 
13         list = list1;
14         list = list2;
15 
16         test t = new test();
17         t.show(list1);
18         t.show(list2);
19     }
20 
21     public void show(List<?> list){
22         Iterator<?> iterator = list.iterator();
23         while(iterator.hasNext()) {
24             Object obj = iterator.next();
25             System.out.println(obj);
26         }
27     }
28 
29 }


添加（写入）：对于List<?>不能向起内部添加数据，null除外


获取（读取）：允许读取数据，读取的数据类型为object



有限制条件的通配符的使用



? extends T ----- 类型上界


这个时候这个通配符可以配的范围就是 T类型对象和T类型子类的对象
形象的也可以看成是 : (-oo , T];
就是负无穷到T — 把T包含在内
那么这个时候G<? extends A>就可以作为G< A>和G< B>的父类,其中A是B的父类


? super T — 类型下界


这个时候这个通配符可以配的范围就是T类型的对象和T类型的父类的对象
形象的说也可以看成是: [T , +oo)
也就是T到正无穷
那么这时候G<? super A> 就可以作为G< A>和G < C>的父类,其中A是C的子类




 1  /*
 2     有限制条件的通配符的使用
 3     ? extends A:
 4     G<? extends A> 可以作为G和G的父类，其中B是A的子类
 5     ? super A:
 6     G<? super A> 可以作为G和G的父类，其中B是A的父类
 7      */
 8     @Test
 9     public void test4(){
10         List<? extends Person> list1 = null;//<=
11         List<? super Person> list2 = null;//>=
12  
13         List list3 = new ArrayList();
14         List list4 = new ArrayList();
15         List list5 = new ArrayList();
16  
17         list1 = list3;
18         list1 = list4;
19 //        list1 = list5;
20  
21 //        list2 = list3;
22         list2 = list4;
23         list2 = list5;
24  
25         //读取数据：
26         list1 = list4;
27         Person p = list1.get(0);
28         //编译不通过
29 //        Student1 s = list1.get(0);
30  
31         list2 = list4;
32         Object o = list2.get(0);
33         //编译不通过
34 //        Person o = list2.get(0);
35  
36         //写入数据:
37         //编译不通过
38 //        list1.add(new Student1());
39  
40         //编译通过
41         list2.add(new Person());
42         list2.add(new Student1());
43  
44     }
						  
					  
						
							


						

							
							
			java面向对象							
						



						

						
						


						

						
					
					

					
					

						
相关

						

				
						
			

																
								

										
Java面向对象：super 关键字

									
									

								 

        

								

							
							

																
								

										
Java面向对象：继承

									
									

								 

        

								

							
							

																
								

										
Java面向对象

									
									

								 

        

								

							
							

																
								

										
Java面向对象

									
									

								 

        

								

							
							

																
								

										
Java面向对象

									
									

								 

        

								

							
							

																
								

										
典型的java面向对象的程序架构

									
									

								 

        

								

							
							

																
								

										
Java面向对象总结3

									
									

								 

        

								

							
							

																
								

										
Java面向对象

									
									

								 

        

								

							
							

																
								

										
JAVA面向对象之封装

									
									

								 

        

								

							
							

																
								

										
JAVA面向对象学习——java面向对象概念———一个简单的继承示例——final关键字

									
									

								 

        

								

							
							

																
								

										
Java面向对象01

									
									

								 

        

								

							
							

																
								

										
JAVA面向对象学习——java面向对象概念——Java 异常处理——checked异常和runtime异

									
									

								 

        

								

							
							
            
            
            
                                    
           
  			
						

					

					
				

				

														
					
					

					
									

					
									   
标签

										

										
    
										

									

										
										

									

					

					
				


			
		
		
		
			


						





	

	
一品网 冀ICP备14022925号-6