`

JAVA泛型实例解析

java泛型java基础 
阅读更多

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;
	}
	
}

 

分享到：
| 用户权限管理
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java泛型的用法及T.class的获取过程解析

    Java泛型的用法及T.class的获取过程解析 Java泛型是Java编程语言中的一种重要特性，它允许开发者在编写代码时指定类型参数，从而提高代码的灵活性和可读性。本文将详细介绍Java泛型的用法 及T.class的获取过程解析...

    Java泛型实例

    Java泛型是Java编程语言中的一个重要特性，它在2004年随着Java SE 5.0的发布而引入。这个特性允许程序员在定义类、接口和方法时声明类型参数，从而增强了代码的类型安全性和重用性。通过使用泛型，我们可以编写更加...

    很好的Java泛型的总结

    Java泛型机制详解 Java泛型是Java语言中的一种机制，用于在编译期检查类型安全。Java泛型的出现解决了Java早期版本中类型安全检查的缺陷。Java泛型的好处是可以在编译期检查类型安全，避免了运行时的...

    全面总结Java泛型--实例

    标题与描述均提到了“全面总结Java泛型--实例”，这表明文章旨在深入解析Java泛型的概念，并通过具体示例来展示其应用。Java泛型是Java编程语言的一个强大特性，它允许在编译时检查类型安全，并且所有的强制转换都是...

    Java泛型擦除深度解析：原理、影响与编程实践

    Java泛型是Java 5中引入的一项重要特性，它为编译时类型安全提供了支持。然而，Java泛型的实现机制——类型擦除，也带来了一系列的问题和限制。本文将深入探讨Java泛型擦除的工作原理、它对编程的影响，以及在实际...

    java泛型指南 经典

    ### Java泛型指南经典知识点解析 #### 一、引言 Java 1.5 版本引入了一系列重要的语言特性，其中“泛型”是其中一项关键特性。泛型的引入极大地提高了 Java 语言的类型安全性和代码重用性。本文档旨在深入探讨 ...

    Java泛型设计及其PECS原则解析

    内容概要：本文详细介绍了Java泛型的起源、特性、应用场景及限制。重点讲解了PECS（Producer extends Consumer super）原则及其在实际编码中的重要性和应用。通过具体示例阐述了泛型的引入对代码安全性的提升和...

    Java深度历险之Java泛型.docx

    类型擦除导致了一些副作用，比如泛型类无法拥有独特的`Class`对象，所有泛型实例共享相同的静态成员等。 2. **与旧版本的兼容性**：为了保持向后兼容性，Java泛型的实现方式并不完美。例如，无法在异常处理的`...

    重新理解Java泛型

    本文旨在深入解析Java泛型的各个方面，帮助开发者形成全面、清晰的理解。 1. **泛型基础** - **泛型类**：泛型类是在类定义时引入类型参数的，如`Box&lt;T&gt;`中的`T`，它代表一个未指定的具体类型。这种设计使得类能够...

    Java 泛型全解析

    3. **泛型方法**：在方法定义中使用泛型，如`&lt;T&gt; T newInstance(Class&lt;T&gt; cls)`，这样方法可以接受任何类型的参数，并返回相应类型的实例。 **泛型通配符** 1. **无界通配符**：`&lt;?&gt;`可以代表任何类型，常用于变量...

    Java泛型的使用限制实例分析

    "Java泛型的使用限制实例分析" Java泛型的使用限制是Java编程语言中的一個重要概念，泛型的使用可以提高代码的可读性和安全性，但是需要注意一些使用限制，否则可能会出现编译错误或运行时异常。 首先， Java泛型...

    Java泛型extends及super区别实例解析

    Java泛型extends及super区别实例解析 Java泛型中的通配符（Wildcards）和边界（Bounds）是两个重要的概念，分别由 &lt;? extends T&gt; 和 &lt;? super T&gt; представляют。这些概念的出现是为了解决泛型中的一些...

    java泛型精华

    本文将深入探讨Java泛型的精髓，解析其工作原理，以及在使用过程中可能遇到的问题和解决方案。 #### 泛型擦除与类型安全 Java泛型的实现方式被称为“擦除”（Erasure），即在编译阶段，编译器会根据泛型参数进行...

    Java泛型和集合-英文版

    根据提供的文件信息，我们可以确定本书的标题为《Java泛型和集合》（Java Generics and Collections），作者为Maurice Naftalin和Philip Wadler。该书详细介绍了Java中的泛型（Generics）特性以及集合（Collections...

    泛型工具类

    ### 泛型工具类在IT行业的应用与理解 在现代软件开发中，泛型作为一种强大的类型...对于任何希望深入了解Java泛型和设计模式的开发者来说，深入研究并掌握此类工具类的实现原理和应用场景都是一项非常有价值的技能。

    Java泛型的继承和实现操作示例

    Java泛型的继承和实现操作示例主要介绍了Java泛型的继承和实现操作，结合实例形式分析了Java泛型类的继承以及泛型接口的实现相关操作技巧。 一、泛型类的继承 在Java中，泛型类可以被继承，子类可以继承父类的泛型...

    java泛型常用通配符实例解析

    java泛型常用通配符实例解析 Java泛型是Java 5中引入的一项新特性，可以用来编写泛型代码，使得代码更加灵活和可重用。其中，通配符是泛型中的一种重要概念，本文将详细介绍Java泛型常用通配符实例解析。 1. 限定...

    Java泛型梳理.

    ### Java泛型梳理 #### 一、泛型概念解析 泛型是一种参数化的类型机制，其核心在于将具体的类型参数化处理。这种处理方式类似于函数中的变量参数——具体类型可以在定义时留空，而在实际使用时传入。这种方式极大...

    Java静态泛型使用方法实例解析

    Java静态泛型使用方法实例解析 Java静态泛型使用方法实例解析主要介绍了Java静态泛型使用方法实例解析，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下。 一...

Magicbox
Global site tag (gtag.js) - Google Analytics