一、基本概念
java泛型出现原因：为了解决类型转换的问题。就是说所操作的数据类型被指定为一个参数，在用到的时再指定为具体类型。
泛型可以用在：类、接口、方法中。（泛型类，泛型接口，泛型方法）
简单概念：
整个成为ArrayList<E>泛型类型
ArrayList<E>中的 E称为类型变量或者类型参数
整个ArrayList<Integer> 称为参数化的类型
二、泛型的使用
泛型类的简单使用：
public class FX<T> {
private T ob;//申明一个范型的object
public FX(T demoOb){//这里指明了T的类型
this.ob = demoOb;
}
public T getOb(){//看T是什么类型，返回的就是什么类型
return ob;
}
public void showType(){
System.out.println("T的实际类型是："+ob.getClass());
}
public static void main(String[] args){
FX<Integer> intOb = new FX<Integer>(100);
intOb.showType();
System.out.println("value ="+intOb.getOb());
System.out.println("----------------");
FX<String> strOb = new FX<String>("String_test");
strOb.showType();
System.out.println("value ="+strOb.getOb());
}
}public class FXInter {
interface Show<T,U>{
void show(T t,U u);
}
class ShowTest implements Show<String, Integer>{
@Override
public void show(String str, Integer num) {
// TODO Auto-generated method stub
System.out.println("str ="+str);
System.out.println("num ="+num);
}
}
public static void main(String[] args){
ShowTest showTest = new ShowTest();
showTest.show("this is String", 12345);
}
} 泛型方法简单应用：
package com.fx.test;
public class FXWay {
public static void main(String[] args) throws ClassNotFoundException{
String str = get("Hello","World");
System.out.println(str);
}
public static <T,U> T get(T t, U u){
if(u != null){
return t;
}else{
return null;
}
}
} 二、泛型变量的类型限定
有的时候，类、接口或方法需要对类型变量加以约束。
1:界定通配符的上边界
Vector<? extends 类型1> x = new Vector<类型2>();
类型1指定一个数据类型，那么类型2就只能是类型1或者是类型1的子类
Vector<? extends Number> x = new Vector<Integer>();//这是正确的
Vector<? extends Number> x = new Vector<String>();//这是错误的
2:界定通配符的下边界
Vector<? super 类型1> x = new Vector<类型2>();
类型1指定一个数据类型，那么类型2就只能是类型1或者是类型1的父类
Vector<? super Integer> x = new Vector<Number>();//这是正确的
Vector<? super Integer> x = new Vector<Byte>();//这是错误的
提示：限定通配符总是包括自己
二、泛型实现的原理
一、Java泛型的实现方法：类型擦除
Java的泛型是伪泛型。为什么说Java的泛型是伪泛型呢？因为，在编译期间，所有的泛型信息都会被擦除掉。
Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。
如在代码中定义的List<object>和List<String>等类型，在编译后都会编程List。JVM看到的只是List，而由泛型附加的类型信息对JVM来说是不可见的。
看一个例子来证明java泛型的类型擦除：
public class Test4 {
public static void main(String[] args) {
ArrayList<String> arrayList1=new ArrayList<String>();
arrayList1.add("abc");
ArrayList<Integer> arrayList2=new ArrayList<Integer>();
arrayList2.add(123);
System.out.println(arrayList1.getClass()==arrayList2.getClass());
}
}二、类型擦除后保留的原始类型
什么是原始类型？原始类型（raw type）就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型。无论何时定义一个泛型类型，相应的原始类型都会被自动地提供。类型变量被擦除（crased），并使用其限定类型（无限定的变量用Object）替换。
例题：
class Pair<T> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}class Pair {
private Object value;
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
}如果类型变量有限定，那么原始类型就用第一个边界的类型变量来替换。
public class Pair<T extends Comparable& Serializable> { 要区分原始类型和泛型变量的类型
在调用泛型方法的时候，可以指定泛型，也可以不指定泛型。
在不指定泛型的情况下，泛型变量的类型为 该方法中的几种类型的同一个父类的最小级，直到Object。
在指定泛型的时候，该方法中的几种类型必须是该泛型实例类型或者其子类。
public class Test2{
public static void main(String[] args) {
/**不指定泛型的时候*/
int i=Test2.add(1, 2); //这两个参数都是Integer，所以T为Integer类型
Number f=Test2.add(1, 1.2);//这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Number
Object o=Test2.add(1, "asd");//这两个参数一个是Integer，另一个是String，所以取同一父类的最小级，为Object
/**指定泛型的时候*/
int a=Test2.<Integer>add(1, 2);//指定了Integer，所以只能为Integer类型或者其子类
int b=Test2.<Integer>add(1, 2.2);//编译错误，指定了Integer，不能为Float
Number c=Test2.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float
}
//这是一个简单的泛型方法
public static <T> T add(T x,T y){
return y;
}
} 三、类型擦除引起的问题及解决方法
ArrayList<String> arrayList1=new ArrayList<Object>();//编译错误
ArrayList<Object> arrayList1=new ArrayList<String>();//编译错误 ArrayList<Object> arrayList1=new ArrayList<Object>();
arrayList1.add(new Object());
arrayList1.add(new Object());
ArrayList<String> arrayList2=arrayList1;//编译错误 ArrayList<String> arrayList1=new ArrayList<String>();
arrayList1.add(new String());
arrayList1.add(new String());
ArrayList<Object> arrayList2=arrayList1;//编译错误 获取的时候如何从 原型--------->目标类型
因为类型擦除的问题，所以所有的泛型类型变量最后都会被替换为原始类型。这样就引起了一个问题，既然都被替换为原始类型，那么为什么我们在获取的时候，不需要进行强制类型转换呢？看下ArrayList和get方法：
public E get(int index) {
RangeCheck(index);
return (E) elementData[index];
}
看一个接口泛型 具体例子：
class Pair<T> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
} class DateInter extends Pair<Date> {
@Override
public void setValue(Date value) {
super.setValue(value);
}
@Override
public Date getValue() {
return super.getValue();
}
}那么在 DateInter类中 setValue 和 getValue 是被重载还是重写了呢？
答案：是被重写了。
验证：
public static void main(String[] args) throws ClassNotFoundException {
DateInter dateInter=new DateInter();
dateInter.setValue(new Date());
dateInter.setValue(new Object());//编译错误
} 可是由于种种原因，虚拟机并不能将泛型类型变为Date，只能将类型擦除掉，变为原始类型Object。这样，我们的本意是进行重写，实现多态。可是类型擦除后，只能变为了重载。这样，类型擦除就和多态有了冲突。JVM知道你的本意吗？知道！！！可是它能直接实现吗，不能！！！如果真的不能的话，那我们怎么去重写我们想要的Date类型参数的方法啊。
于是JVM采用了一个特殊的方法，来完成这项功能，那就是桥方法。
首先，我们用javap -c className的方式反编译下DateInter子类的字节码，结果如下：
class com.tao.test.DateInter extends com.tao.test.Pair<java.util.Date> {
com.tao.test.DateInter();
Code:
0: aload_0
1: invokespecial #8 // Method com/tao/test/Pair."<init>"
:()V
4: return
public void setValue(java.util.Date); //我们重写的setValue方法
Code:
0: aload_0
1: aload_1
2: invokespecial #16 // Method com/tao/test/Pair.setValue
:(Ljava/lang/Object;)V
5: return
public java.util.Date getValue(); //我们重写的getValue方法
Code:
0: aload_0
1: invokespecial #23 // Method com/tao/test/Pair.getValue
:()Ljava/lang/Object;
4: checkcast #26 // class java/util/Date
7: areturn
public java.lang.Object getValue(); //编译时由编译器生成的巧方法
Code:
0: aload_0
1: invokevirtual #28 // Method getValue:()Ljava/util/Date 去调用我们重写的getValue方法
;
4: areturn
public void setValue(java.lang.Object); //编译时由编译器生成的巧方法
Code:
0: aload_0
1: aload_1
2: checkcast #26 // class java/util/Date
5: invokevirtual #30 // Method setValue:(Ljava/util/Date; 去调用我们重写的setValue方法
)V
8: return
}
而桥方法的内部实现，就只是去调用我们自己重写的那两个方法。
所以，虚拟机巧妙的使用了桥方法，来解决了类型擦除和多态的冲突。
4、泛型类型变量不能是基本数据类型
5、运行时类型查询
ArrayList<String> arrayList=new ArrayList<String>();因为类型擦除之后，ArrayList<String>只剩下原始类型，泛型信息String不存在了。
if( arrayList instanceof ArrayList<String>) if( arrayList instanceof ArrayList<?>) 6、异常中使用泛型的问题
public static<T extends Throwable> void doWork(T t) throws T{
try{
...
}catch(Throwable realCause){
t.initCause(realCause);
throw t;
} 10、泛型在静态方法和静态类中的问题
泛型类中 的静态方法和静态变量 不可以使用 泛型类所声明的泛型类型参数
public class Test2<T> {
public static T one; //编译错误
public static T show(T one){ //编译错误
return null;
}
} public class Test2<T> {
public static <T> T show(T one){//这是正确的
return null;
}
}
4、泛型类型变量不能是基本数据类型
http://blog.csdn.net/hgd613/article/details/12656073
http://blog.csdn.net/hgd613/article/details/12656073
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
