Java泛型

博客地址

定义

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

常用的泛型变量

E：元素（Element），多用于java集合框架
K：关键字（Key）
N：数字（Number）
T：类型（Type）
V：值（Value）

使用泛型的意义

1. 适用于多种数据类型执行相同的代码（代码复用）
2. 泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

泛型类的使用

public class A<T> {

    T i;
    private T getI(){
        return i;
    }
    public void setI(T i) {
        this.i = i;
    }


    public static void main(String[] args) {
        A<String> a = new A<String>();
        a.setI("xxxiii");

        A<Integer> a1 = new A<Integer>();
        a1.setI(333);
        System.out.println(a.getI() instanceof String);
        System.out.println(a1.getI() instanceof Integer);
    }
}

泛型接口的使用

定义接口

public interface GenericInter<T> {

    public T getData();
}

第一种实现方式

在实现时不明确指定类型

public class GenericImpl<T> implements GenericInter<T> {
    private T data;


    @Override
    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }


    public static void main(String[] args) {
        GenericImpl<Integer> genericImpl = new GenericImpl<>();
        genericImpl.setData(123);
        GenericInter<Integer> genericInter = genericImpl;
        System.out.println(genericInter.getData() instanceof Integer);
    }
}

输出结果为 true

第二种实现方式

在实现时明确指定类型

public class GenericImpl2 implements GenericInter<String> {
    @Override
    public String getData() {
        return "getData";
    }

    public static void main(String[] args) {
        GenericInter<String> genericinter = new GenericImpl2();
        System.out.println(genericinter.getData());
    }
}

泛型方法的使用

public class GenericMethod3
{
    // 泛型方法 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( "双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组

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

有界的类型参数

可以限制类型种类的范围

public class MaximumTest
{
    // 比较三个值并返回最大值
    public static <T extends Comparable<T>> T maximum(T x, T y, T z)
    {
        T max = x; // 假设x是初始最大值
        if ( y.compareTo( max ) > 0 ){
            max = y; //y 更大
        }
        if ( z.compareTo( max ) > 0 ){
            max = z; // 现在 z 更大
        }
        return max; // 返回最大对象
    }
    public static void main( String args[] )
    {
        System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
                3, 4, 5, maximum( 3, 4, 5 ) );

        System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
                6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );

        System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
                "apple", "orange", maximum( "pear", "apple", "orange" ) );
    }
}

输出结果：

3, 4 和 5 中最大的数为 5
6.6, 8.8 和 7.7 中最大的数为 8.8
pear, apple 和 orange 中最大的数为 pear

类型通配符

类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List,List 等所有List<具体类型实参>的父类。

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

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

public class GenericTest {

    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("icon");
        age.add(18);
        number.add(314);

        getData(name);
        getData(age);
        getData(number);
        System.out.println();
        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3

    }

    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 :icon
data :18
data :314

data :18
data :314