java 泛型学习笔记

最新推荐文章于 2025-03-26 20:26:07 发布

lkf520java

最新推荐文章于 2025-03-26 20:26:07 发布

阅读量129

点赞数

CC 4.0 BY-SA版权

分类专栏： Java开发文章标签： Java

本文链接：https://blog.youkuaiyun.com/lkf520java/article/details/83683201

Java开发专栏收录该内容

13 篇文章

订阅专栏

java泛型从JDK1.5开始出来的，虽然自己平时也有用到，但是一直没有全面的学习，今天在看myibatis3.0.1源码时，看到多处用到泛型设计，所以自己把泛型学习了下。

什么是泛型？

在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点就是被Object引用对象被“上塑”造型，对象的具体类型信息被丢失，这样当我们要使用该类型时要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

　　泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

泛型使用的规则和限制

泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
泛型的类型参数可以有多个。
泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上称为“有界类型”。
泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String");

泛型的基本使用

eg1:使用了泛型

package com.kyle.Generics.ch01;


/**
 * 定义泛型类型
 * @author kyle
 *
 * @param <T>
 */
public class SimpleDemo1<T> {
	private T ob;//定义泛型成员变量
	
    public T getOb() {
		return ob;
	}

	public void setOb(T ob) {
		this.ob = ob;
	}

	public SimpleDemo1(T ob){
    	
    	this.ob=ob;
    }
	
	public  void showType(){
		
		System.out.println("T的实际类型是："+ob.getClass().getName());
	}
    
	public static void main(String args[]){
		//定义泛型SimpleDemo的一 个Integer版本
		SimpleDemo1<Integer> intObj=new SimpleDemo1<Integer>(88);
		//不需要转换可以得到ob的具体类型
		Integer  intValue=intObj.getOb();
		intObj.showType();
		
		
		//定义泛型SimpleDemo的一个String版本
		
		SimpleDemo1<String> strObj=new SimpleDemo1<String>("Hello world");
		//不需要转换可以得到ob的具体类型
		String strValue=strObj.getOb();
		strObj.showType();
		String str=strObj.getOb();
		System.out.println("ob is vlaue :"+str);
		
		
	}
    

}

eg2:没有使用泛型实现

package com.kyle.Generics.ch01;

/**
 * 没有使用泛型
 * @author kyle
 *
 */
public class SimpleDemo2{
	
	private Object ob; //定义一个通用类型成员 
	
	public SimpleDemo2(Object ob) {
		this.ob = ob; 
	} 
	
	public Object getOb() {
		return ob;
	}

	public void setOb(Object ob) {
		this.ob = ob;
	}

	
	
    public  void showType(){
		
		System.out.println("Object的实际类型是："+ob.getClass().getName());
	}
    
    public  static void main(String args[]){
    	SimpleDemo2  intObj=new  SimpleDemo2(new Integer(88));
               int intValue=(Integer)intObj; //强制转换成Integer
    	intObj.showType();


    	SimpleDemo2  strObj=new SimpleDemo2(new String("Hello Gen2"));
               String  strValue=(String)strObj;//强制转换成String 
    	strObj.showType();
    	
    }

}

通过上面两个DEMO的比较，我们可以很直接的看到泛型给我们带来的易用性。在这里DEMO1中我们可以简单的假想为T就是我们构造对象时动态传入的字符串，例如

SimpleDemo1<Integer> intObj=new SimpleDemo1<Integer>(88)传入的是Integer，那么private T ob 就变成private Integer ob,SimpleDemo1<String> strObj=new SimpleDemo1<String>("Hello world")传入的String,那么private T ob就变成private String ob。T就相当于是一个类型变量，编译器在编译时把该变量替换成我们传入的类型。

泛型的高级应用

1.限制泛型的可用类型

class GenericsFoo<T extends Collection>，这样的泛型T只能是Collection接口的实现类或者子接口，传入非Collection接口则会编译报错

注意：<T extends Collection>这里的限定使用关键字extends ，实际T的类型Collection可以是实现Collection接口的类也可以是继承了Collection接口， extends只是起一个限定作用，而非继承的意义。

eg:

package com.kyle.Generics.ch03;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;

public class CollectionGenFoo <T extends Collection>{
	
	private T x;
	
   public CollectionGenFoo( T x){
    	
    	this.x=x;
    	
    }
	
    public T getX() {
		return x;
	}

	public void setX(T x) {
		this.x = x;
	}
	
