java基础系列（六）--泛型

泛型

泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。

什么是泛型？

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

为什么使用泛型?

举个栗子 ：

    @Test
    public void test_1() {
        List arrayList = new ArrayList<>();
        arrayList.add("haha");
        arrayList.add(10);
        for (int i = 0; i < arrayList.size(); i++) {
            String item = (String) arrayList.get(i);
            System.out.println("泛型测试    item = " + item);
        }
    }

上面代码的运行结果:

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

ArrayList未指定泛型，可以存放任意Object，但是在遍历的时候做了强制类型转换就出异常！
如果我们改一下，加入泛型

List<String> arrayList = new ArrayList<String>();
...
//arrayList.add(10); 在编译阶段，编译器就会报错

泛型作用周期

泛型只在编译阶段有效。看下面的代码：

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    System.out.println("泛型测试,类型相同");
}

输出结果：泛型测试，类型相同。

通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

泛型的使用

泛型类

泛型类的声明: 在类名后面添加了类型参数声明,类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型

public class So<T> {
    private T t;

    public void add(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public static void main(String[] args) {
        So<Integer> integerSo = new So<Integer>();
        So<String> stringSo = new So<String>();

        integerSo.add(new Integer(10));
        stringSo.add(new String("haha"));

        System.out.printf("整型值为 :%d\n\n", integerSo.get());
        System.out.printf("字符串为 :%s\n", stringSo.get());
    }
}

编译以上代码，运行结果如下所示：

整型值为 :10

字符串为 :haha

多个类型参数

public class Soo<T, E> {
    private T t;
    private E e;

    public void add(T t, E e) {
        this.t = t;
        this.e = e;
    }

    public T getT() {
        return this.t;
    }

    public E getE() {
        return this.e;
    }

    public static void main(String[] args) {
        Soo<String, Integer> soo = new Soo<>();
        soo.add("haha", 100);
        System.out.println("T : " + soo.t.getClass().getTypeName() + " : " + soo.getT());
        System.out.println("E : " + soo.e.getClass().getTypeName() + " : " + soo.getE());
    }
}

编译以上代码，运行结果如下所示：

T : java.lang.String : haha
E : java.lang.Integer : 100

泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中，可以看一个例子：

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

实现类

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class FruitGenerator<T> implements Generator<T>{
 * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
 */
public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

泛型通配符

ava泛型中的标记符含义：

E - Element (在集合中使用，因为集合中存放的是元素)

T - Type（Java 类）

K - Key（键）

V - Value（值）

N - Number（数值类型）

？ - 表示不确定的java类型

泛型方法

所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。

每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。

泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }

    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组

        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组

        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}

• 
  
• 至此泛型基本概念和使用已经差不多了，还有一些小知识点
  
  • <? extends T>和<? super T>的区别
    

<? extends T>表示该通配符所代表的类型是T类型的子类。

<? super T>表示该通配符所代表的类型是T类型的父类。