Java——泛型

一.   泛型

1. 概述

泛型，即“参数化类型”。就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

2. 特性

package com.zth;

import java.util.ArrayList;
import java.util.List;

public class Demo0{
    public static void main(String[] args){
        List<String> stringArrayList = new ArrayList<String>();
        List<Integer> integerArrayList = new ArrayList<Integer>();

        Class classStringArrayList = stringArrayList.getClass();
        Class classIntegerArrayList = integerArrayList.getClass();
        System.out.println(classIntegerArrayList == classStringArrayList);
        
    }
    
}

在使用泛型时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型，当然，在逻辑上我们可以理解成多个不同的泛型类型。

究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上可以看成是多个不同的类型，实际上都是相同的基本类型。

 

二.  泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

1.  泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

基本格式：

class 类名称 <泛型标识：标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....

  }
}

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

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

package com.zth;

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
class Generic<T>{
    //key这个成员变量的类型为T,T的类型由外部指定
    private T key;
    //泛型构造方法形参key的类型也为T，T的类型由外部指定
    public Generic(T key){
        this.key = key;
    }
    //泛型方法getKey的返回值类型为T，T的类型由外部指定
    public T getKey() {
        return key;
    }
}
public class Demo0{
    public static void main(String[] args){
        //泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
        //传入的实参类型需与泛型的类型参数类型相同，即为Integer.
        Generic<Integer> genericInteger = new Generic<Integer>(123456);

        //传入的实参类型需与泛型的类型参数类型相同，即为String.
        Generic<String> genericString =  new Generic<String>("haha");

        System.out.println(genericInteger.getKey());
        System.out.println(genericString.getKey());
    }

}

执行结果：

123456
haha

在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

public static void main(String[] args){
        Generic generic0 = new Generic("1111");
        Generic generic1 = new Generic(1111);
        Generic generic2 = new Generic(false);
        Generic generic3 = new Generic(11.11);

        System.out.println(generic0.getKey());
        System.out.println(generic1.getKey());
        System.out.println(generic2.getKey());
        System.out.println(generic3.getKey());
    }

执行结果：

1111
1111
false
11.11

【注】

• 泛型的类型参数只能是类类型，不能是简单类型。
• 不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。

　　if(ex_num instanceof Generic<Number>){ }

2.  泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中。

package com.zth;

import java.util.Random;

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

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

public class Demo0{
    public static void main(String[] args){
        FruitGenerator fruitGenerator = new FruitGenerator();
        System.out.println(fruitGenerator.next());
        System.out.println(fruitGenerator.next());
    }

}

3.  泛型通配符

3.1、用?代替具体的类型参数。

例如 List<?> 在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类。

package com.zth;

import java.util.ArrayList;
import java.util.List;

public class Demo0{
    public static void main(String[] args){
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();

        name.add("zth");
        age.add(18);
        number.add(13);
        getData(name);
        getData(age);
        getData(number);
    }
    public static void getData(List<?> data){
        System.out.println("data: "+data.get(0));
    }
}

执行结果：

data: zth
data: 18
data: 13

 因为getData()方法的参数是List类型的，所以name，age，number都可以作为这个方法的实参，这就是通配符的作用

3.2、定义类型通配符上限

通过形如  List<? extends Number>  来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。

package com.zth;

import java.util.ArrayList;
import java.util.List;

public class Demo0{
    public static void main(String[] args){
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();

        name.add("zth");
        age.add(18);
        number.add(13);

        // getUperNumber(name);1
        getUperNumber(age);
        getUperNumber(number);
    }
    public static void getData(List<?> data){
        System.out.println("data: "+data.get(0));
    }

    public static void getUperNumber(List<? extends Number> data){
        System.out.println("data: "+data.get(0));
    }
}

执行结果：

data: 18
data: 13

在(//1)处会出现错误，因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number，所以泛型为String是不在这个范围之内，所以会报错

3.3、定义类型通配符下限

通过形如 List<? super Number> 来定义，表示类型只能接受Number及其三层父类类型，如Objec类型的实例。

 

4. 泛型方法

泛型方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

下面是定义泛型方法的规则：

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

package com.zth;

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

    public static void main(String args[]){
        // 创建不同的数组
        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("双精度型数组元素为：");
        printArray(doubleArray);

        System.out.println("字符型数组元素为：");
        printArray(charArray);
    }
}