JAVA泛型实例解析

最新推荐文章于 2024-04-24 19:36:44 发布
最新推荐文章于 2024-04-24 19:36:44 发布
阅读量177 收藏
点赞数
分类专栏： JAVA基础 文章标签： java 泛型 java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_16391/article/details/82436094
版权

JAVA泛型大体分为:基本泛型和通配符泛型，在大多数项目下一般使用基本泛型的概率会大一些，此文主要就是对最近学习的泛型进行的一个总结，不足的望给予批评与指导！下例子

   案例1：

 

Java代码 复制代码  收藏代码
  1. public class GenericTest {   
  2.        
  3.     /*在JAVA1.4中的集合应用是无泛型的，我们可以向内部传入各种种类的值*/  
  4.     public void Generic14(){   
  5.         ArrayList co = new ArrayList();   
  6.         co.add(1);   
  7.         co.add(1L);   
  8.         co.add("aaa");   
  9.         /*但是我们需要在获取的时候对其进行强制类型转换*/  
  10.         int i = (Integer)co.get(0);   
  11.         System.out.println(i);   
  12.     }   
  13.        
  14.     /*JDK1.5中添加了泛型关键字为<>(如<String>,其中放置的基本数据类型)这样有效的减少强制转换*/  
  15.     public void Generic15() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{   
  16.         ArrayList<Integer> cos = new ArrayList<Integer>();   
  17.         cos.add(1);   
  18.         cos.add(2);   
  19.         /*因为经过泛型所以cos.add("abc");不能被编译器所通过，但是泛型的样式在编译过后将被剔除仍为ArrayList形式*/  
  20.         /*以下为反射的例子，去做验证，利用反射的方法调用ArrayList的add方法向cos对象中插入字符串abc*/  
  21.         Method  method = ArrayList.class.getMethod("add", Object.class);   
  22.         //           对象   参数值   
  23.         method.invoke(cos, "abc");   
  24.         //遍历cos对象   
  25.         for(Object c : cos){   
  26.             System.out.println(c);   
  27.         }   
  28.     }   
  29.        
  30.     /*例子2*/  
  31.     public void GenericlA(){   
  32.         List<Integer> A = new ArrayList<Integer>();   
  33.         List<String> B = new ArrayList<String>();   
  34.         //泛型在编译时已经被去除并不带入到运行过程   
  35.         System.out.println(A.getClass()==B.getClass());   
  36.     }   
  37.        
  38.     public void Connection(){   
  39.         //Collection父类   
  40.         Collection c = new ArrayList();   
  41.         //Vector类型相当于Arraylist内部进行了syn的处理，效率会相对Array的类型要底   
  42.         Vector<String> d = new Vector();   
  43.     }   
  44.        
  45.     public static void main(String[] args) throws SecurityException, IllegalArgumentException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {   
  46.         GenericTest genericTest = new GenericTest();   
  47. //      genericTest.Generic14();   
  48. //      genericTest.Generic15();   
  49. //      genericTest.GenericlA();   
  50.         genericTest.GAll();   
  51.     }   
  52.        
  53.     public static void GAll(){   
  54.         //map的迭代   
  55.         HashMap<String, Integer> hashMaps = new HashMap<String, Integer>();   
  56.         hashMaps.put("dhy", 11);   
  57.         hashMaps.put("slb",5);   
  58.         //但是map型不能直接进行迭代必须转化为set类型才能   
  59.         Set<Map.Entry<String, Integer>> entrySet = hashMaps.entrySet();   
  60.         for (Entry<String, Integer> entry : entrySet) {   
  61.             System.out.println(entry.getKey()+" : "+entry.getValue());   
  62.         }   
  63.     }   
  64.        
  65. }  
public class GenericTest {
	
	/*在JAVA1.4中的集合应用是无泛型的，我们可以向内部传入各种种类的值*/
	public void Generic14(){
		ArrayList co = new ArrayList();
		co.add(1);
		co.add(1L);
		co.add("aaa");
		/*但是我们需要在获取的时候对其进行强制类型转换*/
		int i = (Integer)co.get(0);
		System.out.println(i);
	}
	
