Java泛型在实际开发中的一点运用总结（随笔）

泛型的概念：

泛型是java中的一种类型，在java中所有的类型都可以用Type来代替；泛型是JDK 1.5以后的的一项新特性，它的本质是参数化类型（Parameterized Type）的应用，也就是说所操作的数据类型被指定为一个参数，在用到的时候在指定具体的类型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。在Java编程思想中解释道：泛型的主要目的之一就是指定容器要持有什么类型的对象，而且由我们的编译器来保证类型的正确性。

关于泛型类（Generic Type）的语法定义其实也非常的简单，主要是在类名之后加上一个“<>”，然后在这个“<>”里面加上一个类型参数。

public class GenericTypeDemo<T> {
    // 定义该泛型
     private T value;
 
     public T getValue() {
         return value;
     }
 
     public void setValue(T value) {
         this.value = value;
     }
}

注意：泛型所带的类型参数不仅仅局限于一个，而是可以携带多个类型参数的，比如：

public class GenericTypeDemo<T,U,...>{
    ......
}

Parameterized Type 该类型就是泛型

public interface ParameterizedType extends Type {   
	//得到实际类型的参数
	Type[] getActualTypeArguments();
	//得到rawType
	Type getRawType();
	//得到自己的类型
	Type getOwnerType();
}

理解ActualTypeArguments、RawType

public class PersonService<E>{
	        
}

   上述的class由两部分组成
   PersonService-------> rawType
   <E> --------------------> 代表形参
   getActualTypeArguments() 该方法告诉我们<E>的实际类型；在编译阶段，把实参传递给形参。

在泛型中传递参数的方式

public class ArrayList<E>{
		
}

声明了一个泛型
为ArrayList创建对象

ArrayList<Person> pList = new ArrayList<Person>();

public interface PersonDao<E>{
		
}

public interface P<E> extends PersonDao<E>{
		   
}

public class PersonDaoImpl implements P<Person>{
		   
}

例如ArrayList：
ArrayList<Person>-->ArrayList<E>-->【AbstractList<E> | List<E> 】-->AbstractCollection<E>-->Collection<E>

实际的应用：重构dao

示例：1、cn/itcast/shoa/dao/base/BaseDao

package cn.itcast.shoa.dao.base;

import java.io.Serializable;
import java.util.Collection;

public interface BaseDao<E>{
	/**
	 * 得到E代表的所有的实体对象
	 * @return
	 */
	public Collection<E> getAllEntry();
	/**
	 * Serializable该类型可以接受所有的基本类型和String类型
	 * @param id
	 * @return
	 */
	public E getEntryById(Serializable id);
	
	public void saveEntry(E e);
	
	public void deleteEntry(Serializable id);
	
	public void updateEntry(E e);
}

2、实现类:cn/itcast/shoa/dao/base/impl/BaseDaoImpl

package cn.itcast.shoa.dao.base.impl;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.HashSet;

import javax.annotation.Resource;

import org.hibernate.metadata.ClassMetadata;
import org.springframework.orm.hibernate3.HibernateTemplate;

import cn.itcast.shoa.dao.base.BaseDao;

public class BaseDaoImpl<E> implements BaseDao<E>{
	
	private Class classt;
	
	public BaseDaoImpl(){
		/**
		 * 1、this可以代表子类或者本类
		 * 2、不能把BaseDaoImpl在spring容器中实例化，因为如果在spring容器中实例化，则就不是泛型了
		 * 3、所以根据以上两点可以得出this应该代表子类
		 * 4、this.getClass().getGenericSuperclass()代表当前的类：就是泛型
		 * 5、注意：不能把BaseDaoImpl让spring容器实例化
		 */
		ParameterizedType type = (ParameterizedType)this.getClass().getGenericSuperclass();
		//因为将来E代表的是某一个持久化类，而该类型是class
		this.classt = (Class)type.getActualTypeArguments()[0];
	}
	
	@Resource(name="hibernateTemplate")
	public HibernateTemplate hibernateTemplate;

	@Override
	public Collection<E> getAllEntry() {
		// TODO Auto-generated method stub
		return this.hibernateTemplate.find("from "+this.classt.getName());
	}
	@Override
	public E getEntryById(Serializable id) {
		// TODO Auto-generated method stub
		/**
		 * classMetadata是持久化类的数据字典
		 */
		ClassMetadata classMetadata =  this.hibernateTemplate.getSessionFactory().getClassMetadata(this.classt);
		return (E)this.hibernateTemplate.
					find("from "+this.classt.getName()
							+
							" where "
							+classMetadata.getIdentifierPropertyName()
							+"=?",
							id).get(0);
	}
	@Override
	public void saveEntry(E e) {
		// TODO Auto-generated method stub
		this.hibernateTemplate.save(e);
	}
	@Override
	public void deleteEntry(Serializable id) {
		// TODO Auto-generated method stub
		E e = this.getEntryById(id);
		this.hibernateTemplate.delete(e);
	}
	@Override
	public void updateEntry(E e) {
		// TODO Auto-generated method stub
		this.hibernateTemplate.update(e);
	}
}

以上是针对之前的项目做的一点知识补充，有关Java泛型的学习，这里有一篇博客值得参考：http://www.importnew.com/24029.html