java泛型编程

最新推荐文章于 2020-12-29 16:53:19 发布
最新推荐文章于 2020-12-29 16:53:19 发布
阅读量453 收藏
点赞数
分类专栏： 【java】


java泛型应用是java核心基础之一，从java 5开始引进泛型。如果你曾经使用过java Collection，那你已经算是接触过泛型了。在java Collection里使用泛型是一件很简单的事情，可泛型还具有很多你意想不到的作用。在深入了解泛型之前，首先来了解一下泛型的一些基本概念与原理。

一、java 泛型引入

    java泛型的应用可以提高的代码的复用性，同时泛型提供了类型检查，减少了数据的类型转换，同时保证了类型安全。

关于复用性，个人理解类似于c++中的模板类，对于用样的方法，只是传入的参数不同，此时可以提取成为一个模板类

下面看一下，泛型如何保证了类型安全：

List list = new ArrayList();
list.add("abc");
list.add(new Integer(1));	//可以通过编译
for (Object object : list) {
	System.out.println((String)object);//抛出ClassCastException异常
}

     上面的代码会在运行时抛出ClassCastException，因为它尝试将一个Integer转换为String。

接着，来看一下从java5开始，Collection的用法：

List<String> list = new ArrayList<>();
list.add("abc");
//list.add(new Integer(1));	//编译错误
for (String string : list) {
	System.out.println(string);//无需任何强制类型转换
}

 注意到，List的创建增加了类型参数String，因此只能向list添加String类型对象，添加其他对象会抛出编译异常；同样可以注意到，foreach循环不需要再添加任何强制类型转换，也就移除了运行时的ClassCastException异常。


二、泛型的类与接口


    既然是学泛型，自然就要知道如何去使用泛型定义自己的类和接口。同时为了加深理解泛型的作用，先引进一个原始的类：

public class Gen {
	private Object obj;
	
	public Object getObj() {
		return obj;
	}

	public void setObj(Object obj) {
		this.obj = obj;
	}
	
	public static void main(String[] args) {
		Gen gen = new Gen();
		gen.setObj("abc");
		String str = (String) gen.getObj();//类型转换，可能会引起运行时ClassCastException
	}
}


    原始类的定义，容易引发ClassCastException，和第一大点谈到的类似。现在来看一下泛型类来重新定义Gen — 使用<>指定泛型参数，如下：

public class Gen<T> {
	T obj;

	public T getObj() {
		return obj;
	}

	public void setObj(T obj) {
		this.obj = obj;
	}
	public static void main(String[] args) {
		Gen<String> gen = new Gen<>();
		gen.setObj("abc");
//		gen.setObj(10);		//无法通过编译
		String str = gen.getObj();	//无需类型转换
		//-----------------------------
		Gen gen2 = new Gen();//raw type原始类型
		gen2.setObj("abc");
		gen2.setObj(10);	//可以通过编译，自动装箱将10转化为Integer对象
		Integer num = (Integer) gen2.getObj();//使用了强制类型转换
	}
}

    细心的你会发现在main（）方法里是使用泛型类型Gen<String>,便不再需要强制类型转换，也就移除了运行时的ClassCastException。同时为了区别，在此也定义了一个没有使用泛型类型的gen2，这时，编译器会弹出一个警告“Gen is a raw type,References to generic type Gen<T> should be parameterized”。当我们不提供泛型类型时，会默认使用Object会代替，也是因此这样，gen2可以设置String和Integer类型，不过，我们应尽量去避免这种这种情况的出现，如此，便又需要用到强制类型转换，也伴随着运行时的ClassCastException异常。

    tips：可以使用@SuppressWarnings("rawtypes")来抑制编译器弹出警告。

    接口的泛型应用和类的泛型应用很类似，如下：

public interface List <E> {
	 void add(E x);
	 Iterator<E> iterator();
}

public interface Iterator<E> {
	 E next();
	 boolean hasNext();
}

    类似的，可以将此应用到自定义的接口与类当中。另外再提一下的是，可以使用多个泛型参数来定义接口与类，比如Map<K,V>；同时，泛型类型也可以作为一个参数来用，如下：new HashMap<String, List<String>>()。

总结：其实第一点和第二点所谈的内容是一致，突出了泛型的作用：提高代码的复用性，检查数据输入，减少类型转换


