泛型定义
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。
用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码的重用率。
泛型规则限制
1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型；
2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的；
3、泛型的类型参数可以有多个；
4、泛型的参数类型可以使用extends、super语句，例如。习惯上称为“有界类型“；
5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String");
示例对比
有这样一个需求：定义矩形对象，使矩形对象的宽度、高度既可以支持整形又可以支持字符串类型（例子可能不太恰当~~）。在不使用泛型的情况下，我们可能会定义两个类，一个类支持整形参数，另一个类支持字符串类型参数，如下：
类一：
package com.ips.volatiles.demo1;
public class RectangleInteger {
private Integer width;
private Integer height;
public RectangleInteger(Integer width, Integer height){
this.width = width;
this.height = height;
}
public Integer getWidth() {
return width;
}
public void setWidth(Integer width) {
this.width = width;
}
public Integer getHeight() {
return height;
}
public void setHeight(Integer height) {
this.height = height;
}
public void showDetails(){
System.out.println("the rectangle, width is " + this.width + " height is " + this.height);
}
public static void main(String [] args){
Integer width = 10;
Integer height = 5;
RectangleInteger rect = new RectangleInteger(width, height);
width = rect.getWidth();
height = rect.getHeight();
rect.showDetails();
}
}类二：
package com.ips.volatiles.demo1;
public class RectangleString {
private String width;
private String height;
public RectangleString(String width, String height){
this.width = width;
this.height = height;
}
public String getWidth() {
return width;
}
public void setWidth(String width) {
this.width = width;
}
public String getHeight() {
return height;
}
public void setHeight(String height) {
this.height = height;
}
public void showDetails(){
System.out.println("the rectangle, width is " + this.width + " height is " + this.height);
}
public static void main(String [] args){
String width = "20";
String height = "40";
RectangleString rect = new RectangleString(width, height);
width = rect.getWidth();
height = rect.getHeight();
rect.showDetails();
}
}类三（泛型方式定义）：
package com.ips.volatiles.demo1;
public class Rectangle<T> {
private T width;
private T height;
public Rectangle(T width, T height){
this.width = width;
this.height = height;
}
public T getWidth() {
return width;
}
public void setWidth(T width) {
this.width = width;
}
public T getHeight() {
return height;
}
public void setHeight(T height) {
this.height = height;
}
public void showDetails(){
System.out.println("the rectangle, width is " + this.width + " height is " + this.height);
}
public static void main(String [] args){
Integer width = 10;
Integer height = 5;
Rectangle<Integer> rect = new Rectangle<Integer>(width, height);
width = rect.getWidth();
height = rect.getHeight();
rect.showDetails();
String widthStr = "20";
String heightStr = "40";
Rectangle<String> rect1 = new Rectangle<String>(widthStr, heightStr);
widthStr = rect1.getWidth();
heightStr = rect1.getHeight();
rect1.showDetails();
}
}泛型类
单参数泛型类：
public class Rectangle<T> {
private T width;
private T height;
public Rectangle(T width, T height){
this.width = width;
this.height = height;
}
public T getWidth() {
return width;
}
public void setWidth(T width) {
this.width = width;
}
public T getHeight() {
return height;
}
public void setHeight(T height) {
this.height = height;
}
public static void main(String [] args){
Integer width = 10;
Integer height = 5;
Rectangle<Integer> rect = new Rectangle<Integer>(width, height);
String widthStr = "20";
String heightStr = "40";
Rectangle<String> rect1 = new Rectangle<String>(widthStr, heightStr);
}
}通过public class Rectangle<T> {}定义泛型类，在实例化该类时，必须指明泛型T的具体类型，例如：Rectangle<String> rectangle = new Rectangle<String>();，指明泛型T的类型为String。
多参数泛型类：
public class Container<K, V> {
private K key;
private V value;
public Container(K k, V v) {
key = k;
value = v;
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
public static void main(String[] args) {
Container<String, String> c1 = new Container<String, String>("name", "Messi");
Container<String, Integer> c2 = new Container<String, Integer>("age", 30);
Container<String, Double> c3 = new Container<String, Double>("height", 1.78);
System.out.println(c1.getKey() + " : " + c1.getValue());
System.out.println(c2.getKey() + " : " + c2.getValue());
System.out.println(c3.getKey() + " : " + c3.getValue());
}
}通过public class Container<K, V> {}定义泛型类，在实例化该类时，必须指明泛型K、V的具体类型，例如：Container<String, String> c1 = new Container<String, String>("name", "Messi");，指明泛型K的类型为String，泛型V的类型为String。
泛型接口
public interface Calculator<T> {
public T and(T a, T b);
}public class CalculatorInteger implements Calculator<Integer>{
public Integer and(Integer a, Integer b){
return a + b;
}
public static void main(String[] args) {
CalculatorInteger ci = new CalculatorInteger();
Integer val = ci.and(10, 20);
System.out.println(val);
}
}public class CalculatorString implements Calculator<String>{
public String and(String a, String b){
return a + b;
}
public static void main(String[] args) {
CalculatorString ci = new CalculatorString();
String val = ci.and("10", "20");
System.out.println(val);
}
}通过public interface Calculator<T> {}定义泛型接口，在实现该接口时，必须指明泛型T的具体类型，例如：public class CalculatorInteger implements Calculator<Integer>{}，指明泛型T的类型为Integer，实例化该类时无需制定泛型类型。
泛型方法
public class Generic {
public <T> T getObject(Class<T> c){
T t = null;
try {
t = c.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return t;
}
public static void main(String [] args){
try {
Generic generic = new Generic();
Object obj = generic.getObject(Class.forName("com.ips.volatiles.demo2.Generic"));
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}泛型方法说明： 
在调用泛型方法的时候，在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一个父类的最小级，直到Object。在指定泛型的时候，该方法中的几种类型必须是该泛型实例类型或者其子类。
在初始化泛型类的时候，不指定泛型的时候，泛型的类型为Object，就比如ArrayList中，如果不指定泛型，那么这个ArrayList中可以放任意类型的对象。
在java泛型中，？ 表示通配符，代表未知类型，< ? extends Object>表示上边界限定通配符，< ? super Object>表示下边界限定通配符。
通配符 与 T 的区别
T：作用于模板上，用于将数据类型进行参数化，不能用于实例化对象。
?：在实例化对象的时候，不确定泛型参数的具体类型时，可以使用通配符进行对象定义。
< T > 等同于 < T extends Object>
< ? > 等同于 < ? extends Object>例一：定义泛型类，将key，value的数据类型进行< K, V >参数化，而不可以使用通配符。
public class Container<K, V> {
private K key;
private V value;
public Container(K k, V v) {
key = k;
value = v;
}
}例二：实例化泛型对象，我们不能够确定eList存储的数据类型是Integer还是Long，因此我们使用List<? extends Number>定义变量的类型。
List<? extends Number> eList = null;
eList = new ArrayList<Integer>();
eList = new ArrayList<Long>();上界类型通配符（? extends）
List<? extends Number> eList = null;
eList = new ArrayList<Integer>();
Number numObject = eList.get(0); //语句1，正确
//Type mismatch: cannot convert from capture#3-of ? extends Number to Integer
Integer intObject = eList.get(0); //语句2，错误
//The method add(capture#3-of ? extends Number) in the type List<capture#3-of ? extends Number> is not applicable for the arguments (Integer)
eList.add(new Integer(1)); //语句3，错误语句1：List<? extends Number>eList存放Number及其子类的对象，语句1取出Number（或者Number子类）对象直接赋值给Number类型的变量是符合java规范的。
语句2：List<? extends Number>eList存放Number及其子类的对象，语句2取出Number（或者Number子类）对象直接赋值给Integer类型（Number子类）的变量是不符合java规范的。
语句3：List<? extends Number>eList不能够确定实例化对象的具体类型，因此无法add具体对象至列表中，可能的实例化对象如下。
eList = new ArrayList<Integer>();
eList = new ArrayList<Long>();
eList = new ArrayList<Float>();总结：上界类型通配符add方法受限，但可以获取列表中的各种类型的数据，并赋值给父类型（extends Number）的引用。因此如果你想从一个数据类型里获取数据，使用 ? extends 通配符。限定通配符总是包括自己。
下界类型通配符（? super ）
List<? super Integer> sList = null;
sList = new ArrayList<Number>();
//Type mismatch: cannot convert from capture#5-of ? super Integer to Number
Number numObj = sList.get(0); //语句1，错误
//Type mismatch: cannot convert from capture#6-of ? super Integer to Integer
Integer intObj = sList.get(0); //语句2，错误
sList.add(new Integer(1)); //语句3，正确语句1：List<? super Integer> 无法确定sList中存放的对象的具体类型，因此sList.get获取的值存在不确定性，子类对象的引用无法赋值给兄弟类的引用，父类对象的引用无法赋值给子类的引用，因此语句错误。
语句2：同语句1。
语句3：子类对象的引用可以赋值给父类对象的引用，因此语句正确。
总结：下界类型通配符get方法受限，但可以往列表中添加各种数据类型的对象。因此如果你想把对象写入一个数据结构里，使用 ? super 通配符。限定通配符总是包括自己。
总结
- 限定通配符总是包括自己
- 上界类型通配符：add方法受限
- 下界类型通配符：get方法受限
- 如果你想从一个数据类型里获取数据，使用 ? extends 通配符
- 如果你想把对象写入一个数据结构里，使用 ? super 通配符
- 如果你既想存，又想取，那就别用通配符
- 不能同时声明泛型通配符上界和下界
扫一扫
10万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
