因为看书的时候对这部分知识没太看懂。网上查了一下才明白。书上讲的有点乱。还是喜欢c++ primer这种书= =感觉写的比较清楚。
8.5 泛型代码
类型擦除:虚拟机没有泛型对象,在定义一个泛型类型时,会自动提供其相对应的原始类型,即擦去类型变量,如果是限定的类型变量,则用第一个限定类型的代替,如果是无限定的类型变量,则用Object代替。
//Pair<T>的原始类型:
public class pair
{
private Object first;
private Object second;
public pair()
{first = null;second = null;}
public pair(Object first,Object second)
{this.first = first;this.second = second;}
public Object getFirst()
{return first;}
public Object getSecond()
{return second;}
public void setFirst(Object newinput)
{first = newinput;}
public void setSecond(Object newinput)
{second = newinput;}
}
//限定的泛型类的原始类型
public class Interval<T extends Comparable & Serializable> implements Serializable
{
private T lower;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
在调用泛型方法时,如果擦去了返回类型,则编译器会插入强制类型转换
Pair<Employee> buddies = ...;
Employee = buddies.getFirst();//getFirst()首先生成一个object类,再强制转换为Employee类
- 1
- 2
桥方法
泛型方法中也会发生类型消除
如
class DateInterval extends Pair<LocalDate>
{
public void setSecond(LocalDate second)
{
if(second.compareTo(getFirst()) >= 0)
super.setSecond(second);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
上面此段代码有个问题,DateInterval是Pair< LocalDate>的子类,其中有一个方法setSecond(),通常来说子类的方法需覆盖住超类的方法,然而由于类型消除,子类会从超类的原始类型中继承到另一个setSecond()
public void setSecond(LocalDate second)//child-class
public void setSecond(Object second)//继承
//当调用setSecond(aDate)时,多态性会出现问题
- 1
- 2
- 3
此时子类的方法不能覆盖住超类的方法,从而影响了多态性。解决方法便是编译器在子类中生成了一个桥方法,从而调用了子类中的setSecond
public void setSecond(Object second)
{setSecond((LocalDate) second);}
- 1
- 2
换一种情况来看
class DateInterval extends Pair<LocalDate>
{
public LocalDate getSecond()
{return (Date) super.getSecond().clone();}
}
- 1
- 2
- 3
- 4
- 5
此时编译器也会生成一个桥方法
public Object getSecond()
{...}
- 1
- 2
子类中便有两个不含参数且同名的方法了
这在编写上是不允许的,因为它们没有参数,只是返回类型不同,而在编译器中,是以参数类型和返回类型来确定一个方法,因此编译器可以参数两个仅返回类型不同的方法字节码,但是这样的编写是不能通过编译的。
8.6 约束
1.不能用基本类型实例化类型参数,即不能有Pair< double>,因为类型擦去后Pair的类型为Object,不能将double赋给它,只能有Pair< Double>
2.对于类型查询(instanceof),只产生原始类型。getClass()也是返回原始类型
if(a instanceof Pair<String>){...}//实际上只能查询a是否属于Pair
- 1
3.不能创建参数化类型的数组,即new Pair< String>[10]是不允许的,Pair< String>[] 不能初始化
只能使用ArrayList< Pair< String>>来搜集参数化类型
4.由于不能创建参数化类型的数组,所以在提供一系列参数化类型作为参数的方法中,调用用时会发出警告,可用@SafeVarags来消除创建泛型数组的有关限制
@SafeVarags
public static <T> void addAll(collection<T> coll,T...st)//一系列T对象会被写为数组
- 1
- 2
5.不能实例化类型变量,即new T(..)/new T[…]/T.class等
6.不能构造泛型数组,一般需要强制类型转换,即[T[]] new Object[size];
7.不能在静态域和静态方法中使用类型变量
8.7 继承
如果S为T的超类,Pair< S>和Pair< T>没有任何关系
8.8 通配符类型
通配符可以分为子类型限定通配符和超类型限定通配符
子类型限定通配符: ? extends Employee 不能向更改器方法传递特定的类型,但是可以让访问器方法返回特定类型
超类型限定通配符:? super Manager,不能像向改器传递Manager的超类,访问器方法只能返回Object类
泛型的规则限制
- 泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。
- 同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。
- 泛型的类型参数可以有多个。
- 泛型的参数类型可以使用extends语句,例如。习惯上称为“有界类型”。
- 泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(“java.lang.String”);
1、具体例子
下面给出两个简单的例子,实现同样的功能,一个使用了泛型,一个没有使用泛型。
例子一:使用了泛型
public class Gen<T> {
private T t;
public Gen(T t){
this.t = t;
}
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public void showType(){
System.out.println("T的实际类型是:" + t.getClass().getName());
}
public static void main(String[] args) {
Gen<Integer> gen = new Gen<Integer>(1);
gen.showType();
int i = gen.getT();
System.out.println(" value = " + i);
System.out.println(" ====================== ");
//定义泛型类Gen的一个String的版本
Gen<String>strObj = new Gen<String>("Hello Gen!");
strObj.showType();
String s = strObj.getT();
System.out.println(" value = " + s);
}
}
例子二:没有使用泛型
public class Gen2 {
// 定义一个通用类型成员
private Object obj;
public Gen2(Object obj) {
this.obj = obj;
}
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
public void showType() {
System.out.println("T的实际类型是: " + obj.getClass().getName());
}
public static void main(String[] args) {
// 定义类Gen2的一个Integer版本
Gen2 intObj = new Gen2(2);
intObj.showType();
int i = (Integer) intObj.getObj();
System.out.println(" value = " + i);
System.out.println(" ====================== ");
// 定义类Gen2的一个String版本
Gen2 strOb = new Gen2("Hello Gen!");
strOb.showType();
String s = (String) strOb.getObj();
System.out.println(" value= " + s);
}
}
2、深入泛型
在Java 5之前,为了让类有通用性,往往将参数类型、返回类型设置为Object类型,当获取这些返回类型来使用时候,必须将其“强制”转换为原有的类型或者接口,然后才可以调用对象上的方法。
泛型和使用“Object泛型”方式实现结果的完全一样,但是简单多了,因为不需要强制类型转换。
泛型类语法:
使用来声明一个类型持有者名称,然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。当然T仅仅是个名字,这个名字可以自行定义。
class GenericsFoo 声明了一个泛型类,这个T没有任何限制,实际上相当于Object类型,实际上相当于 class GenericsFoo。
与Object泛型类相比,使用泛型所定义的类在声明和构造实例的时候,可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。例如:
GenericsFoo<Double> douFoo=new GenericsFoo<Double>(new Double("33"));
当然,也可以在构造对象的时候不使用尖括号指定泛型类型的真实类型,但是你在使用该对象的时候,就需要强制转换了。比如:
GenericsFoo douFoo=new GenericsFoo(new Double("33"));
实际上,当构造对象时不指定类型信息的时候,默认会使用Object类型,这也是要强制转换的原因。
3、高级应用
限制泛型
在上面的例子中,由于没有限制class GenericsFoo类型持有者T的范围,实际上这里的限定类型相当于Object,这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做:
class GenericsFoo,这样类中的泛型T只能是Collection接口的实现类,传入非Collection接口编译会出错。
多接口限制
虽然Java泛型简单的用 extends 统一的表示了原有的 extends 和 implements 的概念,但仍要遵循应用的体系,Java 只能继承一个类,但可以实现多个接口,所以你的某个类型需要用 extends 限定,且有多种类型的时候,只能存在一个是类,并且类写在第一位,接口列在后面,也就是:
(泛型方法的类型限定)
<T extends SomeClass & interface1 & interface2 & interface3>
(泛型类中类型参数的限制)
public class Demo<T extends Comparable & Serializable> {
// T类型就可以用Comparable声明的方法和Seriablizable所拥有的特性了
}
通配符泛型
为了解决类型被限制死了不能动态根据实例来确定的缺点,引入了“通配符泛型”,针对上面的例子,使用通配泛型格式为<? extends Collection>,“?”代表未知类型,这个类型是实现Collection接口。
注意:
- 如果只指定了<?>,而没有extends,则默认是允许Object及其下的任何Java类了。也就是任意类。
- 通配符泛型不单可以向下限制,如<? extends Collection>,还可以向上限制,如<? super Double>,表示类型只能接受Double及其上层父类类型,如Number、Object类型的实例。
- 泛型类定义可以有多个泛型参数,中间用逗号隔开,还可以定义泛型接口,泛型方法。这些都与泛型类中泛型的使用规则类似。
4、泛型方法
是否拥有泛型方法,与其所在的类是否泛型没有关系。要定义泛型方法,只需将泛型参数列表置于返回值前。如:
public class GenericMethod {
public <T> void print(T x) {
System.out.println(x.getClass().getName());
}
public static void main(String[] args) {
GenericMethod method = new GenericMethod();
method.print(" ");
method.print(10);
method.print('a');
method.print(method);
}
}
需要注意的是,一个static方法,无法访问泛型类的类型参数,所以,若要static方法需要使用泛型能力,必须使其成为泛型方法。
泛型的好处如:
开始版本
public void write(Integer i, Integer[] ia); public void write(Double d, Double[] da);
泛型版本
public <T> void write(T t, T[] ta);
简便了代码
定义泛型
定义在类后面
紧跟类名后面
public class TestClassDefine<T, S extends T>{......}
定义泛型 T, S, 且S 继承 T
定义在方法装饰符后面
紧跟修饰符后面(public)
public <T, S extends T> T testGenericMethodDefine(T t, S s){......}
定义泛型 T, S, 且S 继承 T
实例化泛型
实例化定义在类上的泛型
第一声明类变量或者实例化时。例如
List<String> list;
list = new ArrayList<String>;
第二继承类或者实现接口时。例如
public class MyList<E> extends ArrayList<E> implements List<E> {...}
实例化定义方法上的泛型
当调用范型方法时,编译器自动对类型参数(泛型)进行赋值,当不能成功赋值时报编译错误。
通配符(?)
上面有泛型的定义和赋值;当在赋值的时候,上面一节说赋值的都是为具体类型,当赋值的类型不确定的时候,我们用通配符(?)代替了:
List<?> unknownList;
List<? extends Number> unknownNumberList;
List<? super Integer> unknownBaseLineIntgerList;