深入了解泛型


深入了解泛型

                   泛型是为编译器用的

           可以用反射跳过编译

                   例如ArrayList<Integer>collection = new ArrayList<Integer>();

                            collection.add("abb");//编译器会报错

                            //通过反射

                            collection.getClass().getMethod("add",Object.class).invoke(collection,"sd");

                            因为编译器编译后会去掉泛型,所以在内存中不存在泛型

           几种错误

                            Collection<String>c = new Vector();警告

                            Collectionc= new Vector<String>();警告

                            Collection<String>c = new Vector<Object>();错误

                            Collection<Object>c = new Vector<String>();错误

           通配符?    

                            表示任意类型

                            publicstatic void printCollection(Collection<?> cols){

                                     cols.add(1);//错误?可以代表任意类型

                                     cols.size();//正确,此方法和类型参数无关

                                     cols= new HashSet<Date>()//正确,如果作为参数传递过来,是可以的。因为cols可以表示任意类型

                                    

                            }

                                     publicstatic void printCollection(Collection<Object> cols){

                                     cols.add(1);//正确

                                     cols= new HashSet<Date>()//错误,相当于赋值,传参,类型错误

                                     cols.size();//正确,此方法和类型参数无关

                                    

                            }

                            使用?通配符可以引用其他各种参数化的类型,?通配符的作用主要用作引用

                            ,可以调用与参数化无关的方法,不能调用与参数化有关的方法

                   限定

                 上限

                            Vector<?extendsNumber> x = new Vector<Integer>();//正确,必须是Number的子类或者本身

                            Vector<?extendsNumber> x = new Vector< String >();//错误

                 下限

                            Vector<?superInteger> x = new Vector<Number>();//正确,必须是Integer的父类或者本身

                            Vector<?superInteger> x = new Vector<Byte>();//错误

                            a<?>= new a<Integer>();可以,反过来不可以

                            编译器不允许创建类型变量的数组

                            Vector<Integer>[]list = new Vector<Integer>[10];//错误

                           

           HashMap 的迭代

                            HashMap<String,Integer>map = new HashMap<string,Integer>)();

                            map.add("sd",1);

                            map.add("s",3);

                            map.add("sdd",4);

                            Set<Map.Entry<String,Integer>>entrySet = map.entrySet();

                            for(Map.Entry<String,Integer>entry:entrySet){

                                     entry,getKey();entry.getValue();

                            }

           泛型的应用

                            泛型先定义后使用

                            publicstatic <T> void swap(T[] a ,int i,int j){

                                     Ttemp = a[i];

                                     a[i]  = a[j];

                                     a[j]= temp;

                            }

                            swap(newString[]("s","s"),0,1);//正确

                            swap(newint[]{1,2,3,4,4},2,3);//错误,因为基本数据类型不能作为T实际类型

                           

                            privatestatic <T> TconvertObj(Object obj){

                                     return(T)obj

                            }

                            privatestatic <T> void arr(T[] a,T v){

                                     for(inti = 0;i<a.length;i++){

                                               a[i]= v

                                     }

                            }

                            privatestatic <T> void printCollection(Collection<T> cols,T t){

                                     cols.add(t);//正确,因为类型就是T,确定类型就可以增加了

                            }

                            privatestatic <T> void copyData(T[] arr,Collection<T> cols){

                                     inti = 0;

                                     for(Tc:cols){

                                               arr[i]= c

                                               i++;

                                     }

                            }

           在类上用泛型

                            publicclss Dao<T>{

                                     publicvoid add(T t){

                                     }

                                     publicvoid delete(T t){}

                                     publicvoid update(T t){}

                                     publicSet<T> findByConditions(String where){return null}

                                     publicstatic void update(T t){}//出错,静态不能用类泛型,除非单独定义泛型因为静态方法单独存在

                            }

                            可以保证T是同一种类型,因为是在类上定义的

                            如果是 public<T> void delete(T t){}

                            public<T> void udpate(T t){}

                            则就不能保证是同一个类型

                            Dao<RefkectPoint>da = new Dao<RefkectPoint>();

                           

           如何确定一个集合中元素的类型

                            Vector<Date>v ;无法通过v本身来得到

                            可以把v放在一个方法里

                            publicstaic void applyVector(Vector<Date> v){}

                            publicstatic void main(){

                                     //得到该类的字节码对象,通过字节码对象来得到该方法

                                     Methodmethod = GenericTest.class.getMethod("applyVector",Vector.class);

                                     //得到该方法的泛化类型列表

                                     Type[]types = method.getGenericParameterTypes();

                                     //转为变量类型

                                     ParameterizedTypeptype = (ParameterizedType) types[0];

                                     //得到原始类型

                                     ptype.getRawType();//Vector

                                    得到真实类型

                                     ptype.getActualTypeArguments()[0];//Date

                  

                                    

                            }

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

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值