###Java泛型
泛型是很多语言都有得特性,泛型让代码更加的泛化,增加代码的通用性。但是java的泛型并不是1.0引入的,而是jdk5才引入的。为了向上兼容以前的老代码,java的泛型并不像C++,或别的语言的泛型那样强大,java的泛型是利用“擦除”实现的。**泛型的类型信息仅存在与编译期,编译器结束后,就找不到任何使用泛型的痕迹了。**其原理是
在大多数使用泛型的地方,编译器进行了类型检查和插入转型代码。
Java泛型虽没有像C++泛型那么强大,但是还是有它的用武之地的。
Java几乎所有的容器都用到了泛型,泛型能在利用编译器进行类型检查和强制转换。使程序运行其来更安全,代码看上去跟简洁,泛型性还能提高程序运行效率。
举个例子,现在有个容器类,该类可以容纳任意一种类型的对象。以下提供了泛型和非泛型2个版本。
非泛型利用的是用Object类型接受,然后再进行强制转化。但不仅有可能出现转化异常,而且还需要写些强制转化代码,而利用泛型则避免前者的缺点。其实编译完后2者的字节码是差不多的,原因java的泛型是利用擦除实现的。
class ObjectHolder{
private Object obj;
public void set(Object object){
this.obj = object;
}
public Object get(){
return obj;
}
}
public class GeneratorHolder<T> {
private T item;
public void set(T item){
this.item = item;
}
public T get(){
return item;
}
public static void main(String[] args){
ObjectHolder objholder = new ObjectHolder();
objholder.set(new String());
String str = (String) objholder.get();
//int i = (int) obj.get(); java.lang.ClassCastException:
GeneratorHolder<Integer> holder = new GeneratorHolder<Integer>();
holder.set(1);
int i = holder.get();
}
}
###泛型类型信息的声明
想类型信息,可以是用大写,字母,或小写字母来表示,<可以有多个元组>,
class Tuple<A,B,a,b,c>{
public void test(A a,B b){
}
}
###泛型方法
不一定要定义泛型类,可以定义泛型方法,只需将类型信息添加到方法定义的地方就行了。 表示泛型类型
public class GeneratorFunction {
public <T> T generator(T item){
return item;
}
}
###边界
边界,如果使用泛型没有设置其边界的,那么其默认边界就是Object(向上转型),由于java泛型的机制,那些边界为object的方法只能调用Object的方法,如果要想泛型做更多的事,就必须设置其边界。使其转为更具体的类型,从而表现更多的行为。
####上界
<? extends MyClass> 表示继承自myClass这个类的类型。
?号表示某种特定的类型通配符,这个我们后面介绍,这是指定上界常用一种方式,MyClass表示具体的类。下面我通过一个例子了解这个上边界的用法。
class Fruit{
private static int count=0;
public String toString(){
return this.getClass().getSimpleName() + " " +count++;
}
}
class Apple extends Fruit{
}
class Orange extends Fruit{
}
class Banana extends Fruit{
}
class Pear extends Fruit{
}
public class GeneratorBound{
public static void main(String[] args){
List<Fruit> list = new ArrayList<Fruit>();
List<? extends Fruit> list1 = list;
//list1.add(new Fruit()) //error
//list1.add(new Apple())// error
//list1.add(new Object())//error
Fruit f = list1.get(0);
}
}
这有个Apple,pear等类的父类是Fruit类,
我们实例化了一个Fruit类型的集合list,又声明了一个引用变量list1,这个集合的类型使用来上面的表达式,表示继承自Fruit的集合,并将其指向list。但是这里list1的add方法,却不能添加Fruit或Fruit的子类,按理来说向上转型,应该是可以添加的,这是为什么呢?原因是java的泛型是由"擦除实现",编译器在编译期就必须确定这个集合的类型,对于list1来说,由于并不知道Fruit的子类型到底有哪些,所以add方法只能添加null,那这样的类型有什么用呢,
Fruit f = list1.get(0);
list1适合用来取元素。因为向上转型是安全的。
###下界(逆变)
<? super MyClass> 也可以使用类型参数<? super T>,前者表示Myclass的超类,后者表示泛型参数超类。我们还是通过刚才那个例子来看看 ``` public class GeneratorBound{ public static void main(String[] args){ List list = new ArrayList(); List<? super Fruit> list1 = list; list1.add(new Fruit()); list1.add(new Apple()); //list1.add(new Object()); Type mismatch: cannot convert from capture#3-of ? super Fruit to Fruit // Fruit f = list1.get(0); } } ``` list1表示Fruit父类的集合,但是我们确发现list1可以添加Fruit的子类,但却不能添加Fruit的父类,这不是和我们上面的描述矛盾?,因为list1并不知道Fruit的父类有哪些,如果可以添加Fruit或Fruit的父类,将违反静态类型安全。而添加子类向上转型为Fruit,是安全的。和<? extends Fruit>是相反的。所以向集合添加元素可以使用<? super MyClass>,而使用则用 <? extends Fruit>更为方便。造成这些原因都是因为java的泛型是由”擦除“实现的。这也是java泛型不够强大的原因。 ###?(通配符) 表示某个特定类型的非原生类型,例如List表示持有任何类型的非原生List,而List<?>表示某种特定类型的非原生List,在很多情况下2者可以表现出相同的性质。public class GeneratorBound{
public static void main(String[] args){
List<Fruit> list = new ArrayList<Fruit>();
List<?> list2 = list;
//list2.add(new Object()); error 不知道是什么类型,所以即使是Object类型也无法添加进容器。
Object obj = list2.get(0);//取出来向上转型为Object类型
}
}
###注意的问题
不能实例化泛型对象和泛型数组,由于擦除的原因,编译器无法验证T类型的安全性。
public class GeneratorOption<T> {
public void test(Object arg){
//if(arg instanceof T){}
// T item = new T();
// T[] args = new T[];
}
}