/**
 * 文件名：GenericMethodDemo.java
 * 功能描述：泛型方法测试Demo
 */
public class GenericMethodDemo {

    //定义一个泛型方法 printArray
    public static <T> void printArray(T[] inputArray) {//必须先声明一个类型变量：<T>
        //输出数组元素
        for(T 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);

    }
}

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

Java第十二周作业_类型参数

有界的类型参数：

可能有时候，你会想限制那些被允许传递到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接受Number或者Number子类的实例。这就是有界类型参数的目的。

要声明一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界，如下面就是定义了一个继承于Comparable接口的泛类型 T：

<T extends Comparable<T>>

实例2

下面的例子演示了"extends"如何使用在一般意义上的意思"extends"（类）或者"implements"（接口）。该例子中的泛型方法返回三个可比较对象的最大值。

import java.text.Collator;

/**
 * 文件名：MaximumTest.java
 * 功能描述：有界的类型参数泛型测试例子
 * 使用说明：要申明是一个有界的类型参数，首先列出类型参数的名称，后跟extends关键字，最后紧跟它的上界
 */
public class MaximumTest {
    public static <T extends Comparable<T>> T maximum(T x,T y,T z) {
        T max = x;
        if (max instanceof String) {
            //Collator类可以使用本地化的语言规则比较字符串的大小
            Collator collator = Collator.getInstance();
            if (collator.compare(y, max) > 0)
                max = y;
            if (collator.compare(z, max) > 0)
                max = z;
        } else {
            if (y.compareTo(max)>0)
                max = y;
            if (z.compareTo(max)>0)
                max = 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",3.3,7.4,6.5,maximum(3.3,7.4,6.5));

        System.out.printf("%s, %s 和 %s 中最大的数为 %s\n\n","one","two","three",maximum("one","two","three"));

        System.out.printf("%s, %s 和 %s 中最大的数为 %s\n\n","李四","张三","王小",maximum("李四","张三","王二"));

    }
}

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

Java第十二周作业_java_02

二、泛型类

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

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

实例3

如下实例演示了我们如何定义一个泛型类：

/**
 * 文件名：Box.java
 * 功能描述：泛型类的定义
 */
public class Box<T> {
    private T t;

    public T getT() {
        return t;
    }

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

测试用例：

/**
 * 文件名：GenericClassTest.java
 * 功能描述：泛型类的测试
 */
public class GenericClassTest {
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        Box<Double> doubleBox = new Box<Double>();
        Box<String> stringBox = new Box<String>();

        integerBox.setT(10);
        doubleBox.setT(12.56);
        stringBox.setT("小宇飞刀");

        System.out.printf("整型值为：%d\n\n",integerBox.getT());
        System.out.printf("浮点型值为：%.2f\n\n",doubleBox.getT());
        System.out.printf("字符串为：%s\n\n",stringBox.getT());
    }
}

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

Java第十二周作业_java_03

三、类型通配符

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

实例4

import java.lang.reflect.Array;
import java.util.*;

/**
 * 文件名：GenericTest.java
 * 功能描述：类型通配符的使用Demo
 */
public class GenericTest {
    //此方法未使用类型限制
    public static void printData(List<?> data) {
        //System.out.println("data : "+data.get(0));

        Iterator<?> iterator= data.iterator();
        while(iterator.hasNext()) {
            System.out.println("data :"+iterator.next());
        }
    }

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

        name.add("小宇飞刀");
        age.add(29);
        height.add(170f);

        name.add("张三丰");
        age.add(18);
        height.add(180.0);

        printData(name);
        printData(age);
        printData(height);

    }
}

输出结果为：

Java第十二周作业_泛型方法_04

解析： 因为printData()方法的参数是List类型的，所以name，age，height都可以作为这个方法的实参，这就是通配符的作用。

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

实例5

import java.lang.reflect.Array;
import java.util.*;

/**
 * 文件名：GenericTest.java
 * 功能描述：类型通配符的使用Demo
 */
public class GenericTest {
    //此方法未使用类型限制
    public static void printData(List<?> data) {
        //System.out.println("data : "+data.get(0));

        Iterator<?> iterator= data.iterator();
        while(iterator.hasNext()) {
            System.out.println("data :"+iterator.next());
        }
    }
    //此方法使用了类型限制：extends Number
    public static void printNumber(List<? extends Number> data) {
        //System.out.println("data :" + data.get(0));

        Iterator<?> iterator = data.iterator();
        while (iterator.hasNext()) {
            System.out.println("data :" + iterator.next());
        }
    }

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

        name.add("小宇飞刀");
        age.add(29);
        height.add(170f);

        name.add("张三丰");
        age.add(18);
        height.add(180.0);

        //printNumber(name); //此语句无法编译，因为printNumber()方法中的参数已经限定了参数泛型上限为Number
        printData(age);
        printNumber(height);
    }
}