	public static void main(String args[]){
		
		/**1
   		* 定义CollectionGenFoo的泛型为ArrayList
   		* 即定义listFoo这个引用只接受泛型为
  		* ArrayList类型的实例
   		* 我们构造函数传入new ArrayList()传入的正是ArrayList类型
   		*/



   		CollectionGenFoo<ArrayList> listFoo = null;
  		 listFoo=new CollectionGenFoo<ArrayList>(new ArrayList());
                                 listFoo.getX();//该方法返回的对象为ArryList类型
 		 /**2
  		 * 定义CollectionGenFoo的泛型为Collection
  		 * 即定义listFoo这个引用只接受泛型为
   		 * Collection类型的实例
   		 *  我们构造函数传入new ArrayList()是Collection接口的实现类
   		 *  也是Collection类型的
   		*/



   		CollectionGenFoo<Collection> listFoo2 = null;
   		listFoo2=new CollectionGenFoo<Collection>(new ArrayList());
                              	listFoo2.getX();//该方法返回的对象为Collection类型		
		  /**3
    		  * 下面的报错
    		  *CollectionGenFoo<String>中的类型必须是 Collection类型的
     		  */



    		 //CollectionGenFoo<String> listFoo3=null;
   
   
    		/**4
    		* 下面的报错，因为声明的引用已经定义参数必须为Collection类型的
    		* 那么new CollectionGenFoo<ArrayList>传入的类型必须与引用一致
    		* 即T这个类型变量不能同时为两个值
    		*/



       		//CollectionGenFoo<Collection> listFoo4 = null;
   		//listFoo4=new CollectionGenFoo<ArrayList>(new ArrayList());
	}

	
}

通过这个例子，我们应该仔细对比1，2，3，4这三种声明方式，体会泛型的含义:

1.从1，2，3可以看出使用“有界泛型”<T extends SuperClass>这种声明方式时，类型参数T必须是SuperClass的子类或者SuperClass类型。如果不是则会在编译时报：

Bound mismatch: The type String is not a valid substitute for the bounded parameter <T extends Collection> of the type CollectionGenFoo<T> 这个错误。

2.从4可以看出<T extends SuperClass>中的T虽然可以是任意SuperClass的任意类型，但是一旦引用指定具体类型以后，实例的泛型类型必须和引用是一致，在这里并不存在什么父子关系，即类型T不能前后赋两个不同值。

2.通配符泛型

在上面的例子中对于当我们声明某一种特定泛型类型的引用时，那么对应的实例的泛型类型就必须和引用的泛型类型一样，这样当我们有多个泛型类型子类实例时，我们就必须声明多个不同的引用，也就是我们的引用被具体化了，换句话说，我们的泛型被具体化了，所以才导致我们的引用也被具体化了。那么如何让一个含有泛型的引用

也可以接受任意的实例类型？

eg: 继续上面的DEMO，在main方法中加入如下声明方式

                /**5
		 * 使用通配符CollectionGenFoo<? extends Collection> 
		 * listFoo5这个引用接受所有Collection类型 的实例
		 * 
		 */

		CollectionGenFoo<? extends Collection> listFoo5 = null;
		listFoo5=new CollectionGenFoo<ArrayList>(new ArrayList());
		listFoo5=new CollectionGenFoo<LinkedList>(new LinkedList());
		listFoo5.getX();//该方法返回值的类型为Collection类型
		
		
		/**
		 * CollectionGenFoo<?>方式声明引用时
		 * listFoo5这个引用接受所有Collection类型的实例
		 * 
		 */
		CollectionGenFoo<?> listFoo6 = null;
		listFoo6=new CollectionGenFoo<ArrayList>(new ArrayList());
		listFoo6=new CollectionGenFoo<LinkedList>(new LinkedList());
		listFoo6.getX();//该方法返回值的类型为Object类型
     
		/*
		 * 下面的报错：
		 * 虽然通配符?可以是任意类型，但是也是有限制的
		 * 必须是Collection的子类
		 */
                /*报错：
                  *Bound mismatch: The type String is not a valid substitute for the bounded parameter
                  *<T extends Collection> of the type CollectionGenFoo<T>
                  */

  		//listFoo6=new CollectionGenFoo<String>(new String("test"));

总结：

1. 从5中可以看出当我们使用CollectionGenFoo<? extends SuperClass>的通配符方式声明对象引用时，虽然引用可以接受不同泛型的对象实例，但是该实例泛型的具体类型已经丢失，全部被上溯成为SuperClass类型

2.从6中可以看出当我们使用CollectionGenFoo<?>的通配符方式声明对象引用时，虽然引用可以接受不同泛型的对象实例，但是该实例的泛型的具体类型已经丢失，全部被上溯成为Object类型

3.5，6中的 new的实例中的泛型必须是SuperClass的子类或者SuperClass类型。

4.通配符泛型不单可以向下限制，还可以向上限制，如：<? Super ArrayList>,表示类型只能接受ArrayList类型以及其上层父类类型，如：List,Collection

3.泛型方法

未完。。。

泛型在设计的使用场景