黑马程序员--高新技术--泛型

泛型：
1.5后出现的新特性，解决了安全问题，是一个类型安全机制。


好处：
1.将运行时期转移到编译时期，方便程序员解决问题。提高了安全性。


2.避免了强制转换的麻烦


ArrayList<String> 泛型语法
Iterator<String>


格式：

通过<>来定义要操作的引用数据类型。

什么时候使用泛型?

在集合中很常见，只要见到<>就要定义泛型。
<>是用来接收数据类型的泛型技术：其实应用在编译时期，是给编译器使用的技术，到了运行时期，泛型就不存在了。
为什么,因为泛型的擦除：也就是说，编辑器检查了泛型的类型正确后，在生成的类文件中是没有泛型的.

在运行时，如何知道获取的元素类型而不用强转呢？
泛型的补偿：
因为存储的时候，类型已经确定了是同一个类型的元素，所以在运行时，只要获取到该元素的类型，在内部进行一次转换即可，所以使用者不用再做转换动作了。

应用:

泛型类
什么时候定义泛型类？
当类中操作的引用数据类型不确定的时候，
早起定义Object来完成扩展。

现在定义泛型来完成扩展。

<span style="white-space:pre">		</span>class Utils<QQ> {
	
			private QQ q;
			
			public void setObject(QQ q); {
			
				this.q=q;
		  
			}
			public QQ gerobject() {
			   return q;
		   
			}

		}

泛型方法：
泛型类定义的反应，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。


为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

<span style="white-space:pre">		</span>class Demo {  
		
			public <T> void show(T t) {
			
			}


		}

静态方法泛型：静态方法不可以访问类上定义的泛型，如果静态方法操作的数据类型不确定，可以将泛型定义在方法上。


public static <W>  void menthod(W w){}




泛型接口：

<span style="white-space:pre">		</span>interface Inter<T> {
		
		   void show(T t);
		   
		}

		class InterImpl<R> implements Inter<R> {
		
			 public void show(R r) { 
			 
				  System.out.println("show:"+r); 
				  
			  }
		}

案例：给限定Integer类型的集合 添加 String类型

ArrayList<Integer> collection2 = new ArrayList<Integer>();   

System.out.println(collection1.getClass()==collection2.getClass());   

collection2.add（“呵呵 ”）；//这句会报错    

collection2.getClass().getMethod("add", Object.class).invoke(collection2, "呵呵");   

System.out.println(collection2.get(0)); //结果却为呵呵  

//已经限制集合中元素的类型为Integer，可用反射却能将String存入，为什么？ 

//这是因为泛型是给编译器用的，运行时就没有这些泛型信息了，这叫做“去泛型化”，所以可以通过反射，获取集合字节码加入非指定的类型。

泛型限定

通配符<?>,也可以理解为占位符号
? extends E:可以接受E类型或者E的子类型 上限 <? extends E>
? super E:可以接受E或E的父类型 下限  <? super E>


上限什么时候用：
往集合中添加元素时，既可以添加E类型对象，又可以添加E的子类型对象。为什么？因为取的时候，
E类型既可以接收E类对象，又可以接收E的子类型对象。?


下限什么时候用：
当从集合中获取元素进行操作的时候，可以用当前元素的类型接收，也可以用当前元素的父类型接收。




泛型的细节：

1）、泛型到底代表什么类型取决于调用者传入的类型，如果没传，默认是Object类型；
 
2）、使用带泛型的类创建对象时，等式两边指定的泛型必须一致； 
 
  原因：编译器检查对象调用方法时只看变量，然而程序运行期间调用方法时就要考虑对象具体类型了；
  
3）、等式两边可以在任意一边使用泛型，在另一边不使用(考虑向后兼容)； 
 
ArrayList<String> al = new ArrayList<Object>();  //错  //要保证左右两边的泛型具体类型一致就可以了，这样不容易出错。 

ArrayList<? extends Object> al = new ArrayList<String>(); al.add("aa");  //错  
 
//因为集合具体对象中既可存储String，也可以存储Object的其他子类，所以添加具体的类型对象不合适，类型检查会出现安全问题。
 
？extends Object 代表Object的子类型不确定，怎么能添加具体类型的对象呢？ 


  public static void method(ArrayList<? extends Object> al) { 
al.add("abc");  //错  


//只能对al集合中的元素调用Object类中的方法，具体子类型的方法都不能用，因为子类型不确定。
  }
总结: (借用下张老师的总结不是一般的强悍)
 
类型参数的类型推断
l 编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。

l 根据调用泛型方法时实际传递的参数类型或返回值的类型来推断，具体规则如下：

1．当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，
这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：
swap(new String[3],3,4)   à    static <E> void swap(E[] a, int i, int j)

2．当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，
这很容易凭着感觉推断出来，例如：
add(3,5)   à static <T> T add(T a, T b) 

3．当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，
且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：

fill(new Integer[3],3.5f)   à static <T> void fill(T[] a, T v) 

4．当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，
并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，
对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：

int x =(3,3.5f)   à static <T> T add(T a, T b) 

5．参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，
而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：

<span style="white-space:pre">			</span>copy(new Integer[5],new String[5]) à static <T> void copy(T[] a,T[]  b);
			copy(new Vector<String>(), new Integer[5]) à static <T> void copy(Collection<T> a , T[] b);

定义泛型类型

如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，
也就是类级别的泛型，语法格式如下：

<span style="white-space:pre">			</span>public class GenericDao<T> {
			private T field1;
			public void save(T obj){}
			public T getById(int id){}
			}

类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：

<span style="white-space:pre">			</span>GenericDao<String> dao = null;
			new genericDao<String>();

注意：

在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。
当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，
所以静态成员不应该有类级别的类型参数。