赵雅智_Java 泛型

JDK5以前,对象保存到集合中就会失去其特性,取出时通常要程序员手工进行类型的强制转换,这样不可避免就会引发程序的一些安全性问题。

泛形的典型应用:BaseDao

例如:

public class Demo1 {

	/**
	 * @param args
	 */
	@Test
	public void test(){
	ArrayList list = new ArrayList();
	list.add("abc");
	list.add(new Integer(10));
	//list.add("name");
	list.add(new Random());
	list.add(new ArrayList());
	for(int i=0;i<list.size();i++){
		Integer num = (Integer) list.get(i);  //运行时会出错,但编码时发现不了
		System.out.println(num);
	}
	}

使用泛型,对list集合中存放的对象加了限制,此时再放入其他的对象就出现了错误

@Test
	public void testt(){
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(new Integer(10));
		/*在list中放入非Integer类型讲提示错误
		 * list.add("name");
		list.add(new Random());
		list.add(new ArrayList());*/
		for(int i=0;i<list.size();i++){
			Integer num =  list.get(i);  //不用强转
			System.out.println(num);
		}
		}


泛型的作用

  • JDK5中的泛形允许程序员在编写集合代码时,就限制集合的处理类型,从而把原来程序运行时可能发生问题,转变为编译时的问题,以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。
  • 不用强转
  • 注意:泛型是提供给javac编译器使用的,它用于限定集合的输入类型,让编译器在源代码级别上,即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后,生成的class文件中将不再带有泛形信息,以此使程序运行效率不受到影响,这个过程称之为“擦除”。

泛形的基本术语

以ArrayList<E>为例

  • <>念着type of
  • E称为类型参数变量
  • 整个称为ArrayList<E>泛型类型
  • ArrayList<Integer>中的Integer称为实际类型参数
  • 整个ArrayList<Integer>称为参数化的类型ParameterizedType

泛型典型应用

  1. 使用迭代器迭代泛形集合中的元素。
    public void test1(){
    		List<String> list=new ArrayList<String>();
    		
    		list.add("abc");
    		list.add("1");
    		list.add("efg");
    		
    		//1.
    		Iterator<String> it=list.iterator();
    		while(it.hasNext()){
    			String str=it.next();
    			System.out.println(str);
    		}
    }

  2. 使用增强for循环迭代泛形集合中的元素。
    @Test
    	public void test1(){
    		List<String> list=new ArrayList<String>();
    		
    		list.add("abc");
    		list.add("1");
    		list.add("efg");
    				
    		//2.
    		for(String str:list){
    			System.out.println(str);
    		}	
    	}

  3. 存取HashMap中的元素。
    @Test
    	//未加泛型
    	public void test2(){
    		Map m=new HashMap();
    		m.put(1,"aa");
    		m.put(2,"bb");
    		m.put(3,"cc");
    		
    		
    		//map.keySet(); map.entrySet();
    		
    		Set set=m.entrySet();
    		
    		Iterator it=set.iterator();
    		
    		while(it.hasNext()){
    			Map.Entry  me=(Map.Entry)it.next();
    			
    			System.out.println(me.getKey()+"..."+me.getValue());
    		}
    		
    		
    	}
    	@Test
    	//加泛型
    	public void test3(){
    		Map<Integer,String> map=new HashMap<Integer,String>();
    		
    		map.put(1,"aa");
    		map.put(2,"bb");
    		map.put(3,"cc");
    		
    		Set<Map.Entry<Integer,String>> set= map.entrySet();
    		
    		Iterator<Map.Entry<Integer,String>> it=set.iterator();
    		
    		while(it.hasNext()){
    			Map.Entry<Integer,String> me=it.next();
    			System.out.println(me.getKey()+"..."+me.getValue());
    		}
    		
    	}

使用泛形时的几个常见问题:

  • 使用泛形时,泛形类型须为引用类型,不能是基本数据类型
    ArrayList<String> list = new ArrayList<Object>();  //错
    ArrayList<Object> list = new ArrayList<String>(); //错
    ArrayList<String> list = new ArrayList ();               //行
    ArrayList list = new ArrayList<String>();              
    //行
  • 两边的类型必须一致
       ArrayList<String> list = new ArrayList<String>();
  • 两边只有一边用泛型(为了保持兼容性)
         ArrayList<String> list = new ArrayList ();
         ArrayList list = new ArrayList<String>();
    public static void test4(ArrayList list){
    		
    	}
    	
