java泛型和注解的用法，请问有人能详细说一下嘛？

泛型的作用是指定集合里面所能存放的数据类型。
比如你定义一个用户信息集合，里面用来存放用户对象的。不允许存放其他类型的数据，则可以定义一个list集合，泛型里面的类型为用户对象<User>，这样从里面取出来的对象就是一个User的对象了。
注解的使用的地方一般在类的头部、方法的头部、方法体里面使用，分别用来描述：
类的创建日期，作者，修改记录，类的描述等信息；
方法的功能描述，参数描述等；
代码块的功能描述，变量的作用记录等。

这是在各种Java泛型面试中，一开场你就会被问到的问题中的一个，主要集中在初级和中级面试中：
1：什么是泛型？
泛型就是广泛的类型，也是一种数据类型，而这种数据类型可以是任意类型，编写过程中当中不能确定类型，创建对象时必须指定具体类型，不指定也可以，但是会出现一些错误。
泛型是编译器行为，只能在编译期有效，如果能够跨过编译器，那么泛型就没有任何意义了。
2、泛型类
怎么定义泛型类？
在类后面加<>，<>中可以编写任意长度任意字符，不能是数值。（一般用26个大写英文字母表示）
泛型类 <具体类型> 变量名 = new 泛型类<>();
3怎么使用泛型
有以下几种使用场景以及放在那种位置
泛型只能定义引用数据类型，而不能使用基本数据类型
泛型类、泛型方法、泛型接口、泛型通配符
例如:作用在类上时( public class Animal <E> { E pet; } ) , 泛型跟在类后边,可以指定用了泛型的类内部的 pet 的类型。
作用在对象上时( Animal<Dog> str = new Animal<Dog>(); ) , 泛型跟在类后边 , 使得对象类的的 pet 属性为 Dog类型。

数组没有泛型的貌似，只有集合有泛型的：List<T>和Dictionary<K,V>。
ArrayList还是数组没错，他和上两个泛型集合的区别在于，他属于弱类型集合而泛型集合属于强类型集合，懂的人可能已经知道我的意思了，就是ArrayList中存放的类型都是Object的，虽然方便，但也可能造成隐患，比如存入存取一个不同类型的值就会发生类型错误，而泛型集合是在定义时就确定类型的，List<这里定义你期望存入的类型>，这样就限制了List存取的类型，极大的避免的出错的可能性。这也是强类型集合的优势，从你新建一个类的命名空间来看，微软已经默认帮你引入了SystemCollectionGeneric，这说明微软也是希望我们多多使用泛型集合的。发言完毕，有遗漏错误请高手们指正，谢谢！祝楼主成功！

我可以给你demo，你可以参考

接口你可以自己写

package comshoppingb2bdaoimpl;

import javaioSerializable;

import javalangreflectField;

import javautilCollection;

import javautilList;

import javautilMap;

import javaxannotationResource;

import javaxpersistenceTable;

import orgapachelog4jLogger;

import orghibernateHibernate;

import orghibernateQuery;

import orghibernateSQLQuery;

import orghibernateSession;

import orghibernateSessionFactory;

import orghibernatetransformTransformers;

import orgspringframeworkbeansfactoryannotationAutowired;

import orgspringframeworkstereotypeRepository;

import comshoppingb2bdaoISuperDao;

@Repository("superDao")