三、泛型的命名规范


    为了更好地去理解泛型，我们也需要去理解java泛型的命名规范。为了与java关键字区别开来，java泛型参数只是使用一个大写字母来定义。各种常用泛型参数的意义如下：

  • E — Element，常用在java Collection里，如：List<E>,Iterator<E>,Set<E>
  • K,V — Key，Value，代表Map的键值对
  • N — Number，数字
  • T — Type，类型，如String，Integer等等
  • S,U,V etc. - 2nd, 3rd, 4th 类型，和T的用法一样

四、泛型的方法与构造函数

    

有时候我们并不希望整个类都被泛型化，这时可以只在某个方法上应用泛型。因为构造函数是一种特殊的方法，因此也可以在构造函数上应用泛型。Demo GenMethod演示了如何在方法上应用泛型和调用泛型方法，

public class GenMethod {
	
	public static <T> void fromArrayToCollection(T[] a,Collection<T> c){
		for (T t : a) {
		  c.add(t);
		}
	}
	
	public static void main(String[] args) {
		Object[] oa = new Object[100];
		Collection<Object> co = new ArrayList<>();
		
		GenMethod.<Object>fromArrayToCollection(oa, co);
	}		
}


    GenMethod 的代码不多，不过需要注意的地方却不少。

第一、定义方法所用的泛型参数需要在修饰符之后添加，如上面的，public static <T>,如果有多个泛型参数，可如此定义<K,V>或者<T1,T2>。

第二，不建议在泛型变量里添加其他类型，如下面的代码，将会引起编译错误（或隐含错误），如下：

public static <T> void fromArrayToCollection(T[] a,Collection<T> c){
		for (T t : a) {
			c.add(t);
			c.add(new Object());	
		}
	}


    第三、看一下泛型方法的调用GenMethod.<Object>fromArrayToCollection(oa, co); 在方法前声明了泛型类型Object。不过因为编译器可以推断这个泛型类型，因此也可以这样写：

    GenMethod.fromArrayToCollection(oa, co)。

    为了加深对编译器推断泛型类型的了解，再看一下如下几个推断：

String[] sa = new String[100];
Collection<String> cs = new ArrayList<String>();

// T 推断为String
fromArrayToCollection(sa, cs);

// T 推断为Object
fromArrayToCollection(sa, co);

Integer[] ia = new Integer[100];
Float[] fa = new Float[100];
Number[] na = new Number[100];
Collection<Number> cn = new ArrayList<Number>();

//T 推断为Number
fromArrayToCollection(ia, cn);

//T 推断为Number
fromArrayToCollection(fa, cn);

//T 推断为Number
fromArrayToCollection(na, cn);

//T 推断为Object
fromArrayToCollection(na, co);

//编译错误，Number与String不能兼容
fromArrayToCollection(na, cs);

 总结：在接口或者是类中设置泛型以后，程序会自动根据传入的类型数据进行T推断。一般而言，都是从低往高推，比如说有String和Object两种，那么T推断的结果就是的Object类型，为的就是更大的包容性。但是有一点还需再次强调，Number和String类型是不兼容的。


五、泛型参数的界限

    有时候，你会希望泛型类型只能是某一部分类型，比如操作数据的时候，你会希望是Number或其子类类型。这个想法其实就是给泛型参数添加一个界限。其定义形式为：

    <T extends BoundingType>

    此定义表示T应该是BoundingType的子类型（subtype）。T和BoundingType可以是类，也可以是接口。另外注意的是，此处的”extends“表示的子类型，不等同于继承。但是一定要注意基础类型数据的extends与泛型的子类型不要混合在一起，具体可以往下找到答案

    Demo：

public class Box<T> {

	private T t;

	public void set(T t) {
		this.t = t;
	}

	public T get() {
		return t;
	}

	public <U extends Number> void inspect(U u) {
		System.out.println("T: " + t.getClass().getName());
		System.out.println("U: " + u.getClass().getName());
	}

	public static void main(String[] args) {
		Box<String> integerBox = new Box<>();
		integerBox.set("abc");	//能通过编译，因为T指定为String类型
//		integerBox.inspect("abc");//不能通过编译，因为U必须是Number类型或其子类
		integerBox.inspect(new Integer(10));
	}
}


    通过Box<T>，了解了如何为泛型参数添加一个界限。可问题也来了，既然限定了泛型参数的界限，那时候可以调用BoundingType（上指Number）的相对应的方法呢？？答案是肯定的，如下：

