java[学习] 泛型

概念

泛型，即概念参数化类型，将类型由原来的具体的类型参数化，类似方法中的变量参数，此时类型也定义成参数形式（可以称为类型形参），然后再使用调用时传入具体的类型。

##实例##

先来看看Java自带的例子 List

public class Fxing { public static void main(String args[]){ List<String> list = new ArrayList<String>(); list.add("qqyumidi"); list.add("corn"); for (int i = 0; i < list.size(); i++) { String name = list.get(i); // 2 show("name:" + name); } } private static void show(Object object){ System.out.println(object); } }

上述列子中将lIst的泛型定义为String类型参数，也就是说，相应的List接口中肯定含有类型形参，且get()方法的返回结果也直接是此形参类型。具体看一下list源码

public interface List<E> extends Collection<E> { int size(); ....... E get(int index); /** * Replaces the element at the specified position in this list with the * specified element (optional operation). */ E set(int index, E element); /** * Inserts the specified element at the specified position in this list * (optional operation). Shifts the element currently at that position * (if any) and any subsequent elements to the right (adds one to their * indices). */ void add(int index, E element); /** * Removes the element at the specified position in this list (optional * operation). Shifts any subsequent elements to the left (subtracts one * from their indices). Returns the element that was removed from the * list. */ E remove(int index); ..... }

我们可以看到，在List接口中采用泛型化定义之后，中的E表示类型形参，可以接收具体的类型实参，并且此接口定义中，凡是出现E的地方均表示相同的接受自外部的类型实参。

我又写了一个例子

public class Fxing { public static void main(String args[]){ List list = new ArrayList(); list.add("qqyumidi"); list.add("corn"); list.add(100); for (int i = 0; i < list.size(); i++) { String name = "123"; if(list.get(i) instanceof String){ name = (String) list.get(i); // 2 }else if(list.get(i) instanceof Integer){ name = (list.get(i)).toString(); // 2 } show("name:" + name); } } private static void show(Object object){ System.out.println(object); } }

从代码中，可以看出，如果没有定义类型参数，也可以传其他参数，但是在输出的时候就要判断是什么类型，这样就比较麻烦了。

写了一个泛型类

package com.yangyi.javaplan.fxing; /** * Created by GYH on 2017/3/6. */ public class Box<T> { private T data; public Box(T data) { this.data = data; } public T getData() { return data; } public void setData(T data) { this.data = data; } }

调用

import java.util.ArrayList; import java.util.List; /** * Created by GYH on 2017/3/6. */ public class Fxing { public static void main(String args[]){ Box<String> stringBox = new Box<String>("guoyuehua"); show(stringBox.getClass()); Box<Integer> integerBox = new Box<Integer>(12); show(integerBox.getClass()); } private static void show(Object object){ System.out.println(object); } }

运行结果

class com.yangyi.javaplan.fxing.Box class com.yangyi.javaplan.fxing.Box true

从运行结果可以看出，虽然传入了不同的泛型实参类型，但是并没有真正意义上生成不同的类型，传入不同的类型实参，在内存上只有一个，即还是原来的最基本的类型，当然，逻辑上不同的泛型类型。

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

那么泛型中父子关系的类型吗

栗子

public class Fxing { public static void main(String args[]){ Box<Number> numberBox = new Box<Number>(99); Box<Integer> integerBox = new Box<Integer>(12); showData(numberBox); showData(integerBox); } private static void showData(Box<Number> box){ show("name: "+ box.getData()); } private static void show(Object object){ System.out.println(object); } }

栗子中Number 和 Integer是父子关系，但是编译时报错，…cannot be applied to …，错误，显然在逻辑上Box不能作为Box 的父类，如果非要用，是不是还要判断类型或者强制转换，这就和泛型提出的理论矛盾了，这个时候类型通配符就来了，类型通配符的使用：代替具体的类型实参（是实参、实参、实参 重要的事情说三遍）

栗子

public class Fxing { public static void main(String args[]){ Box<Number> numberBox = new Box<Number>(99); Box<Integer> integerBox = new Box<Integer>(12); showData(numberBox); showData(integerBox); } private static void showData(Box<?> box){ show("name: "+ box.getData()); } private static void show(Object object){ System.out.println(object); } }

还有在使用的时候还要遇到，限制通配符的上限和下限，比如我要限制传的参数必须是Number的子类等等，那么就需要加上限制。

public class Fxing { public static void main(String args[]){ Box<Number> numberBox = new Box<Number>(99); Box<Integer> integerBox = new Box<Integer>(12); showData(numberBox); showData(integerBox); } private static void showData(Box<? extends Number> box){ show("name: "+ box.getData()); } private static void show(Object object){ System.out.println(object); } }

上面定义的是上限，那么下限定义是：Box<? super Number> 形式

注意：并且还要注意的一点是，Java中没有所谓的泛型数组一说。