public class SuperDaoImpl implements ISuperDao{

@Resource

private SessionFactory hibernateSessionFactory;

public SessionFactory getHibernateSessionFactory() {

return hibernateSessionFactory;

}

public void setHibernateSessionFactory(SessionFactory hibernateSessionFactory) {

thishibernateSessionFactory = hibernateSessionFactory;

}

private Logger logger = LoggergetLogger(thisgetClass());

private Session getCurrentSession() {

return thishibernateSessionFactorygetCurrentSession();

}

@Override

public <T> T get(Class<T> clazz, Serializable id) {

return (T)thisgetCurrentSession()get(clazz, id);

}

@Override

public <T> T getSql(String sql, Map<String, Object> params, Class<T> po) {

SQLQuery q = thisgetCurrentSession()createSQLQuery(sql);

/

say:

从数据库查出来的数据类型给po，如果要自定义，那么需要扩展addScalar

默认情况：数据库字段类型是什么类型，返回的po也是什么类型。移植性不好

可扩展

/

if(po != null){

qsetResultTransformer(TransformersaliasToBean(po));

}else{

qsetResultTransformer(TransformersALIAS_TO_ENTITY_MAP);

}

if(params != null && !paramsisEmpty()){

for (String k : paramskeySet()) {

Object v = paramsget(k);

if(v != null){

if(v instanceof Object[]){

qsetParameterList(k, (Object[])v);

}else if(v instanceof Collection<>){

qsetParameterList(k, (Collection<>)v);

}else{

qsetParameter(k, v);

};

}

}

}

List<T>  list = qlist();

return list == null || listisEmpty() null:listget(0);

}

@Override

public Serializable save(Object entity) {

return thisgetCurrentSession()save(entity);

}

@Override

public boolean update(Object entity) {

boolean result = false;

try {

thisgetCurrentSession()update(entity);

result = true;

} catch (Exception e) {

result = false;

}

return result;

}

@Override

public boolean updateSql(String sql,Map<String, Object> params) {

SQLQuery q = thisgetCurrentSession()createSQLQuery(sql);

if(params != null && !paramsisEmpty()){

for (String k : paramskeySet()) {

Object v = paramsget(k);

if(v != null){

if(v instanceof Object[]){

qsetParameterList(k, (Object[])v);

}else if(v instanceof Collection<>){

qsetParameterList(k, (Collection<>)v);

}else{

qsetParameter(k, v);

};

}

}

}

return qexecuteUpdate() == 0 false :true;

}

@Override

public boolean delete(Object entity) {

boolean result = false;

try {

thisgetCurrentSession()delete(entity);

result = true;

} catch (Exception e) {

result = false;

}

return result;

}

@Override

public <T> boolean deleteSql(Class<T> clazz,Serializable id) {

boolean result = false;

try {

Table table = (Table)clazzgetAnnotation(Tableclass);

if(table != null){

String tableName = tablename();

thisgetCurrentSession()

createSQLQuery("delete from :tableName where id = :id")

setParameter("tableName", tableName)

setParameter("id", id)

executeUpdate();

}

result = true;

} catch (Exception e) {

result = false;

}

return result;

}

@Override

public <T> List<T> queryList(String sql, Map<String, Object> params, Class<T> po) {

SQLQuery q = thisgetCurrentSession()createSQLQuery(sql);

/

say:

从数据库查出来的数据类型给po，如果要自定义，那么需要扩展addScalar

默认情况：数据库字段类型是什么类型，返回的po也是什么类型。移植性不好

可扩展

/

if(po != null){

qsetResultTransformer(TransformersaliasToBean(po));

}else{

qsetResultTransformer(TransformersALIAS_TO_ENTITY_MAP);

}

if(params != null && !paramsisEmpty()){

for (String k : paramskeySet()) {

Object v = paramsget(k);

if(v != null){

if(v instanceof Object[]){

qsetParameterList(k, (Object[])v);

}else if(v instanceof Collection<>){

qsetParameterList(k, (Collection<>)v);

}else{

qsetParameter(k, v);

}

}

}

}

List<T>  list = qlist();

return list == null || listisEmpty() null:list;

}

@Override

public <T> List<T> queryList(String sql, Map<String, Object> params, int firstResult, int maxResults, Class<T> po) {

SQLQuery query = thisgetCurrentSession()createSQLQuery(sql);

/

say:

从数据库查出来的数据类型给po，如果要自定义数据类型，那么需要扩展addScalar

默认情况：数据库字段类型是什么类型，返回的po也是什么类型。移植性不好

可扩展

/

if(po != null){

querysetResultTransformer(TransformersaliasToBean(po))setFirstResult(firstResult)setMaxResults(maxResults);

}else{

querysetResultTransformer(TransformersALIAS_TO_ENTITY_MAP)setFirstResult(firstResult)setMaxResults(maxResults);

}

//thisaddScalarsToString(query, po)setFirstResult(firstResult)setMaxResults(maxResults);//test

if(params != null && !paramsisEmpty()){

for (String k : paramskeySet()) {

Object v = paramsget(k);

if(v != null){

if(v instanceof Object[]){

querysetParameterList(k, (Object[])v);

}else if(v instanceof Collection<>){

querysetParameterList(k, (Collection<>)v);

}else{

querysetParameter(k, v);

}

}

}

}

List<T>  list = querylist();

return list == null || listisEmpty() null:list;

}

@Override

public <T> Serializable queryCount(String sql, Map<String, Object> params) {

Query query = thisgetCurrentSession()createSQLQuery(sql);

if(params != null && !paramsisEmpty()){

for (String k : paramskeySet()) {

Object v = paramsget(k);

if(v != null){

if(v instanceof Object[]){

querysetParameterList(k, (Object[])v);

}else if(v instanceof Collection<>){

querysetParameterList(k, (Collection<>)v);

}else{

querysetParameter(k, v);

}

}

}

}

return IntegerparseInt(queryuniqueResult()toString());

}

/

扩展

默认将class的属性类型转换为hibernate所对应的的类型<br/>

如果严格的话请使用TransformersaliasToBean(Tclass)<br/>

对应表如下：

未实现

@param query

@param cls

@return

/

private  <T> Query addScalarsToCustom(SQLQuery query,Class<T> cls){

Field[] fields = clsgetDeclaredFields();

for(Field item:fields){

////Systemoutprintln(itemgetName() + ":" + itemgetGenericType());

//该接口需要判断，返回的属性类型，然后转换为hibernate语法

//Systemoutprintln(itemgetName() + ":" + itemgetGenericType());

//该接口需要判断，返回的属性类型，然后转换为hibernate语法

if("class javamathBigInteger"equals(itemgetGenericType()toString())){

//Systemoutprintln(clsgetName() +":"+itemgetName()  + "    ||==int");

}else if("class javalangString"equals(itemgetGenericType()toString())){

//Systemoutprintln(clsgetName() +":"+itemgetName()  +  "    ||==String");

}else if("class javamathBigDecimal"equals(itemgetGenericType()toString())){

//Systemoutprintln(clsgetName() +":"+itemgetName()  +  "    ||==String");

}else{

//Systemoutprintln(clsgetName() +":"+itemgetName()  +  "    ||==未匹配类型");

}

}

return null;

}

}

