Java泛型

2019-07-05 22:00:24 by冲冲

1. 泛型的引例

 1 List list = new ArrayList();

 2 list.add(1022);        //向集合中添加一个 Integer 类型的数据

 3 list.add("Yadiel");    //向集合中添加一个 String 类型的数据

 4

 5 //遍历list元素

 6 for(int i = 0 ; i < list.size() ; i++){

 7     Object obj = list.get(i);  //注意这里每个类型都是 Object

 8     System.out.println(obj);

 9 }

10

11 //如果遍历的时候就想得到自己想要的数据类型

12 for(int i = 0 ; i < list.size() ; i++){

13     String obj = (String) list.get(i);  //在取 Integer 的时候会报类型转换错误

14     System.out.println(obj);

15 }

报错信息：

意思是集合中第二个数据是 Integer，但是我们取出来的时候将其转换为 String 了，所以报错。

解决方案：

① 我们在遍历的时候，根据每个数据的类型判断，然后进行强转。缺陷是，如果数据成千上万，该方案不可取。

② 在往集合中加入数据的时候，就做好限制，比如这个集合只能添加 String 类型的，下一个集合只能添加 Integer 类型的（就像数组一样规定元素类型必须相同），那么在取数据时，由于前面已经限制了该集合的数据类型，那么就很好强转了。这第二种解决办法，也就是我们这篇文章讲的泛型。

2. 泛型的概念

泛型是Java SE1.5的新特性。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

3. 泛型的语法

（1）引例的解决

 1 List<String> list = new ArrayList<String>();

 2 //list.add(1022);  //向集合中添加一个 Integer 类型的数据时，编译器会报错

 3 list.add("Aoa");   //向集合中添加一个 String 类型的数据

 4 list.add("Loa");   //向集合中添加一个 String 类型的数据

 5

 6 //如果我们遍历的时候就想得到自己想要的数据类型

 7 for(int i = 0 ; i < list.size() ; i++){

 8     String obj = list.get(i);  //这里就不需要强转了，前面添加的是什么类型，这里获取的就是什么类型

 9     System.out.println(obj);

10 }

（2）泛型只在编译阶段有效

1 List<String> list1 = new ArrayList<String>();

2 List list2 = new ArrayList();

3 Class c1 = list1.getClass();

4 Class c2 = list2.getClass();

5 System.out.println(c1==c2); //true

由于反射是在运行时阶段，c1==c2为 true，说明编译之后的 class 文件中是不包含泛型信息。

结论：Java 泛型只在编译阶段有效，即在编译过程中，程序会正确的检验泛型结果。而编译成功后，class 文件是不包含任何泛型信息的。

（3）泛型类

在类名后面添加类型参数的声明部分，其他跟非泛型类完全一样。

泛型类的类型参数声明部分，可以包含一个或多个类型参数，参数间用逗号隔开。

 1 public class Box<T> {

 2   private T t;

 3   public void add(T t) {

 4     this.t = t;

 5   }

 6   public T get() {

 7     return t;

 8   }

 9

10   public static void main(String[] args) {

11     Box<Integer> integerBox = new Box<Integer>();

12     Box<String> stringBox = new Box<String>();

13

14     integerBox.add(new Integer(1022));

15     stringBox.add(new String("肥猪"));

16

17     System.out.println("整型值为 :"+ integerBox.get());

18     System.out.println("字符串为 :"+ stringBox.get());

19   }

20 }

输出结果：

1 整型值为 :1022

2 字符串为 :肥猪

（4）泛型方法

应用场景：假如需要写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？答案是泛型。

定义泛型方法的规则：

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

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

③ 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。

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

 1 public class GenericMethodTest {    //演示如何使用泛型方法打印不同字符串的元素

 2     // 泛型方法 printArray

 3     public static <E> void printArray(E[] inputArray) {

 4         // 输出数组元素

 5         for (E element : inputArray) {

 6             System.out.printf("%s ", element);

 7         }

 8         System.out.println();

 9     }

10

11     public static void main(String args[]) {

12         // 创建不同类型数组： Integer, Double 和 Character

13         Integer[] intArray = { 1, 2, 3, 4, 5 };

14         Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };

15         Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

16

17         System.out.println("整型数组元素为:");

18         printArray(intArray); // 传递一个整型数组

19

20         System.out.println("\n双精度型数组元素为:");

21         printArray(doubleArray); // 传递一个双精度型数组

22

23         System.out.println("\n字符型数组元素为:");

24         printArray(charArray); // 传递一个字符型数组

25     }

