为什么使用泛型
泛型就是“参数化类型”，就是把类型当作参数传递
对于为什么要使用泛型，我们先来举几个栗子
🌰1:
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
上面两个方法的方法体实现都是一样的，但是因为参数的类型和返回值的类型不同就需要定义两个方法。
🌰2:
public class MainActivity extends AppCompatActivity{
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
initViews();
initData();
}
}
public class TestActivity extends AppCompatActivity{
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
initViews();
initData();
}
}
上面两个activity类中实现的方法是一样的，但是由于属于不同的页面导致我们要实现多个重复的代码。
🌰3:
List list = new ArrayList();
list.add(1);
list.add("a");
System.out.println((String)list.get(0) + (String)list.get(1));
报错：
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
在编译过程中，List中的类型应该是Object，强制类型转换就有可能出错。
泛型的好处：
1、多种数据类型执行相同的代码
2、实例化时指定类型，不需要强制类型转换
泛型类、泛型接口、泛型方法
泛型类：
public class T1<T>{}
泛型接口：
public interface T2<T>{}
泛型方法：
// 1. 普通泛型方法
// 1.1 方法调用时指定类型
public <T> T test1(T t){
return t;
}
// 1.2 类初始化时指定类型
public class T1<T>{
public T test1(T t){
return t;
}
}
// 2. 静态泛型方法
public class T2<T>{
// 此处的T和T2后面的T没有任何关系，
// T2中的T需要在初始化时指定类型，
// 此处的静态方法是在方法调用时指定的
public static <T> T test(T t){
return t;
}
}
限定类型变量
有的时候，我们需要对类型变量（泛型）进行约束，比如取两个变量的最小值
public <T> T min(T a, T b) {
if (a.compareTo(b) > 0) return b;
else return a;
}
如何保证传入的T有compareTo方法呢？
public <T extends Comparable> T min(T a, T b) {
if (a.compareTo(b) > 0) return b;
else return a;
}
T extends Comparable & Serializable 泛型可以支持多个接口，如果限定类型有类，这个类必须是在限定列表的第一个。
泛型中的约束和局限性
-
不能实例化基本数据类型的泛型
// Test<double> t = new Test<double>();// 不允许这种写法 Test<Double> t = new Test<Double>(); -
不能实例化类型变量
// T t = new T(); -
运行时类型查询，只能适用于原始类型
Test<Double> t = new Test<>(); //if(t instanceof Test<Double>) //不允许 //if(t instanceof Test<T>) //不允许 t.getClass(); -
泛型类静态上下文中类型变量失效
class Test<T> { //此处的T和Test<T>不是同一个 public static <T> T getInstance(){ ... } } -
不能创建参数化类型的数组
// Test<Double> ts = new Test<Double>[]; //不允许 -
不能捕获泛型类型的实例
// class MyException<T> extends Exception //编译器报错 // class MyThrowable<T> extends Throwable //编译器报错 //public <T extends Throwable> void test(){ // try { // // }catch (T e){//此处T报错 // // } //} public <T extends Throwable> void test(){ try { }catch (Throwable e){//可以这么写 } }
通配符类型
-
? extends X
表示类型的上界，类型参数是X的子类
-
? super X
表示类型的下界，类型参数是X的超类
无限定的通配符
Pair<?>。初看起来，这好像与原始的 Pair 类型一样。 实际上， 有很大的不同。类型 Pair<?> 有以下方法:
? getFi rst()
void setFirst(?)
getFirst 的返回值只能赋给一个 Object ，setFirst 方法不能被调用， 甚至不能用 Object 调用。Pair<?> 和 Pair 本质的不同在于: 可以用任意 Object 对象调用原始 Pair 类的 setObject；
为什么要使用这么脆弱的类型？
它对于许多简单的操作非常有用。 例如， 下面这个方法 将用来测试一个 pair 是否包含一个 null 引用， 它不需要实际的类型。
public static boolean hasNulls(Pair<?> p){
return p.getFirstO = null || p.getSecondO = null;
}
也可以使用：
public static <T> boolean hasNulls(Pair<T> p)
但带有通配符可读性更强一些。
虚拟机中是如何实现泛型的？
在Java语言处于还没有出现泛型的版本时，只能通过Object是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。由于Java语言里面所有的类型都继承于java.lang.Object，所以Object转型成任何对象都是有可能的。但是也因为有无限的可能性，就只有程序员和运行期的虚拟机才知道这个Object到底是个什么类型的对象。在编译期间，编译器无法检查这个Object的强制转型是否成功，如果仅仅依赖程序员去保障这项操作的正确性，许多ClassCastException的风险就会转嫁到程序运行期之中。
C#中的泛型和Java中的泛型有什么区别？
C#在编译成中间语言时List<int>和List<String>是两种不同的类型，而在Java中，泛型只是一种语法糖，编译成class文件后泛型就会被擦除，变成List<Object>。