是的

上面是ArrayList的get方法，返回时是强转了

如果不指定泛型就是Object类型的，如果指定了泛型，类型不对的话你put都put不进去的

public static string Serialize<T>(T obj)
{
XmlSerializer xs = null;
StringWriter sw = null;
try
{
xs = new XmlSerializer(typeof(T));
sw = new StringWriter();
xsSerialize(sw, obj);
swFlush();
return swToString();
}
catch (Exception err)
{
throw err;
}
finally
{
if (sw != null)
{
swClose();
swDispose();
}
}
}
public static T Deserialize<T>(string xml)
{
if (stringIsNullOrEmpty(xml))
return default(T);
XmlSerializer xs = null;
StringReader sr = null;
try
{
xs = new XmlSerializer(typeof(T));
sr = new StringReader(xml);
return (T)xsDeserialize(sr);
}
catch (Exception err)
{
throw err;
}
finally
{
if (sr != null)
{
srClose();
srDispose();
}
}
}
序列化与反序列化的代码，可以将你的泛型列表中的对象序列化为XML，前提是你的泛型类为Serialzable

public class Test {
public static void main(String[] args){
List<A> list = new ArrayList<A>();
A a1 = new A("101","01","122222222","上海");
A a2 = new A("102","02","133333333","南京");
A a3 = new A("103","03","142333223","上海");
A a4 = new A("104","04","125555552","上海");
listadd(a1);
listadd(a2);
listadd(a3);
listadd(a4);
}
}
class A{
private String ID;
private String num;
private String iphone;
private String address;
public String getID() {
return ID;
}
public void setID(String iD) {
ID = iD;
}
public String getNum() {
return num;
}
public void setNum(String num) {
thisnum = num;
}
public String getIphone() {
return iphone;
}
public void setIphone(String iphone) {
thisiphone = iphone;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
thisaddress = address;
}
public A(String id,String num,String iphone,String address){
thisID = id;
thisnum = num;
thisiphone = iphone;
thisaddress=address;
}
}
我写了个例子，应该能明白了吧？也就是吧你集合的数据封装成一个对象，这样泛型的时候就可以泛型成这个对象了。A也就是你说的T 这样就是你要的把数据封装成了A类对象
希望能帮到你!

---