26 }

输出结果：

1 整型数组元素为:

2 1 2 3 4 5

3

4 双精度型数组元素为:

5 1.1 2.2 3.3 4.4

6

7 字符型数组元素为:

8 H E L L O

（5）类型通配符?

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

 1 import java.util.*;

 2

 3 public class GenericTest {

 4

 5     public static void main(String[] args) {

 6         List<String> name = new ArrayList<String>();

 7         List<Integer> age = new ArrayList<Integer>();

 8         List<Number> number = new ArrayList<Number>();

 9

10         name.add("yadiel");

11         age.add(18);

12         number.add(999);

13

14         getData(name);

15         getData(age);

16         getData(number);

17

18    }

19

20    public static void getData(List<?> data) {

21       System.out.println("data :" + data.get(0));

22    }

23 }

输出结果：

1 data :yadiel

2 data :18

3 data :999

② 类型通配符的上限和下限

上限：<? extends T> 表示该通配符所代表的类型是 T类型或者 T类型的子类。

下限：<? super T> 表示该通配符所代表的类型是 T类型或者 T类型的父类。

 1 import java.util.*;

 2

 3 public class GenericTest {

 4

 5     public static void main(String[] args) {

 6         List<String> name = new ArrayList<String>();

 7         List<Integer> age = new ArrayList<Integer>();

 8         List<Number> number = new ArrayList<Number>();

 9

10         name.add("yadiel");

11         age.add(18);

12         number.add(999);

13

14         //getUperNumber(name);//String类型表示Number类型的子类，报错

15         getUperNumber(age);   //输出18

16         getUperNumber(number);//输出999

17

18    }

19

20    public static void getUperNumber(List<? extends Number> data) {

21           System.out.println("data :" + data.get(0));

22        }

23 }

设计泛型方法，返回三个可比较对象的最大值。

 1 public class MaximumTest

 2 {

 3    // 比较三个值并返回最大值

 4    public static <T extends Comparable<T>> T maximum(T x, T y, T z)

 5    {

 6       T max = x; // 假设x是初始最大值

 7       if ( y.compareTo( max ) > 0 ){

 8          max = y; //y 更大

 9       }

10       if ( z.compareTo( max ) > 0 ){

11          max = z; // 现在 z 更大

12       }

13       return max; // 返回最大对象

14    }

15    public static void main( String args[] )

16    {

17       System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",

18                    3, 4, 5, maximum( 3, 4, 5 ) );

19

20       System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",

21                    6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );

22

23       System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",

24          "apple", "orange", maximum( "pear", "apple", "orange" ) );

25    }

26 }

输出结果：

1 3, 4 和 5 中最大的数为 5

2

3 6.6, 8.8 和 7.7 中最大的数为 8.8

4

5 pear, apple 和 orange 中最大的数为 pear

4. 注意事项

① 不能用基本类型来定义泛型，如 int、float。

1 List<int> list = new ArrayList<int>(); //不能用 int 这样的基本类型定义泛型

因为集合中只能存放引用类型的数据，即使你存入基本类型，Java还是会通过自动拆箱和自动装箱机制将其转换为引用类型。

② 如果使用？接收泛型对象时，则不能设置被泛型指定的内容。

1 List<?> list = new ArrayList<>();

2 list.add("aa");  //错误，无法设置

③ 泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。

④ 泛型类没有继承关系，即 String 为 Object 类的子类，则 List<String> 是 List<Object> 的子类这句话是错误的。

正确：List<String>==List<Object>。 原因：泛型只是规定了List的元素类型，如果不符合，会在编译阶段报错。在运行阶段，无论List的元素是什么类型，List的类型都属于List。

假设上面那句话是正确的，那么由于泛型的产生机制就是放什么类型的数据进去，取出来的就是什么类型，而不用进行类型转换。

这里把 String 类型的数据放入Object 类的泛型集合中，那么取出来的应该就是 String 类的数据，而实际上取出来的是 Object 类的数据，这与泛型的产生机制相违背，故不成立！

参考：

https://www.cnblogs.com/ysocean/p/6826525.html

https://www.runoob.com/java/java-generics.html

巴特西

【JavaSE】泛型

Java泛型

1. 泛型的引例

2. 泛型的概念

3. 泛型的语法

4. 注意事项

最新文章

热门文章