疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

泛型(Generic)学习总结


 

 
一、使用泛型的原因
 
1、提出问题:
 
public class Max {
 
public static void main(String[] args){
String str = "hello world";
Integer number = new Integer(2);
System.out.println(max(str, number));
}
public static Comparable max(Comparable o1, Comparable o2){
if(o1.compareTo(o2) > 0){
return o1;
}
else{
return o2;
}
}
}
 
String 类和 Integer类都实现了Comparable接口,在编译时是不会报错的,但是Integer和String是无法比较的,因此在运行时会抛出java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String。怎样才能在编译时就报错呢?
使用泛型可以指定类或方法一起工作的对象的类型,从而在编译时就找出不相容的对象(比如Integer和String不相容)。
改进代码如下:
 
public static <E extends Comparable<E>> E max(E o1, E o2){
if(o1.compareTo(o2) > 0){
return o1;
}
else{
return o2;
}
}
 
二、在类,方法,接口中使用泛型
1、类
 
public class GenericStack<T> {
private List<T> list = new ArrayList<T>();
public void push(T t){
list.add(t);
}
public T pop(){
int size = list.size();
if(size > 0){
return list.get(list.size() - 1);
}
return null;
}
}
为了定义个类为泛型类型,需要将泛型类型放在类名之后,例如:GenericStack<T>
 
2、方法
public class Max {
 
public static void main(String[] args) {
Integer[] numbers = { 4, 2, 6, 1, 2 };
Integer max = Max.<Integer>max(numbers);
System.out.println(max);
}
 
public static <E extends Comparable<E>> E max(E[] objects){
int length = objects.length;
if (length == 0) {
return null;
}
 
E max = objects[0];
for (int i = 1; i < length; i++) {
if (max.compareTo(objects[i]) < 0) {
max = objects[i];
}
}
return max;
}
}
为了定义一个方法为泛型类型,需要将泛型类型放在方法的返回类型之前。如
public static <E extends Comparable<E>> E max(E[] objects)
三、原始类型和通配泛型
1、问题:
 
定义一个泛型栈类型MyStack<T>,我们申明如下方法:
public static double max(MyStack<Number> myStack){
...
}
 
但是当我们如下调用时:
MyStack<Integer> myStack = new MyStack<Integer>();
myStack.push(12);
myStack.push(11);
System.out.println("The max is " + max(myStack));
却会报错,那是因为:Number是Integer的父类,但是MyStack<Number> 不是MyStack<Integer> 的父类,因而MyStack<Number>无法引用MyStack<Integer>。
 
改进:将方法中的变量MyStack<Number> 改为MyStack<? extends Number> 则可以通配 MyStack<Integer> 、MyStack<Double> ...各种类型。
 
2、通配泛型的类型有三种:?, ? extends T 或者 ? super T, 其中T是个泛型。
?称为非受限的通配,和? extends Objects一样。
? extends T 称为受限通配,表示T或者T的一个子类型,例子如上
? super T 称为下限通配,表示T或者T的一个父类型,例子如下
 
/*
* 将stack2中的值放到stack1中
* stack1要容纳stack2中的值,那么stack1中值得类型必须是stack2中的类型或是它的父类
*/
public static <T> void add(MyStack<? super T> stack1, MyStack<T> stack2){
while(!stack2.isEmpty()){
stack1.push(stack2.pop());
}
}
 
3、原始类型
 
MyStack<Integer> myStack = new Mystack<Integer>(); 这是使用泛型类同时指定具体类型为Integer
 
MyStack stack = new MyStack(); 这是使用泛型类但是没有指定具体类型,像这样不指定具体类型的泛型类称为原始类型,等价于 MyStack<Object> myStack = new MyStack<Object>();
 
四、泛型的运作原理
 
泛型只能存在于编译时,它存在的意义只是让编译器确认是否可以安全使用,一旦确定,编译器就会把它转为原始类型。举例如下:
 
1、泛型类型不受限
 
ArrayList<String> list = new ArrayList<String>();
list.add("hello");
当编译器确认字符串hello是符合要求的String类型,就会把这段代码变为:
ArrayList list = new ArrayList();
list.add("hello");
 
2、泛型类型受限
 
public static <E extends Number> E max(E o1, E o2)
E是Number的子类的泛型类型
 
编译器编译后,是
 
public static Number max(Number o1, Number o2)
 
 
3、总结:
a、当泛型类型不受限时,编译器编译时,会用Object类型来具体泛型类型
 
b、当泛型类型受限时,那么编译器会用一个受限的类型来替换它
 
c、不管实际的类型是什么,泛型类都是被所有的实例共享的。例如,ArrayList<Integer> list1 和 ArrayList<String> list2 的泛型类都是ArrayList,因此list1 instanceof ArrayList 和list2 instanceof ArrayList都是true;
 
d、泛型类型只存在于编译时,不存在运行时。
 
e、不能使用 new E();即 E object = new E();是错误的
 
f、不能使用 new E[]来申明数组
 
g、静态方法的参数不能有泛型,静态数据域也不能有泛型
 
h、异常类不能是泛型,即泛型类不能继承java.lang.Throwable