    	public static void test5(ArrayList<String> list){
    		
    	}
    	
    	public static void main(String[] args) {
    		
    		test5(new ArrayList());
    
    	}

自定义泛形——泛型方法

Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。

方法使用泛形前,必须对泛形进行声明,

语法:

<T> ,T可以是任意字母,但通常必须要大写。

  • <T>通常需放在方法的返回值声明之前。public static <T> void method(T t);
    注意
    1. 只有对象类型才能作为泛型方法的实际参数。
    2. 在泛型中可以同时有多个类型
      package com.hbsi.generics;
      
      import java.util.Arrays;
      
      public class Demo3 {
      
      	/**
      	 * @param args
      	 */
      	public static void main(String[] args) {
      		Integer arr1[]={1,2,3,4};
      		test(arr1,0,3);
      		/*for循环遍历
      		 * for(Integer i:arr1){
      			System.out.print(i);
      			
      		}//4231*/
      		//测试Test
      		System.out.println(Arrays.asList(arr1));
      		
      		//测试Text2
      		String arr[]={"a","b","c","d"};
      		test2(arr);
      		System.out.println(Arrays.asList(arr));
      	}
      	
      	//编写一个泛形方法,实现数组元素的交换。
      	
      	public static <T> void test(T arr[],int i,int j){
      		
      		T temp=arr[i];
      		arr[i]=arr[j];
      		arr[j]=temp;
      		
      	}
      	//编写一个泛形方法,接收一个任意数组,并颠倒数组中的所有元素
      	
      	public static <T> void test2(T arr[]){
      		int start=0;
      		int end=arr.length-1;
      		
      		while(true){
      			
      			if(start>=end){
      				break;
      			}
      			T temp=arr[start];
      			arr[start]=arr[end];
      			arr[end]=temp;
      			
      			start++;
      			end--;
      		}	
      	}
      }
      

  • 如果一个类多处都要用到同一个泛型,这时可以把泛形定义在类上(即类级别的泛型),语法格式如下:
     public class GenericDao<T> {
      private T field1;
      public void save(T obj){}
      public T getId(int id){}
     }

    注意
    1.  在类级别上定义的泛型,只对类的非静态成员有效
    2. 静态方法不能使用类定义的泛形,而应单独定义泛形。
      package com.hbsi.generics;
      
      public class Demo2 <T,E>{
      
      	/**
      	 * @param args
      	 */
      	public static void main(String[] args) {
      		// TODO Auto-generated method stub
      
      	}
      	
      	//自定义泛型方法
      	
      	public  void test1(T t){
      		
      	}
      	
      	public  void test2(T t){
      		
      	}
      	
      	public static <T> void test3(T t){
      		
      	}
      }
      

通配符

定义一个方法,接收一个集合,并打印出集合中的所有元素,如下所示:

  void print (Collection<String> c) {
           for (String e : c) {
                 System.out.println(e);
           }
} 


问题:该方法只能打印保存了String对象的集合,不能打印其它集合。通配符用于解决此类问题,

方法的定义可改写为如下形式:

void print (Collection<?> c) {   //Collection<?>(发音为:"collection of unknown")
for (Object e : c) {
System.out.println(e);
}
}


此种形式下需要注意的是:

由于print方法c参数的类型为Collection<?>,即表示一种不确定的类型

因此在方法体内不能调用与类型相关的方法,例如add()方法。但可以调用与类型无关的方法,例如size()方法

总结:使用?通配符主要用于引用对象,使用了?通配符,就只能调对象与类型无关的方法,不能调用对象与类型有关的方法。

有限制的通配符

限定通配符的上边界(?的类型必须是Number的子类),限定通配符总是包括自己。

正确:Vector<? extends Number> x = new Vector<Integer>();
错误:Vector<? extends Number> x = new Vector<String>();

限定通配符的下边界(?的类型必须是Integer的父类)

正确:Vector<? super Integer> x = new Vector<Number>();
错误:Vector<? super Integer> x = new Vector<Byte>();

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值