java-泛型小记

泛型是JDK1.5以后才有的，
作用：
1. 编译时期进行类型检查
2. 避免频繁类型转化

---

泛型类型必须是引用类型,不能为基本类型
e.g：能用Integet、Double 不能用int、double

泛型包括 ：泛型方法/泛型类/泛型接口
作用：
设计公用的类、方法，对公用的业务实现进行抽取！
使程序更灵活！

泛型方法:

public class GenericDemo {

    // 定义泛型方法
    public <K,T> T save(T t,K k) {
        return null;
    }

    // 测试方法
    @Test
    public void testMethod() throws Exception {
        // 使用泛型方法:  在使用泛型方法的时候，确定泛型类型
        save(1.0f, 1);
    }
}

泛型类：

 public class GenericDemo<T> {

    // 定义泛型方法
    public <K> T save(T t,K k) {
        return null;
    }

    public void update(T t) {

    }

    // 测试方法
    @Test
    public void testMethod() throws Exception {

        // 泛型类：  在创建爱泛型类对象的时候，确定类型
        GenericDemo<String> demo = new GenericDemo<String>();
        demo.save("test", 1);
    }
}

泛型接口

  public interface IBaseDao<T> {
    void save(T t );
    void update(T t );
}

泛型接口类型确定： 在业务实现类中直接确定接口的类型

其它用法:Class类传递及泛型数组

public static <T> List<T> parseArray(String response,Class<T> object){  
    List<T> modelList = JSON.parseArray(response, object);  
    return modelList;  
}  

Class也是一泛型，它是传来用来装载类的class对象的，它的定义如下：

public final class Class<T> implements Serializable {  
    …………  
}  

定义泛型数组
在写程序时，大家可能会遇到类似String[] list = new String[8];的需求，这里可以定义String数组，当然我们也可以定义泛型数组，泛型数组的定义方法为 T[]，与String[]是一致的，下面看看用法：

//定义  
public static <T> T[] fun1(T...arg){  // 接收可变参数    
       return arg ;            // 返回泛型数组    
}    
//使用  
public static void main(String args[]){    
       Integer i[] = fun1(1,2,3,4,5,6) ;  
       Integer[] result = fun1(i) ;  
}    

首先，定义了一个静态函数，然后定义返回值为T[]，参数为接收的T类型的可变长参数。如果有同学对T…arg的用法不了解，可以去找下JAVA 可变长参数方面的知识。
由于可变长参数在输入后，会保存在arg这个数组中，所以，我们直接把数组返回即可。

---

泛型关键字
? 不确定是什么类型，指定只是接收值， 与T没有关系
extends 元素的类型必须继承自指定的类 ，与java类之间的extends没有关系
extends表示绑定，后面的BindingType即可以是接口，也可以是类
super 元素的类型必须是指定的类的父类

public static <T extends Fruit> String getFruitName(T t){  
    return t.getName();  
}  

public static <T extends Comparable & Serializable, U extends Runnable> T foo(T a, U b){  
    …………  
}  

这里有两个泛型变量T和U,将T与Comparable & Serializable绑定，将U与Runnable绑定。

通配符? :通配符只能用于填充泛型变量T,不能用于定义变量

Point<?> point;  

point = new Point<Integer>(3,3);  
point = new Point<Float>(4.3f,4.3f);  
point = new Point<Double>(4.3d,4.90d);  
point = new Point<Long>(12l,23l); 

通配符？总结
总结 ? extends 和 ? super 通配符的特征，我们可以得出以下结论：
◆ 如果你想从一个数据类型里获取数据，使用 ? extends 通配符（能取不能存）
◆ 如果你想把对象写入一个数据结构里，使用 ? super 通配符（能存不能取）
◆ 如果你既想存，又想取，那就别用通配符。

文章推荐：以上内容大部分是由以下文章抽象的，还请参考原作
夯实JAVA基本之一 —— 泛型详解(1):基本使用
夯实JAVA基本之一——泛型详解(2)：高级进阶

---

demo:
场景描述：
有两条业务线，各自有一个实体类，这两个实体类有部分共同属性字段。（没有将共同属性字段抽成一个父类）
业务需求是：两个业务线各有一大批数据，需要对有共同点的字段进行校验，规则为：字段为空则反回false.
在进行业务处理时过虑这部分抽成一个公用方法即可。这种情况就可使用泛型。
步骤为：
1，定义一个接口：包含获取对应公共字段的方法
2，各自实体类实现这个接口。
3，实现泛型方法
demo结构为：

代码为：

/**
 * 业务1
 */
public class Business1 implements PublicFieldFilterService {

    private Long id;
    private String bizBillNum;
    private Double width;
    private Double height;
    /**
     * 共同属性字段
     */
    private String tradingSubOrgId;
    /**
     * 共同属性字段
     */
    private String tradingSubOrgName;

    public Business1() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getBizBillNum() {
        return bizBillNum;
    }

    public void setBizBillNum(String bizBillNum) {
        this.bizBillNum = bizBillNum;
    }

    public Double getWidth() {
        return width;
    }

    public void setWidth(Double width) {
        this.width = width;
    }

    public Double getHeight() {
        return height;
    }

    public void setHeight(Double height) {
        this.height = height;
    }

    @Override
    public String getTradingSubOrgId() {
        return tradingSubOrgId;
    }

    public void setTradingSubOrgId(String tradingSubOrgId) {
        this.tradingSubOrgId = tradingSubOrgId;
    }

    @Override
    public String getTradingSubOrgName() {
        return tradingSubOrgName;
    }

    public void setTradingSubOrgName(String tradingSubOrgName) {
        this.tradingSubOrgName = tradingSubOrgName;
    }
}

/**
 * 业务2
 */
public class Business2 implements PublicFieldFilterService {

    private Long id;
    private String skuNum;
    private Double wt;
    private Double len;

    /**
     * 共同属性字段
     */
    private String tradingSubOrgId;
    /**
     * 共同属性字段
     */
    private String tradingSubOrgName;

    public Business2() {
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getSkuNum() {
        return skuNum;
    }

    public void setSkuNum(String skuNum) {
        this.skuNum = skuNum;
    }

    public Double getWt() {
        return wt;
    }

    public void setWt(Double wt) {
        this.wt = wt;
    }

    public Double getLen() {
        return len;
    }

    public void setLen(Double len) {
        this.len = len;
    }

    @Override
    public String getTradingSubOrgId() {
        return tradingSubOrgId;
    }

    public void setTradingSubOrgId(String tradingSubOrgId) {
        this.tradingSubOrgId = tradingSubOrgId;
    }

    @Override
    public String getTradingSubOrgName() {
        return tradingSubOrgName;
    }

    public void setTradingSubOrgName(String tradingSubOrgName) {
        this.tradingSubOrgName = tradingSubOrgName;
    }
}

/**
 * 公共属性过滤接口
 */
public interface PublicFieldFilterService {

     String getTradingSubOrgId();

     String getTradingSubOrgName();

}

/**
 * 測試过滤
 */
public class TestFilter {

    public void testBusiness1() {
        Business1 business1 = new Business1();
        Boolean aBoolean = FilterUtil.filterField(business1);
        System.out.println(aBoolean);
        //编译报错（只能传递所继承接口指定的类型）
//        FilterUtil.filterField(business1.getHeight());
    }

    public void testBusiness2() {
        Business2 business2 = new Business2();
        Boolean aBoolean = FilterUtil.filterField(business2);
        System.out.println(aBoolean);
    }
}