public class NumberTest<T extends Integer> {
	private T num;
	
	public NumberTest(T num) { this.num = num;}
	
	public boolean isOdd(){
		return num.intValue()%2 == 1;
	}
	
	//....
}

    接着引入下一个问题，如何为泛型参数添加多个限制范围，多重限制范围格式如下：

    <T extends A & B & C> 

类比接口优先：

    一个泛型参数可以有多重限制范围，使用“&”分隔。且限制范围中之多有一个类。如果用一个类作为限定，它必须是限定列表中的第一个。举例如下：

Class A { /* ... */ }
interface B { /* ... */ }
interface C { /* ... */ }

class D <T extends A & B & C> { /* ... */ }


    如果BoundingType不是放在第一位，会产生编译异常：

class D <T extends B & A & C> { /* ... */ }  // 无法通过编译

六、泛型方法与泛参界限的综合

             
泛型与Comparable、Comparator相结合，作为比较对象的补充。因为在基本比较操作符是无法直接应用于对象中的。

    如果说泛型方法是一个有用的工具，那泛参的界限就应该这个工具的灵魂，为这个工具添加了一些“行为准则”。如下：设计一个方法，统计在一个数组里比指定元素大的个数，

public static <T> int countGreater(T[] array,T elem) {
		int count = 0;
		for (T t : array) {
			if (t > elem) {//编译错误
				++count;
			}
		}
		return  count;
	}


    发现上面这个方法无法通过编译，为什么呢？？因为操作符“>”只可以用在基本数据类型（byte，char,short，int，float，long，double，boolean），却不可以用来比较类对象之间的大小（除非实现了Comparable接口）。想要解决这个矛盾，就需要为<T>添加一个界限Comparable<T>:

public interface Comparable<T> {
    public int compareTo(T o);
}

    更改后的代码如下：

public static <T extends Comparable<T>> int countGreater(T[] array,T elem) {
		int count = 0;
		for (T t : array) {
			if (t.compareTo(elem) > 0) {//无编译错误
				++count;
			}
		}
		return  count;
	}

     除了上述方式，也可以选择添加界限Comparator<T,T>,只不过此界限需要两个参数而已，Comparator的定义与使用以前已经谈过，这里不再累述，详情可以点击 这里。


七、泛型、继承与子类型


可以将第七点与第八点进行联合对比，谨记基础类型的继承与泛型类型之间的子类型的区别与联系

    如果两个类之间相互兼容（继承与被继承），那么便可以将一个类对象赋值给另一个类对象，比如：你可以将一个String对象赋值给Object，String是Object的子类，

String someString = new String();
Object someObject = new Object();
someObject = someString;

    如果你熟悉面向对象技术，会知道这是一种“is-a”关系。String是Object的一种对象，所以上面的赋值是可以的。同理，Integer、Double是Number的一类对象，下面的赋值也可以：

public void someMethod(Number n) { /* ... */ }

