码迷,mamicode.com
首页 > 编程语言 > 详细

Java 泛型技术(Generic)

时间:2020-05-08 13:22:21      阅读:75      评论:0      收藏:0      [点我收藏+]

标签:编译器   str   将不   import   dem   map   port   静态   java   

1.1  泛形的作用

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

ArrayList list = new ArrayList();

list.add("abc");

Integer num = (Integer) list.get(0);  //运行时会出错,但编码时发现不了

 

list.add(new Random());

list.add(new ArrayList());

for(int i=0;i<list.size();i++){

         (?)list.get(i);          //此处取出来的对象应转换成什么类型

}

 

(2)JDK5中的泛形允许程序员在编写集合代码时,就限制集合的处理类型,从而把原来程序运行时可能发生问题,转变为编译时的问题,以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。

注意:泛型是提供给javac编译器使用的,它用于限定集合的输入类型,让编译器在源代码级别上,即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后,生成的class文件中将不再带有泛形信息,使程序运行效率不受到影响,这个过程称之为“擦除”。

泛形的基本术语,以ArrayList<E>为例:<>念着typeof

ArrayList<E>中的E称为类型参数变量

ArrayList<Integer>中的Integer称为实际类型参数

整个称为ArrayList<E>泛型类型

整个ArrayList<Integer>称为参数化的类型ParameterizedType

1.2  泛型典型应用

使用迭代器迭代泛形集合中的元素。

使用增强for循环迭代泛形集合中的元素。

存取HashMap中的元素。

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

使用泛形时,泛形类型须为引用类型,不能是基本数据类型

//使用泛型时,如果两边都使用到泛型,两边必须一样

ArrayList<String> list = new ArrayList<Object>(); //bad

ArrayList<Object> list = new ArrayList<String>(); //bad

ArrayList<String> list = new ArrayList ();//ok

ArrayList list = new ArrayList<String>();//ok

package com;

import java.util.ArrayList;
import java.util.List;
import org.junit.Test;


public class Demo1 {
    @Test
    public void test1(){
        List list=new ArrayList();
        list.add("111");
        list.add("222");
        list.add("333");
        //传统方式手工转换
        String i=(String) list.get(0);
        //下面注释代码手工转换编辑不报错,运行错误
        //Integer ii=(Integer) list.get(0);        
        System.out.println(i);        
    }
    @Test
    public void test2(){
        List <String>list=new ArrayList<String>();
        list.add("111");
        list.add("222");
        list.add("333");
        //现在不需要强制转换
        String i=list.get(0);
        //下面注释代码编译通不过
        //Integer ii=(Integer) list.get(0);        
        System.out.println(i);        
    }
}

Demo2:

package com;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.Test;

public class Demo2 {
    @Test
    public void test1(){
        List <String>list=new ArrayList<String>();
        list.add("111");
        list.add("222");
        list.add("333");
        //传统
        Iterator<String> it=list.iterator();
        while(it.hasNext()){
            String value=it.next();
            System.out.println(value);
        }
        //增强for
        for(String s:list)
            System.out.println(s);        
    }
    @Test
    public void test2(){
        Map<Integer,String> map=new HashMap<Integer,String>();
        map.put(1, "aaa");
        map.put(2, "bbb");
        map.put(3, "ccc");
        //传统 keyset  entryset
        Set <Map.Entry<Integer, String>> set=map.entrySet();
        Iterator <Map.Entry<Integer, String>>it=set.iterator();
        while(it.hasNext()){
            Map.Entry<Integer, String>entry=it.next();
            int key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key+"="+value);
        }
        //增强for(重点)
        for(Map.Entry<Integer, String> entry:map.entrySet()){
            int key=entry.getKey();
            String value=entry.getValue();
        }        
    }    
}
1.1  自定义泛形——泛型方法

Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。方法使用泛形前,必须对泛形进行声明,语法:<T>,T可以是任意字母,但通常必须要大写。<T>通常需放在方法的返回值声明之前。例如:  public static <T> void doxx(T t);

注意:只有对象类型才能作为泛型方法的实际参数。

在泛型中可以同时有多个类型,例如:

                   public static <K,V> V getValue(K key) { return map.get(key);}

1.2  自定义泛形——泛型类

如果一个类多处都要用到同一个泛型,可以把泛形定义在类上(即类级别的泛型),语法格式如下:

         public class GenericDao<T> {

                   private T field1;

                   public void save(T obj){}

                   public T getId(int id){}

         }

注意,静态方法不能使用类定义的泛形,而应单独定义泛形。

自定义带泛型的方法:

package com;

//自定义带泛型的方法
public class Test {
    public void testa(){
        a("aaaa");
    }
    public <T> void  a(T t){
        
    }
    public <T,E,K> void b(T t,E e,K k){
        
    }
}

自定义类上的泛型:

package com;

//自定义类上的泛型
public class Test <T>{
    public static void main(String[] args) {
        Test t = new Test();
        t.a("a");
        c("c");
    }
    
    public  void  a(T t){
        System.out.println(t.toString());
    }
    public <E,K> void b(T t,E e,K k){
        
    }    
    //类上的泛型不能作用于静态方法
    public static <T> void c(T t){
        System.out.println(t.toString());
    }
}
1.1  泛型的高级应用——通配符

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

void print (Collection<String> c) {

          for (String e : c) {

                System.out.println(e);

           }

问题:该方法只能打印保存了Object对象的集合,不能打印其它集合。通配符用于解决此类问题,方法的定义可改写为如下形式:

void print (Collection<?> c)  {   //Collection<?>(发音为:"collection of unknown")

for (Object e : c) {

         System.out.println(e);

}

}

此种形式下需要注意的是:由于print方法c参数的类型为Collection<?>,即表示一种不确定的类型,因此在方法体内不能调用与类型相关的方法,例如add()方法。

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

1.2  泛型的高级应用——有限制的通配符

限定通配符的上边界:

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

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

限定通配符的下边界:

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

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

问题:以下代码行不行?

public void add(List<? extends String> list){

         list.add("abc");

}

Java 泛型技术(Generic)

标签:编译器   str   将不   import   dem   map   port   静态   java   

原文地址:https://www.cnblogs.com/aaron911/p/7788889.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!