	/*JDK1.5中添加了泛型关键字为<>(如<String>,其中放置的基本数据类型)这样有效的减少强制转换*/
	public void Generic15() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		ArrayList<Integer> cos = new ArrayList<Integer>();
		cos.add(1);
		cos.add(2);
		/*因为经过泛型所以cos.add("abc");不能被编译器所通过，但是泛型的样式在编译过后将被剔除仍为ArrayList形式*/
		/*以下为反射的例子，去做验证，利用反射的方法调用ArrayList的add方法向cos对象中插入字符串abc*/
		Method  method = ArrayList.class.getMethod("add", Object.class);
		//           对象   参数值
		method.invoke(cos, "abc");
		//遍历cos对象
		for(Object c : cos){
			System.out.println(c);
		}
	}
	
	/*例子2*/
	public void GenericlA(){
		List<Integer> A = new ArrayList<Integer>();
		List<String> B = new ArrayList<String>();
		//泛型在编译时已经被去除并不带入到运行过程
		System.out.println(A.getClass()==B.getClass());
	}
	
	public void Connection(){
		//Collection父类
		Collection c = new ArrayList();
		//Vector类型相当于Arraylist内部进行了syn的处理，效率会相对Array的类型要底
		Vector<String> d = new Vector();
	}
	
	public static void main(String[] args) throws SecurityException, IllegalArgumentException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
		GenericTest genericTest = new GenericTest();
//		genericTest.Generic14();
//		genericTest.Generic15();
//		genericTest.GenericlA();
		genericTest.GAll();
	}
	
	public static void GAll(){
		//map的迭代
		HashMap<String, Integer> hashMaps = new HashMap<String, Integer>();
		hashMaps.put("dhy", 11);
		hashMaps.put("slb",5);
		//但是map型不能直接进行迭代必须转化为set类型才能
		Set<Map.Entry<String, Integer>> entrySet = hashMaps.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println(entry.getKey()+" : "+entry.getValue());
		}
	}
	
}

    案例2：

Java代码 复制代码  收藏代码
  1. public class GenericWTest {   
  2.        
  3.     public static void printCollection (Collection<Object> collection){   
  4.         for(Object c : collection){   
  5.             System.out.println(c);   
  6.         }   
  7.     }   
  8.        
  9.     public static void main(String[] args) {   
  10.         ArrayList<String> test = new ArrayList<String>();   
  11.         Collection<String> cn = new ArrayList<String>();   
  12.         /* 本身定义的是Collection<Object>  
  13.          * 传入的是ArrayList(Collection的子类型)<String(Object的子类型)>  
  14.          * 但是却说类型不对,原因在于Collecttion<Object>这样定义后就是要传入<object>的值  
  15.          * 所以在泛型中没有父类与子类之分,所以要用下面的方法  
  16.          */  
  17.         ArrayList<Object> test2 = new ArrayList<Object>();   
  18.         test.add("a");   
  19.         test.add("b");   
  20.         printCollection(test2);   
  21.            
  22.         String[] strs = new String[]{"aaa","bbb","ccc"};   
  23.         ArrayList lists = new ArrayList();   
  24.         lists = (ArrayList) copy1(strs, lists);   
  25.         for (Object list : lists) {   
  26.             System.out.println(list);   
  27.         }   
  28.   
  29. //      泛型的追溯特性，String和Date的都是Serializable的子类   
  30.         copy(new String[10], new Date[10]);   
  31.            
  32. //      泛型的传播特性，其中为Date类型()   
  33. //      copy1(new String[10],new ArrayList<Date>());   
  34.     }   
  35.   
  36.     /*为此推出了?这个通配符*/  
  37.     public static void printCollection2 (Collection<?> collection){   
  38.         /*但是引入这个通配符后，不能对这样的Collection对象去调用与参数有关的方法*/  
  39.         /*collection.add("aa");这样的语句是报错的，因为他不能确定泛型是什么类型的*/  
  40.         for(Object c : collection){   
  41.             System.out.println(c);   
  42.         }   
  43.     }   
  44.     //13:servlet jsp jmail jdbc jndi xml    
  45.     public static void ClassTest(){   
  46.         Class<?> a = null;   
  47.     }   
  48.     // 泛型方法    
  49.     public static <T> T[] copy(T[] forms,T[] to){   
  50.         return null;   
  51.     }   
  52.        
  53.     public static <T> Collection<T> copy1(T[] froms,Collection<T> to){   
  54.         for(T yuan : froms){   
  55.             to.add(yuan);   
  56.         }   
  57.         return to;   
  58.     }   
  59.        
  60. }  
public class GenericWTest {
	
	public static void printCollection (Collection<Object> collection){
		for(Object c : collection){
			System.out.println(c);
		}
	}
	
