java泛型基础－I

java泛型概念及作用

泛型是JDK 1.5的一项新特性，它的本质是参数化类型（Parameterized Type）的应用，那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

泛型的作用：

1. 类型安全：通过泛型定义的变量类型限制，编译器可以在高程度上验证类型假设；
2. 消除强制类型转换：消除了编码过程中强制类型转换，大大减少了代码出错率；
3. 提高代码的重用率；

泛型的基本使用

1：泛型类定义和使用
泛型类就是一个具有一个或者多个类型变量的类。

public class Pair<T> {
    private T first;
    private T second;
    public T getFirst() {
        return first;
    }
    public Pair()
    {
        first=null;
        second=null;
    }
    public Pair(T first,T second)
    {
        this.first=first;
        this.second=second;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public T getSecond() {
        return second;
    }
    public void setSecond(T second) {
        this.second = second;
    }
}

public static Pair<String> minmax(String[] a)
    {
        if(a==null||a.length==0)
        {
            return null;
        }
        String min=a[0];
        String max=a[0];
        for(int i=0;i<a.length;i++)
        {
            if(min.compareTo(a[i])>0)
                min=a[i];
            if(max.compareTo(a[i])<0)
                max=a[i];
        }
        return new Pair<>(min,max);
    }

测试端

import java.util.Date;

public class PairTest1 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String []a={"zhang","hao","zp","csu"};
        Pair<String> pair=ArrayUtil.minmax(a);
        System.out.println("min="+pair.getFirst());
        System.out.println("max="+pair.getSecond());
    }

}

运行结果：

min=csu
max=zp

2：泛型接口定义和使用

public interface Info <T,U>{
    public void show(T t,U u);
}

public class InfoImpl implements Info<String, Date> {

    @Override
    public void show(String t, Date u) {
        // TODO Auto-generated method stub
        System.out.println("信息内容："+t+"  "+"获取时间："+u);
    }
}

测试端：

public static void main(String[] args) {
        // TODO Auto-generated method stub
        InfoImpl infoImpl=new InfoImpl();
        infoImpl.show("下午打球", new Date());
    }

运行结果：

信息内容：下午打球  获取时间：Sat Apr 16 15:18:34 CST 2016

3：泛型方法

public static<T> T getMiddle(T...a)
    {
        return a[a.length/2];
    }

测试端1：

String middle=ArrayUtil.getMiddle("csu","fggt","private");
        System.out.println("middle="+middle);

运行结果：

middle=fggt

测试端2（注意这个不能编译通过）

double middle1=ArrayUtil.getMiddle(12.002,2,45);

运行结果：

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Type mismatch: cannot convert from Number&Comparable<?> to double at com.csu.fanxing.PairTest1.main(PairTest1.java:15)

结果分析：
主要是编译器将会自动打包参数为1个Double和两个Integer对象，然后寻找两个类的共同超类，Number&Comparable<?>。解决方案是将所有参数写为相同类型，例如double或int。
4：类型变量限定
有时候我们需要对类型变量加以约束，以确保类型变量满足某种需求，这个限定可以发生在类、接口、方法。
类型限定格式为<T extends 类名／接口名>
类型变量限定需要注意如下几点：

• 不管是限定类名还是接口，均使用关键字extends；
• 可以使用&符号给出多个限定；public static <T extends Comparable&Serializable> T get(T t1,T t2)
• 限定既有接口也有类，那么类必须只有一个，并且放在首位置。public static <T extends Object&Comparable&Serializable> T get(T t1,T t2)

实例： 泛型方法中只有限定为Comparable接口实现的类才能使用compareTo

public static <T extends Comparable<T>>Pair<T> minmax2(T[] a)
    {
        if(a==null||a.length==0)
        {
            return null;
        }
        T min=a[0];
        T max=a[0];
        for(int i=0;i<a.length;i++)
        {
            if(min.compareTo(a[i])>0)
                min=a[i];
            if(max.compareTo(a[i])<0)
                max=a[i];
        }
        return new Pair<>(min,max);
    }

java泛型中转换总结：
- 虚拟机中没有泛型，只有普通的类和方法；
- 所有类型参数都用它们的限定类型替换；
- 桥方法被合成来保持多态；
- 为保持类型安全性，必要时插入强制类型转换；