Java泛型理解

女爷i 2022-08-13 17:34 228阅读 0赞

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

泛型的用法核心：实质是将具有重复逻辑或者类似功能类集合进行逻辑块的抽取，具体办法是创建一个包装类，将该集合的类作为该类中的一个属性或者暴露一个获取的接口方法，而这个类的属性的类型是自定义的，而包装类中的逻辑块即为该类集合所共有逻辑。注意，若要使用该集合类所具有的方法，无论集合中的类是以属性还是接口的形式提供，都是要在实例化改包装类的时候要初始化。需要提供对应的初始化方法，若该类为包装类属性，则提供构造函数，若为接口方法，则包装类的该方法为虚方法，且包装类为虚函数。以便使用的时候可以自定义初始化。

下述例子即为接口实例化泛型类对象的例子

public abstract class AbstractCommonQuartzJob<T extends IQuartzCommonSIDSV> implements Job  \{  
  
private static Logger logger = LoggerFactory.getLogger(AbstractCommonQuartzJob.class);  
  
/\*\*  
\* 获取执行日志；  
\* @return  
\*   
\*/  
abstract protected Logger getLogger();  
  
  
@Override  
public void execute(JobExecutionContext context) throws JobExecutionException \{  
JobDataMap jobDataMap = null;  
String provinceCode = null ;  
Map<String,String> extendParams =  new java.util.HashMap<>();  
if(context == null)\{  
  
\} else \{  
jobDataMap = context.getJobDetail().getJobDataMap();  
//获取设置的省分编码；  
provinceCode = jobDataMap.getString(JobConstants.JobParam\_ProvinceCode);  
for(String key : jobDataMap.keySet())\{  
if( jobDataMap.get(key) != null)\{  
extendParams.put(key,jobDataMap.getString(key));  
\}  
\}  
\}  
  
IQuartzCommonSIDSV sv = this.getService();  
  
try\{  
if(StringUtils.isEmpty(provinceCode))\{  
this.getLogger().info("定时任务开始，获取的省分编码为空,执行所有省分处理");  
sv.dealQuartz(extendParams);  
\} else \{  
this.getLogger().info("定时任务开始，获取的省分编码列表为："+provinceCode);  
String\[\] provinceCodes = provinceCode.split(JobConstants.JobParam\_SPLIT);  
sv.dealQuartzByProvinceCodes(provinceCodes,extendParams);  
\}  
\} catch(Exception e)\{  
this.getLogger().error("定时任务失败!", e);  
throw new JobExecutionException(e);  
\} finally \{  
this.getLogger().info("定时任务结束!");  
\}  
  
\}  
  
/\*\*  
\* 获取 对应的服务；  
\* @return  
\*   
\*/  
abstract protected T getService();  
  
  
\}

还有一种泛型使用场景是方法泛型，此类泛型的运用目的往往在于对各种对象的格式转换或者加工，使用泛型可以避免传入对象的限制。

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;    
       import java.util.Date;    
       import org.apache.commons.beanutils.BeanUtils;     
       import com.mongodb.BasicDBObject;    
      import com.mongodb.DBObject;    
        
    public class BeanUtil \{    
        
      /\*\*   
       \* 把实体bean对象转换成DBObject   
       \* @param bean   
       \* @return   
       \* @throws IllegalArgumentException   
       \* @throws IllegalAccessException   
       \*/    
      public static <T> DBObject bean2DBObject(T bean) throws IllegalArgumentException,    
          IllegalAccessException \{    
        if (bean == null) \{    
          return null;    
        \}    
        DBObject dbObject = new BasicDBObject();    
        // 获取对象对应类中的所有属性域    
        Field\[\] fields = bean.getClass().getDeclaredFields();    
        for (Field field : fields) \{    
          // 获取属性名    
          String varName = field.getName();    
          // 修改访问控制权限    
          boolean accessFlag = field.isAccessible();    
          if (!accessFlag) \{    
            field.setAccessible(true);    
          \}    
          Object param = field.get(bean);    
          if (param == null) \{    
            continue;    
          \} else if (param instanceof Integer) \{//判断变量的类型    
            int value = ((Integer) param).intValue();    
            dbObject.put(varName, value);    
          \} else if (param instanceof String) \{    
            String value = (String) param;    
            dbObject.put(varName, value);    
          \} else if (param instanceof Double) \{    
            double value = ((Double) param).doubleValue();    
            dbObject.put(varName, value);    
          \} else if (param instanceof Float) \{    
            float value = ((Float) param).floatValue();    
            dbObject.put(varName, value);    
          \} else if (param instanceof Long) \{    
            long value = ((Long) param).longValue();    
            dbObject.put(varName, value);    
          \} else if (param instanceof Boolean) \{    
            boolean value = ((Boolean) param).booleanValue();    
            dbObject.put(varName, value);    
          \} else if (param instanceof Date) \{    
            Date value = (Date) param;    
            dbObject.put(varName, value);    
          \}    
          // 恢复访问控制权限    
          field.setAccessible(accessFlag);    
        \}    
        return dbObject;    
      \}    
        
      /\*\*   
       \* 把DBObject转换成bean对象   
       \* @param dbObject   
       \* @param bean   
       \* @return   
       \* @throws IllegalAccessException   
       \* @throws InvocationTargetException   
       \* @throws NoSuchMethodException   
       \*/    
      public static <T> T dbObject2Bean(DBObject dbObject, T bean) throws IllegalAccessException,    
          InvocationTargetException, NoSuchMethodException \{    
        if (bean == null) \{    
          return null;    
        \}    
        Field\[\] fields = bean.getClass().getDeclaredFields();    
        for (Field field : fields) \{    
          String varName = field.getName();    
          Object object = dbObject.get(varName);    
          if (object != null) \{    
            BeanUtils.setProperty(bean, varName, object);    
          \}    
        \}    
        return bean;    
      \}    
\}

[Link 1]: http://baike.baidu.com/view/1965709.htm
[Link 2]: http://baike.baidu.com/view/965170.htm
[Link 3]: http://baike.baidu.com/view/520690.htm
[Link 4]: http://baike.baidu.com/view/2852863.htm