泛型的个人理解

泛型：参数化的类。将实体类参数化，传递给方法进行使用。

这类参数称之为类型实参，由这些类型实参来限定比如集合的类型

List<String> String为类型实参 ，List为集合

泛型在逻辑上可以看成是多个不同的类型，但是实际上都是相同的基本类型

需要注意的是，Java之中并没有所谓的泛型数组

大体上泛型的使用有三种：
1.List<String> 限定集合的类型
2.Collection<T> 定义泛型接口
3.Collection<?> 类型通配符

部分代码实现参看如下代码块儿：

public class TestGenericity {

public static void main(String[] args) {

//      CastObjectToString();
//      Box<String> name = new Box<String>("corn");
//      System.out.println("name:"+ name.getData());

/*判断Box<Number>和Box<Integer>是否可以看成具有父子关系的泛型类型*/
Box<Number> name = new Box<Number>(99);
Box<Integer> age = new Box<Integer>(712);
getData(name);
//      通过提示信息，我们知道Box<Number>在逻辑上不能视为Box<Integer>的父类
//      getData(age);
}

/**
* @Title: CastObjectToString
* @Description: TODO
* @return: void
*/
public static void CastObjectToString() {
List<Object> list = new ArrayList<>();
list.add("asdfas");
list.add("adsfadsf");
list.add(100);
//      由于list集合中不止有String类型的数据，还有Integer类型的数据
//      所以想要强制类型装换成String类型是不成功的

for (int i = 0; i < list.size(); i++) {
/*
* 1.集合不会记住对象的类型，当对象被放进集合，再次取出来的时候，都会被编译成Object
* 类型的对象，但是在进行运行的时候却还是以原有类型进行运行，
*
* 2.此时进行强制类型转换就会容易发生错误
*
* 3.使用泛型可以解决这个问题
*/
String name = (String) list.get(i);
System.out.println("name:" + name);
}
}

public static void CastObjectToStringdIndex(){
List<String> list = new ArrayList<>();
list.add("sadfasdf");
list.add("sdsa");
//      使用泛型将list集合的类型指定String类型，此时再想list
//      集合中加入Integer类型的对象，则会报错
//      list.add(100);

for (int i = 0; i < list.size(); i++) {
String name = list.get(i);
System.out.println("name:" + name);
}

/*
* 采用泛型写法之后，想list集合中添加Integer类型的对象就会出现
* 编译错误，无法编译通过。
*
* 通过List<String> 直接限定了list集合中只能含有String类型的元素
*/
}

public static void getData(Box<Number> data){
System.out.println("name："+ data.getData());
}
}

/*创建一个不指定泛型的内部类  Box*/
class Box<T>{
private T data;
public Box(){}
public Box(T data){
this.data = data;
}
public T getData(){
return data;
}
}

备注：其中类型通配符有两种特殊情况类型通配符上限和类型通配符下限

在上面的例子中，如果需要定义一个功能类似于getData()的方法，但对类型实参又有进一步的限制：只能是Number类及其子类。此时，需要用到类型通配符上限

如果需要一个功能与getData()方法类似的，但是对传递进去的类型实参由进一步的限制，只能是某个类及其子类，那么就需要用到通配符上限

参考代码如下：

public class GenericTest {

public static void main(String[] args) {

Box<String> name = new Box<String>("corn");
Box<Integer> age = new Box<Integer>(712);
Box<Number> number = new Box<Number>(314);

getData(name);
getData(age);
getData(number);

//getUpperNumberData(name); // 1
getUpperNumberData(age);    // 2
getUpperNumberData(number); // 3
}

public static void getData(Box<?> data) {
System.out.println("data :" + data.getData());
}

public static void getUpperNumberData(Box<? extends Number> data){
System.out.println("data :" + data.getData());
}

}

类型通配符下限 就是传递进去的类型实参是继承自上限类型的实参，那么就称之为类型通配符下限

类型通配符上限通过形如
Box<? extends Number>形式定义，相对应的，类型通配符下限为Box<? super Number>形式，其含义与类型通配符上限正好相反
（来自：http://www.cnblogs.com/lwbqqyumidi/p/3837629.html）