someMethod(new Integer(10));   // OK
someMethod(new Double(10.1);   // OK

    这种“is-a”关系，同样也是用泛型。如果你将泛参设置Number，那么在随后的调用里，只需要传入一个数据对象就行了，如下：

Box<Number> box = new Box<>();
box.add(new Integer(1));   
box.add(new Double(1.0));


     现在，考虑一下下面这种方法：

public void someMethod(Box<Number> n) { /*.....*/}
 
    这个方法可以接受什么类型的参数呢？？显然，这个方法接受Box<Number>类型的参数？？那又是否可以接受Box<Integer>或者Box<Double>类型的参数的？？答案是 否定的，因为Box<Integer>与Box<Double>都不是Box<Number>的子类。在泛型编程里，这是一个容易混淆的概念，但又必须要懂的原理。如下图：
generics-subtypeRelationship
    从图可以看到，即使Integer是Number的子类，但Box<Integer>并不是Box<Number>的子类。Box<Integer>与Box<Number>的共同父类是Object。换言之，无论类A与类B是否存在关联，MyClass<A>与MyClass<B>都没有任何关联，其共同的父类的是Object。那是否说，泛型就不存在子类呢？？这个留待解决，看完本文便可以知晓。


八、泛型类与子类型


    在谈这一小节时，先回顾一下泛型方法的“extends”含义，泛型的“extends”与继承的“extends”并不一样，泛型的“extends”其后可以是一个类（如T extends Number），同样也可以是一个接口（如T extends List<T>）。泛型的”extends“代表子类型，而不是子类，或许你可以把等其同于”extends（继承）“和”implement的并集。

    在泛型里，也存在子类型，前提是其泛型参数的限制并没有改变，可以认为泛参没有改变，其实就是从原来的类或接口来判断泛型的子类型。为了形象理解，我们已collection类来作个例子，如：ArrayList<E> implementList<E>，而List<E> extends  Collection<E>，那么ArrayList<String>就是List<String>的子类型，而List<String>则是Collection<String>,其关系图如下：

generics-sampleHierarchy

    深入一点来谈，现在假设需要定义自己的List接口 — PayLoadList，其定义如下：

interface PayloadList<E,P> extends List<E> {
  void setPayload(int index, P val);
  //...
}

    如上,则下面的样例都是List<String>子类型，：

PayloadList<String,String>
PayloadList<String,Integer>
PayloadList<String,Exception>
  如图：
generics-payloadListHierarchy
 
 
参考链接：http://peiquan.blog.51cto.com/7518552/1302898
 


                

        

        

    

  


    

      

        

            

              
                
                  circujoker_06
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
JAVA泛型教程(帮你解决学习泛型的苦恼)

				
			

			

				

					05-11
				

			

		

		

			
				
JAVA泛型教程(帮你解决学习泛型的苦恼).

Java 泛型编程可能会碰到很多问题，本教程可能会对你有帮助哦。

			
		

	



                

            
              



	

		

			

				
					
Java中的泛型编程

				
			

			

				

					陈九龙的专栏
				

				

					01-08
					
					506
					
				

			

		

		

			
				
引言

什么是泛型？

泛型的意思是 类型参数化。

到底什么是类型参数化呢？通过这一节内容，我们希望大家能够彻底弄懂什么是泛型，以及如何在开发中使用泛型。



Java泛型应用是java核心基础之一，从java5开始引入泛型概念。如果你曾经使用过java中的collection相关的类，那么就算你已经接触过泛型了。在java的Collection中使用泛型是一件很简单的事情，可泛型还具有许...

			
		

	



              


  
              

                


	

		

			

				
					
java习题-集合框架-泛型

				
			

			

				

					刘望的博客
				

				

					01-17
					
					361
					
				

			

		

		

			
				

			集合框架
一 去除List集合中的重复元素。
思路：　　
1，先创建一个临时容器。用于存储唯一性的元素。2，遍历原容器，将遍历到的元素到临时容器中去判断，是否存在。3，如果存在，不存储到临时容器，如果不存在，存储到临时容器中。4，遍历结束后，临时容器中存储的就是唯一性的元素。5，如果需要将这些唯一性的元素保留到原容器中，只要将原容器清空，将临时容器中的元素添加到原容器中即可。代码实...

			
		

	





	

		

			

				
					
Java集合框架上机练习题（泛型1）

				
			

			

				

					sunnnnh的博客
				

				

					12-01
					
					2845
					
				

			

		

		

			
				
1 编写一个Book类，该类至少有name和price两个属性。该类要实现Comarable接口，在接口的compareTo（）方法中规定两个Book类实例的大小关系为二者的price属性的大小关系。在主函数中，选择合适的集合类型存放Book类的若干个对象，然后创建一个新的Book类的对象，并检查该对象与集合中的哪些对象相等。查询结果如下图： 
 
（1）代码import java.util.*;/

			
		

	



		

			
		



	

		

			

				
					
Java泛型编程最全总结

				
			

			

				

					04-05
				

			

		

		

			
				
Java泛型是Java编程语言中的一个关键特性，它在2004年随着...总的来说，Java泛型编程是一种强大的工具，能够提升代码的清晰度、安全性和可维护性。通过深入学习和实践，我们可以更高效地利用泛型来设计和实现复杂系统。

			
		

	





	

		

			

				
					
SUN公司Java泛型编程文档

				
			

			

				

					09-20
				

			

		

		

			
				
SUN公司的Java泛型编程文档，包括英文原版和网络翻译版，为开发者提供了深入理解和熟练运用泛型的重要资源。  首先，泛型的基本概念是允许在定义类、接口和方法时使用类型参数，这样就可以在编译时检查类型安全，...

			
		

	





	

		

			

				
					
Java泛型编程起始篇

				
			

			

				

					Free Square
				

				

					03-30
					
					342
					
				

			

		

		

			
				
　　JDK1.5 令我们期待很久,可是当他发布的时候却更换版本号为5.0。这说明Java已经有大幅度的变化。本文将讲解JDK5.0支持的新功能-----Java的泛型。

[color=darkblue][size=medium][b]1、Java泛型[/b][/size][/color] 
　　其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的metho...

			
		

	





	

		

			

				
					
Java面向对象程序设计--泛型编程

				
			

			

				

					weixin_30502157的博客
				

				

					08-04
					
					181
					
				

			

		

		

			
				
1. 为何要进行泛型编程？
泛型变成为不同类型集合提供相同的代码！省去了为不同类型而设计不同代码的麻烦！

2. 一个简单泛型类的定义:


 1 public class PairTest1 
 2 {
 3     public static void main(String[] args) 
 4     {
 5         String[] arr = {"Th...

			
		

	





	

		

			

				
					
JAVA泛型编程全面总结

				
			

			

				

					__七把刀__
				

				

					05-14
					
					3679
					
				

			

		

		

			
				
JAVA泛型编程总结
                                                                                                                                                               ——by书生
1介绍
Java泛型编程是JDK1.5版

			
		

	





	

		

			

				
					
Java泛型编程

				
			

			

				

					someby的博客
				

				

					10-04
					
					1245
					
				

			

		

		

			
				

    1.所谓泛型（Grenerics）是指在对象建立的时候不指定具体的类型而是在申明和实例化对象的时候指定具体的类型；
    2.需要泛型最重的因素有两点：第一,包容各种类型的变化，第二，框架基于泛型能够“容易”，例如hadoop和Spark都大量使用了泛型
    3.泛型类：
 


     public class JavaGenerics {
        public sta...

			
		

	





	

		

			

				
					
java 泛型编程（一）

				
			

			

				

					weixin_34353714的博客
				

				

					09-27
					
					254
					
				

			

		

		

			
				
Technorati 标记: java,泛型,generic   java泛型应用是java核心基础之一，从java 5开始引进泛型。如果你曾经使用过java Collection，那你已经算是接触过泛型了。在java Collection里使用泛型是一件很简单的事情，可泛型还具有很多你意想不到的作用。在深入了解泛型之前，首先来了解一下泛型的一些基本概念与原理。  一、...

			
		

	





	

		

			

				
					
Java之泛型编程

				
			

			

				

					筚路蓝缕 以启山林
				

				

					05-09
					
					428
					
				

			

		

		

			
				
1.概念
　　泛型就是参数化类型。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。
2.案例
1）先看下面案例：
//不适用泛型编程  
Apple app0=new Apple();  
Apple app1=new Apple();  
   
List li = new ArrayList();  
li.add(app0);  

			
		

	





	

		

			

				
					
JAVA如何使用泛型编程

				
			

			

				

					weixin_33843409的博客
				

				

					11-19
					
					134
					
				

			

		

		

			
				
泛型编程在BaseDAO中的使用，待续。。。。。。
				
转载于:https://blog.51cto.com/6221123/1063785

			
		

	





	

		

			

				
					
Java面向对象编程——泛型

				
			

			

				

					qq_25036849的博客
				

				

					12-29
					
					384
					
				

			

		

		

			
				
目录

一、定义一个Point泛型，如以下程序：

实例化Point类，如以下程序：

关于默认的泛型类型：由于泛型是JDK1.5之后的产物，但是在此之前有不少的内置程序类或者是接口广泛应用在项目开发之中，为保证这些类或接口在追加了泛型之后，原始的类依然可以使用，所以如果没有设置泛型的类型，自动将使用Object作为类型以保证程序的正常执行，但是在编译中会出现警告。

泛型的使用注意点：1.泛型之中只允许设置引用类型，如果现在要操作的基本类型，必须使用包装类；2.从JDK1.7开始，泛型对象实例化可以简化为

			
		

	





	

		

			

				
					
Java泛型编程详解

				
			

			

				

					
				

			

		

		

			
				
"Java泛型编程基础"  Java泛型是自JDK 1.5版本引入的一种强大的编程特性，它允许在定义类、接口和方法时指定类型参数，从而提高了代码的类型安全性和重用性。泛型的主要目标是增强类型检查，避免在运行时进行强制...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值