Java必知必会之（二）---泛型（上）

首先来看一段代码：

 //定义一个集合，往集合中加入不同类型的原型
 List list=new ArrayList();
 list.add("1");//String 
 list.add("2");//String 
 list.add(3);//int

 //error :Type mismatch: cannot convert from element type Object to String
 for(String r:list){
  System.out.println(r);
}

如上，在JDK1.5之前，我们一不小心就会写出这样的代码，使用时才发现类型误。
而jdk1.5后，我们会这样写：

1List<String> list=new ArrayList();
2        list.add("1");//String 
3        list.add("2");//String 
4        //The method add(int, String) in the type List<String> is not applicable for the arguments (int)
5        list.add(3);//int
6
7        for(String r:list){
8            System.out.println(r);
9        }

编译器会在你add一个int类型的数据的时候，就告诉你类型错误，这样可以避免在使用时才发生错误。
比较上面的例子，其实不难发现，第二个例子只是多了个“棱形语法”： <>

这是因为Java1.5加入了“参数化类型”的概念，即本文所说的泛型，它允许程序在创建集合时指定集合元素的类型,因此在创建List的时候同时指定了List集合里的元素类型为String，所以在list.add一个整型数据，编译器就报错。

所谓泛型，就是允许在定义类、接口、方法时指定类型形参（分别称为泛型类、泛型接口、泛型方法），这个类型形参将在声明变量、创建对象、调用方法时动态地指定(即传入实际的类型参数，也可称为类型实参)。

泛型类：

我们来考虑这样的一个场景，当我们又两个类，两个类中的内容一模一样，OK，我们可以把类A复制一份，改名成B类，这样子就是类名不一样，内容一样，这样操作没问题。
那我们现在把问题放大一点，如果有100个类名称不同，成员变量不同，但是逻辑一样的，是不是也是copy一百份A，类名改成A1、A2、….A100呢？
这就有点反人类了哈。
按照所谓的编程思想，当一段代码在项目中重复无数次的时候，我们就得把Java中的封装继承多态巴拉巴拉的拿出来想一下了，是不是应该抽出来，还是应该应该写一个父类集成..等等，其实这些都可以做到，但今天的主题不是这个哈。
还是回到我们的泛型，泛型允许我们类型参数化，那是不是可以把我们的A和B或者A1、A2、…A100都看成参数传进一个通用类中，然后这个类返回的实例就是我们的A实例、B实例…
我们来试试。先定义一个泛型类，如下：

 1public class TestT<T> {
 2    private T t;
 3    public TestT(T t){
 4        this.t=t;
 5    }
 6    public T getTestT(){
 7        return this.t;
 8    }
 9    public void setTest(T t){
10        this.t=t;
11    }
13}

然后我们把Integer类型的A、Double类型的A1、String类型的B作为参数穿进去，创建实例，结果如下：

 1public static void main(String[] args) {
 2        // A实例 Integer对象
 3        TestT<Integer> A = new TestT<Integer>(13);
 4        System.out.println(A.getTestT());
 5
 6        // A1实例 Double对象
 7        TestT<Double> A1 = new TestT<Double>(11.0);
 8        System.out.println(A1.getTestT());
 9
10        // B实例 String对象
11        TestT<String> B = new TestT<String>("我是B");
12        System.out.println(B.getTestT());
13    }

最终结果如我们所愿，需要什么就传进去，出来的就是我们想要的实例了。

这就是泛型类，它用在类的定义中，通过来对一个类添加泛型来实现对外提供相同的接口，就如我们经常用到但是没多注意的容器类一样：

1//List
2List<String> l=new ArrayList();
3//Set
4Set<Integer> s=new TreeSet();
5//Map
6Map<String,Double> m=new HashMap();

泛型类的基本写法如下：

1//下面我用大写C标识泛型标识，小c标识成员变量
2//可以换任意的字符标识的
3class 类名称 <泛型标识 C>{
4  private 泛型标识 C  成员变量 c; 
5  private 泛型标识 类名称(){
6    this.c=c 
7   }
8  }
9}

泛型接口：

泛型接口就是在定义接口时使用泛型，通常被用在各种类的生产器中

1  类型修饰符interface 接口名称 <泛型标识 C>{
2
3}

我们先定义一个接口TestInterface，接口里有一个方法 test

1interface TestInterface<T> {
2    public void test(T t);
3}

然后我们定义一个类ImpTest实现TestInterface接口

1public class ImpTest implements TestInterface<Integer>{
2    @Override
3    public void test(Integer t) {
4
5    }
6}

泛型接口基本上就这样用了，但是有人会问，如果我定义的这个类也是不确定类型的呢？那简单，泛型类实现泛型接口：

1class ImpTest2<T> implements TestInterface<T>{
2    @Override
3    public void test(T t) {
4    }
5}

泛型方法：

所谓泛型方法，就是在声明方法时定义一个或多个类型形参，在调用方法的时候指明泛型的具体类型。

1修饰符 <T, S> 返回值类型 方法名(形参列表)
2{
3    // 方法体...
4}

常见的例子：

 1//    实例方法-返回泛型变量对应的类型的数据
 2    public  <T> T getString(T tr){
 3        return tr;
 4    }
 5//    静态泛型方法--返回已知类型：string 的互数据
 6    public static <T> String getStaticString(T tr){
 7        return tr.toString();
 8    }
 9    //可变泛型参数的泛型方法
10    public <T> void getString( T... args){
11        for(T t : args){
12            System.out.print(t);
13        }
14    }

小结：
以上讲的是泛型的来源以及泛型的类、接口、方法的基本用法，基于原理即是一切的原则，加上我们广大程序猿一通百通的脑壳，再加上在实际开发根本不想用用太深奥的语法的懒惰心里，泛型本文应到此结束，但是为了照顾到
那些为了面试而背投各个知识点的面试者
那些为了期末考试而寻找所有考点的在校学生
那些为了钻牛角尖而不想错过任何细节的筒子们
。。。。。
说了这么多
我只是插个广告：
泛型还有下集！！！！！

题外话：
有队友可能疑惑，jdk1.5之前没有泛型，遇到这些场景就没办法了吗？并不是，大家都知道，在Java里万物皆对象，也就是Object，因此在jdk1.5之前是通过指定类型为Object类做到参数化。

觉得本文对你有帮助？请分享给更多人
关注「编程无界」，提升装逼技能