java泛型学习笔记

本文为从网上东拼西凑的java泛型学习笔记,摘出了我认为有价值的部分,尚未整理,先放在这里备份。


http://docs.oracle.com/javase/1.5.0/docs/guide/language/generics.html
泛型在类、接口和方法中定义,在实现(extends,implements)和实例化时使用。


定义类或接口时,使用"<E extends Fruit>"这种形式,之后就可以在类中对E进行操作。
定义方法所接收的参数时,使用"List<? extends Fruit>"这种形式,就可以接收这个范围的List做参数。
实例化时,不能使用问号这种形式来指定泛型——不能new List<? extends Apple>();
继承或实现时,也不能使用问号这种形式来指定泛型——不能public interface MyList extends List<? extends Apple>


关于extends和super关键字的PECS(producer-extends, consumer-super)原则:
如果参数化类型表示一个T生产者,就使用<? extends T>,因为它只能get,用于将数据从生产者取出(只要生产者可以生产T的子类,那就一定可以生产T);
如果参数化类型表示一个T消费者,就使用<? super T>,因为它只能add,用于将数据add入消费者(只要消费者可以消费T的超类,那就一定可以消费T)。



http://www.infoq.com/cn/articles/cf-java-generics
泛型的继承原则:
1,相同类型参数的泛型类的关系取决于泛型类自身的继承体系结构。即List<String>是Collection<String> 的子类型,List<String>可以替换Collection<String>。这种情况也适用于带有上下界的类型声明。
2,当泛型类的类型声明中使用了通配符的时候, 其子类型可以在两个维度上分别展开。如对Collection<? extends Number>来说,其子类型可以在Collection这个维度上展开,即List<? extends Number>和Set<? extends Number>等;也可以在Number这个层次上展开,即Collection<Double>和 Collection<Integer>等。如此循环下去,ArrayList<Long>和 HashSet<Double>等也都算是Collection<? extends Number>的子类型。
3,如果泛型类中包含多个类型参数,则对于每个类型参数分别应用上面的规则。


泛型的定义原则:
1,泛型类与一般的Java类基本相同,只是在类和接口定义上多出来了用<>声明的类型参数。
2,一个类可以有多个类型参数,如 MyClass<X, Y, Z>。
3,每个类型参数在声明的时候可以指定上界。
4,所声明的类型参数在Java类中可以像一般的类型一样作为方法的参数和返回值,或是作为域和局部变量的类型。
5,由于类型擦除机制,类型参数并不能用来创建对象或是作为静态变量的类型。

http://www.ibm.com/developerworks/cn/java/j-jtp01255.html
如果没有向后兼容性顾虑,那么Collection框架会这么设计(而实际上不是):
interface Collection<E> { 
  public T[] toArray(Class<T super E> elementClass); 
 }
这样很通用,假设E是Apple类,那么传入任何一个Apple的父类(例如Fruit)都合法,会返回Fruit数组。
如果传入Object,那就相当于现在Collection接口的Object[] toArray()方法了。


同样,如果没有向后兼容性顾虑,那么Collection框架的remove和removeAll会这么写(而实际上不是):
interface Collection<E> { 
  public boolean remove(E e);  // not really 
  public void removeAll(Collection<? extends E> c);  // not really 
 } 
缺陷是:只能传入当前泛型的兼容类型,不能传入任意Object或Collection<Object>——这样无法到兼容之前的API定义。


不能创建泛型类型的对象,因为编译器不知道要调用什么构造函数。如果泛型类需要构造用泛型类型参数来指定类型的对象,那么构造函数应该接受类文字(Foo.class)并将它们保存起来,以便通过反射创建实例(类似于上述Collection的toArray方法)

http://www.cnblogs.com/stephen-liu74/archive/2012/01/20/2228938.html
类型安全的异构容器(内部用Map<Class<?>,Object>来实现):
public class Favorites {
     public <T> void putFavorite(Class<T> type,T instance);
     public <T> T getFavorite(Class<T> type);
}
例如用于数据库不定数目的columns:每个cell的数据都以这种方式指定类型保存Favorites到容器中,再将此容器当作元素保存到更上层的结果容器中。


