黑马程序员——泛型

         ------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

  什么是泛型，顾名思义，就是泛指的类型。java5开始出现的一种对Java语言类型的一种拓展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数类型时指定的类型占位符,就好比方法的形式参数是实际参数的占位符一样。泛型能保证大型应用程序的类型安全和良好的维护性。

  泛型的优点：

  1.类型安全,使编译器对泛型定义的类型做判断限制.如保证TreeSet里的元素类型必须一致;

  2.消除强制类型的转换,如,使用Comparable比较时每次都需要类型强转;

  使用泛型的方法：

  在类声明时通过一个标识符表示类中某个字段的类型或者某个方法的返回值或参数的类型，这样在类声明或实例化的时候只要指定自己需要的类型就行了。

  泛型使用的简单例子如下：

package bokedemo;
 
public class Gennarate {
public static void main(String[] args) {
//以String具体化泛型T
new GennarateDemo<String>().getT("hao");
//以Integer具体化泛型T
new GennarateDemo<Integer>().getT(12);
//以Gennarate具体化泛型T
new GennarateDemo<Gennarate>().getT(new  Gennarate());
}
}
class GennarateDemo<T>
{
 	public void getT(T t)
 	{
 	System.out.println(t);
 	}
}

  若一个类中多个字段需要不同的泛型声明，则在声明类的时候指定多个泛型类型即可；

  如下所示修改上面代码：

 package bokedemo;
 
public class Gennarate {
public static void main(String[] args) {
//以String具体化泛型T,以Integer具体化泛型TF
new GennarateDemo<String,Integer>().getT("hao",1);
//以Integer具体化泛型T,以Gennarate具体化泛型TF
new GennarateDemo<Integer,Gennarate>().getT(12,new  Gennarate());
//以Gennarate具体化泛型T,以String具体化泛型TF
new GennarateDemo<Gennarate,String>().getT(new  Gennarate(),"hahaa");
}
}
class GennarateDemo<T,TF>
{
 	public void getT(T t,TF tf)
 	{
 	System.out.println(t);
 	System.out.println(tf);
 	}
}

  泛型中的通配符？：

  使用 ？ ，表示未知类型的泛型对象：

这种带通配符的List仅表示各种泛型List的父类，并不能把元素添加入集合中；

如List<?> 表示未知元素的List集合；

List<?> list = new ArrayList<>(); list.add(1);//ERROR

public void show(List<?> list){}//表示可接受任意类型的List集合

  泛型的上下限：

  设置泛型对象的上限使用extends,表示参数类型只能是该类型或该类型的子类：

声明对象：类名<? extends 类> 对象名

定义类：类名<泛型标签 extends 类>{}

  设置泛型对象的下限使用super,表示参数类型只能是该类型或该类型的父类：

声明对象：类名<? super 类> 对象名称

定义类：类名<泛型标签 extends类>{}

  泛型上限的例子：

public static void main(String[] args) {
Person<Integer> p1 = new Person<>();
p1.setVal(12);
Person<Double> p2 = new Person<>();
p2.setVal(5.6);
Person<String> p3 = new Person<>();
p3.setVal("好");
show(p1);//√
show(p2);//√
show(p3);//×
}
public static void show(Person<? extends Number> p){
        //getVal()是泛型Person<? extends Number> p中的方法
System.out.println(p.getVal());
}

泛型下限的例子：

 public static void main(String[] args) {
Person<Integer> p1 = new Person<>();
p1.setVal(23);//Integer
Person<Double> p2 = new Person<>();
p2.setVal(1.22;//Double
Person<String> p3 = new Person<>();
p3.setVal("hao");//String
Person<Object> p4 = new Person<>();
p4.setVal(new Object());//Object
 
show(p1);//×
show(p2);//×
show(p3);//√
show(p4);//√
}
public static void show(Person<? super String> p){
        //getVal()是泛型Person<? super String> p中的方法
System.out.println(p.getVal());

  泛型的接口：

  java5后，可以声明泛型接口，声明方式和声明泛型类是一样的。

如public interface IDemo<T>{}

  泛型接口子类有两种方式：

  1.直接在子类后申明泛型；

  2.在子类实现的接口中给出具体的泛型类型

如下是方式1：

public class DaoImpl<T> implements IDAO<T>{
 
}

如下是方式2：

public class DaoImpl implements IDAO<String> {
 
}

  泛型的方法：

  方法中可定义泛型参数，形参的参数类型就是实参的类型。

  格式：

  <泛型标签> 返回值类型 方法名([泛型标签 参数]...)

如下：

package bokedemo;
 
public class Gennarate {
//必须要有泛型标签<T>，而且这个标签要在返回类型之前
public <T> void testGennarate(T t)
{
  	System.out.println("fx");
}
}

  或者可以这样：

package bokedemo;
 
public class Gennarate {
//返回类型是T
public <T> T testGennarate(T t)
{
  	System.out.println("fx");
  	return t;
}
}

  在严格的泛型代码里，带泛型声明的类总应该带着类型参数。但是为了和老的Java代码保持一致，也允许在使用带泛型声明的类时不指定类型参数，若没有为这个泛型类指定类型参数则该类型参数被称做一个原始类型，默认是该声明参数时指定的最上限类型（Object）；

  当把一个具有泛型信息的对象赋给另一个没有泛型信息的变量时，则所有在尖括号之间的类型信息都被扔掉，这就是泛型的擦除。

例子如下：

package bokedemo;
 
import java.util.HashSet;
 
public class Gennarate {
public static void main(String[] args) {
HashSet<String> hset=new HashSet<String>();
HashSet set=hset;//会擦除泛型。将有泛型信息的haset赋给没有泛型信息的set会擦除泛型。
}
}