	public static void main(String[] args) {
		ArrayList<String> test = new ArrayList<String>();
		Collection<String> cn = new ArrayList<String>();
		/* 本身定义的是Collection<Object>
		 * 传入的是ArrayList(Collection的子类型)<String(Object的子类型)>
		 * 但是却说类型不对,原因在于Collecttion<Object>这样定义后就是要传入<object>的值
		 * 所以在泛型中没有父类与子类之分,所以要用下面的方法
		 */
		ArrayList<Object> test2 = new ArrayList<Object>();
		test.add("a");
		test.add("b");
		printCollection(test2);
		
		String[] strs = new String[]{"aaa","bbb","ccc"};
		ArrayList lists = new ArrayList();
		lists = (ArrayList) copy1(strs, lists);
		for (Object list : lists) {
			System.out.println(list);
		}

//		泛型的追溯特性，String和Date的都是Serializable的子类
		copy(new String[10], new Date[10]);
		
//      泛型的传播特性，其中为Date类型()
//		copy1(new String[10],new ArrayList<Date>());
	}

	/*为此推出了?这个通配符*/
	public static void printCollection2 (Collection<?> collection){
		/*但是引入这个通配符后，不能对这样的Collection对象去调用与参数有关的方法*/
		/*collection.add("aa");这样的语句是报错的，因为他不能确定泛型是什么类型的*/
		for(Object c : collection){
			System.out.println(c);
		}
	}
	//13:servlet jsp jmail jdbc jndi xml 
	public static void ClassTest(){
		Class<?> a = null;
	}
	// 泛型方法	
	public static <T> T[] copy(T[] forms,T[] to){
		return null;
	}
	
	public static <T> Collection<T> copy1(T[] froms,Collection<T> to){
		for(T yuan : froms){
			to.add(yuan);
		}
		return to;
	}
	
}

 