不能实例化泛型类型的数组:new List<String>[3]是不合法的。
但是在可以确定类型的情况下,将Object数组强制转换成泛型数组是合法的,例如ArrayList的源码:return (T[]) Arrays.copyOf(elementData, size, a.getClass());


泛型方法:
声明方法时将用到的类型参数列在前面即可(所在类上不需要定义此参数类型):
public static <E> Set<E> union(Set<E> s1,Set<E> s2) ;
静态工具方法特别适合这样写。



http://blog.csdn.net/mai0net/article/details/7320399
一般来说编写java泛型方法时,返回值类型和至少一个参数类型应该是泛型,而且类型应该是一致的,如果只有返回值类型或参数类型之一使用了泛型,这个泛型方法的使用就大大的限制了,基本限制到跟不用泛型一样的程度。


第一种:public static <T extends CommonService> T getService(Class<T> clazz);
NoticeService noticeService=CommonService.getService(NoticeService.class);//正确的使用第一种泛型方法,不会出现编译错误。
NoticeService noticeService=CommonService.getService(UserService.class);//不正确的使用第一种泛型方法,会出现编译错误。
第二种:public static <T> T getService(Class<? extends CommonService> clazz);
NoticeService noticeService=CommonService.getService(NoticeService.class);//正确的使用第二种泛型方法,不会出现编译错误,逻辑也正确,运行时不会出现异常。
NoticeService noticeService=CommonService.getService(UserService.class);//不正确的使用第二种泛型方法,不会出现编译错误,但逻辑不正确,运行时会出现异常,危险!

网上不少关于泛型的说明很好,可是不知道是不是jdk版本问题,居然没办法实际通过编译,于是我只好自己在jdk1.7下一一重写和尝试,最后加上总结和注释,如下:

public class Fruit{
	
}
public class Apple extends Fruit {
	
}

public class Basket{
	//从泛型化的list中取出Fruit,里面的元素一定是Fruit的子类,所以都可以当作Fruit返回
	public static Fruit getFruit(List<? extends Fruit> list){
		return list.get(0);
	}
	
	//将Apple放入泛型化的list(这个list可以接收的类型是Apple的父类,所以一定可以接收apple或apple的子类)
	public static void addApple(List<? super Apple> list,Apple apple){
		list.add(apple);
	}
}

public class GenericTester extends AbstractTester{
	public void test1(){
		List<Apple> appleList = new ArrayList<Apple>();
		appleList.add(new Apple()); //先定义List<Apple>,填入元素
		Fruit fruit=Basket.getFruit(appleList); //List<Apple>类型符合List<? extends Fruit>的要求
	}
	
	public void test2(){
		List<Fruit> fruitList=new ArrayList<Fruit>();
		Basket.addApple(fruitList, new Apple()); //List<Fruit>符合List<? super Apple>的要求
	}
	
}

public class GenericCompileTester {
	public void addInteger1(List<?> list){
		list.add(1); //编译错误,因为问号代表“编译时不确定,但运行时确定”的类型,Integer不一定符合要求,其实这里相当于<? extends Object>
	}
	
	public void addInteger2(List<Object> list){
		list.add(1); //编译通过,因为编译时和运行时都确定了是Object类型,Integer肯定符合要求
	}
	
	public void test(){
		List<String> list=new ArrayList<String>();
		addInteger2(list); //编译错误,因为List<String>不能当作List<Object>传入,否则数字1将被当作String添加,类型将不再安全
	}
	
	public void test3(){
		List<? extends Fruit> fruitList=new ArrayList<Apple>();
		fruitList.add(new Apple());	//编译错误,编译器无法确定List允许的是Fruit的具体哪一个子类
		fruitList.add(new Fruit());	//编译错误,编译器无法确定List允许的是Fruit的具体哪一个子类
	}
	
	public void test4(){
		List<? super Apple> fruitList=new ArrayList<Fruit>();
		fruitList.add(new Apple());	//编译通过,Apple和Apple的子类都可以保证符合条件要求
		fruitList.add(new Fruit());	//编译错误,编译器无法确定List允许的是Apple的具体那个级别的父类或接口
	}
}








posted @ 2012-08-22 13:10 爱生活,爱编程 阅读(...) 评论(...) 编辑 收藏