iteye_16391
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java泛型的实战应用
qfluohao的博客
05-07 515
Java有很多的高级特性，泛型是其中之一，泛型即参数化类型。关于泛型的概念，有很多文章都有介绍，这里就不再过多的介绍了。本文将从实战的角度，来看看泛型在实际项目中的使用 1 泛型在框架中的使用 泛型在框架中及为常见，我们在使用各种框架的时候，都会使用到泛型，具体看下面的例子。 1.1 集合框架中使用泛型 这是最常见的泛型的使用场景，比如下面的代码 List<String&gt...
Java学习教程：Java泛型的实战应用
chen801090的博客
05-07 315
Java有很多的高级特性，泛型是其中之一，泛型即参数化类型。关于泛型的概念，有很多文章都有介绍，这里就不再过多的介绍了。本文将从实战的角度，来看看泛型在实际项目中的使用 1 泛型在框架中的使用 泛型在框架中及为常见，我们在使用各种框架的时候，都会使用到泛型，具体看下面的例子。 1.1 集合框架中使用泛型 这是最常见的泛型的使用场景，比如下面的代码 List<String&gt...
Java——Java泛型
用代码征服天下
11-07 195
该系列博文会告诉你如何从入门到进阶，一步步地学习Java基础知识，并上手进行实战，接着了解每个Java知识点背后的实现原理，更完整地了解整个Java技术体系，形成自己的知识框架。 一、泛型概述 1、定义： 所谓泛型，就是允许在定义类、接口、方法时使用类型形参，这个类型形参(或叫泛型)将在声明变量、创建对象、调用方法时动态地指定(即传入实际的类型参数，也可称为类型实参)。Java5改写了集合...
Java 泛型实例
chengzhe1983的博客
06-02 718
泛型 在写代码时有些时候同一种方法要根据不同的输入类型进行不同的返回，在没有泛型的情况下我认为有以下几种解决方式： 设置不同的类或不同的方法。 需要输入类型继承特殊接口。 将输入类型转化为Object传入，之后将输出再强转。 以上个点劣势1：代码过多，不便于维护 2：...
Java泛型实例
06-06
Java泛型，泛型接口、泛型方法实例
Java 泛型全解析
09-07
3. **泛型方法**：在方法定义中使用泛型，如`<T> T newInstance(Class<T> cls)`，这样方法可以接受任何类型的参数，并返回相应类型的实例。 **泛型通配符** 1. **无界通配符**：`<?>`可以代表任何类型，常用于变量...
java泛型常用通配符实例解析
08-25
java泛型常用通配符实例解析 Java泛型是Java 5中引入的一项新特性，可以用来编写泛型代码，使得代码更加灵活和可重用。其中，通配符是泛型中的一种重要概念，本文将详细介绍Java泛型常用通配符实例解析。 1. 限定...
Java泛型的使用限制实例分析
08-25
"Java泛型的使用限制实例分析" Java泛型的使用限制是Java编程语言中的一個重要概念，泛型的使用可以提高代码的可读性和安全性，但是需要注意一些使用限制，否则可能会出现编译错误或运行时异常。 首先， Java泛型...
Java泛型extends及super区别实例解析
08-18
Java泛型extends及super区别实例解析 Java泛型中的通配符（Wildcards）和边界（Bounds）是两个重要的概念，分别由 <? extends T> 和 <? super T> представляют。这些概念的出现是为了解决泛型中的一些...
Java泛型应用实例
01-04
网上很多讲泛型原理的文章, 很少有提到我们什么时候使用泛型有优势, 我就泛型类和方法搞了两个实例,算是探索下泛型使用的冰山一角吧,在我博客里面有配套的文章,可以配套看.
Java泛型是什么?实战demo
qq_42390636的博客
04-02 110
1. 概述 泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。 什么是泛型？为什么要使用泛型？ 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式(可以称之为类型形参)，然后在使用/调用时传入具体的类型...
Java开发实战讲解！Java泛型详解
m0_57077948的博客
08-05 332
定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Person类型的对象。这是完全允许的，因为此时list默认的类型为Object类型。但是以上代码存在两个问题： 获取一个值时必须进行强制类型转换：将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，该对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。 没有错误检查：由于不小心加入了其他类型的值或其他编码原因，使用强制类型装换很容易出现类似于//1中的错误。因为编译阶段正常，而..
java泛型使用的实例_Java中泛型使用实例详解
weixin_32820805的博客
02-28 107
Java中泛型使用泛型作用：泛型：集合类添加对象不用强转反射机制：将泛型固定的类的所有方法和成员全部显示出来核心代码：ArrayList ff=new ArrayList();Ls ls1=new Ls("薯片",5f);ff.add(ls1);Ls cls=ff.get(0);//这里不再需要强转代码实例：说明：这是非泛型的代码，集合类中调用对象时需要强转import java.util.*;p...
【JAVA基础】JAVA泛型原理与实战
后端研发工程师Marion的博客
11-26 162
一、参考资料 # Awesome Sentinel [![Awesome](https://awesome.re/badge-flat.svg)](https://awesome.re) A curated list of awesome things (e.g. samples, third-party extensions, blog posts) for [Sentinel](https://github.com/alibaba/Sentinel). If you want your com
Java泛型：深入理解与实战应用
最新发布
suqieer的博客
04-24 855
借助泛型，可以轻松实现支持多种数据类型的自定义数据结构，如链表、栈、队列等。
java实战篇：第四篇，泛型和集合
rs_gis的博客
12-20 862
文章目录说明一、泛型CollectionList 说明 Java 使用集合来组织和管理对象，本节我们重点讲解泛型和集合。主要介绍 Collection、List、ArrayList、Map、HashMap、Set 和 HashSet、Collections、算法等内容。 一、泛型 泛型即参数化类型，也就是说数据类型变成了一个可变的参数，在不使用泛型的情况下，参数的数据类型都是写死了的，使用泛型之后，可以根据程序的需要进行改变。 定义泛型的规则： 只能是引用类型，不能是简单数据类型。 泛型参数可以有多个。
Java泛型：定义、使用与实战
Jz_Stu的博客
03-26 1476
泛型是Java SE 5.0中引入的一个新特性，它提供了编译时类型安全，减少了类型转换的代码，并提高了代码的可重用性。泛型，顾名思义，就是广泛的数据类型。在Java中，泛型允许我们在定义类、接口和方法时使用类型参数。这些类型参数在类、接口或方法被实例化时（即创建对象时）被具体的类型替换。这样，我们可以编写更加通用的代码，提高代码的可重用性。当我们需要自定义一些数据结构（如栈、队列等）时，泛型可以帮助我们编写更加通用的代码。通过使用泛型，我们可以使这些数据结构支持任意类型的元素。
Java泛型深入解析
Java泛型是自JDK 1.5版本引入的一种强大的编程特性，它允许在类、接口和方法中使用类型参数，以增强类型安全性和代码重用性。本教程将深入讲解这一主题，帮助开发者理解和应用泛型。 1. **泛型基础** 泛型的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值