引言

JDK1.5之后引入了泛型，泛型刚开始接触时比较难理解，经过慢慢学习，有一些收获，现总结下，既可以加深自身理解，也可以帮助他人。

由于本人水平有限，难免有不对的地方，还请指正。废话不多说，下面正式开始。

为了更直观的说明泛型，现假设一个司机开车的场景。我们需要3个类，Driver(司机)、Ford(福特)、Buick(别克)。

第一版

第一版本代码如下：

public class Buick {
    
    public void run(){
        System.out.println("buick run");
    }
    
    public void autoRun(){
        System.out.println("buick auto-run");
    }
    
}

public class Ford {
    
    public void run(){
        System.out.println("ford run");
    }
    
    public void fly(){
        System.out.println("ford fly");
    }
}

public class Driver {
    
    private Object car;
    
    public void drive(Object car){
        this.car = car;
        if(car instanceof Buick){
            System.out.println("I am driving a " + car);
            ((Buick)car).run();
        }else if(car instanceof Ford){
            System.out.println("I am driving a " + car);
            ((Ford)car).run();
        }
    }
    
    public Object getDrivingCar(){
        return car;
    }
    
    public static void main(String[] args) {
        Driver driver1 = new Driver();
        driver1.drive(new Ford());
        Driver driver2 = new Driver();
        driver2.drive(new Buick());
        
        //...执行其它业务逻辑
        
        /** 获取司机1开的福特车执行fly方法 */
        ((Ford)driver1.getDrivingCar()).fly();
        
        /** 获取司机2开的别克车执行autoRun方法 */
        ((Buick)driver2.getDrivingCar()).autoRun();
        
    }
}

简单说明下三个类。Buick类和Ford类都含有run方法，Buick类有autoRun方法，Ford类有fly方法。

Driver类有一个drive方法和getDrivingCar方法及内部属性car。main静态方法是演示示例。

通过上面的演示示例可以发现，在调用Driver实例的drive方法时，实际参数向上转型为Object对象，而在调用getDrivingCar方法时，又需要向下转型为具体的car类来调用其特定的方法。那么这种方式会有什么问题呢？

问题是显而易见的，drive方法的参数类型和getDrivingCar的返回值类型是一样的，但由于要支持不同的car，向上转型为Object类型(没有定义为具体的Buick类型或Ford类型)，这样外部在调用getDrivingCar时，返回的是一般化的Object，这样就失去了具体类的特征，需要外部强制类型转换。这种显示强制转换方式很容易产生ClassCastException异常(不小心把driver2写成driver1时执行代码时会抛出该异常)，并且这种编程错误不能在编译期间发现，而要等到运行期间才能发现，有可能产生隐藏BUG。并且这种方式也不合理，Driver类的使用门槛过高，需要外部代码很小心的处理来防止出现错误，例如在强制转换前用instanceof进行判断。那么有没更好的方式呢？

第二版

第二版本代码如下(只修改Driver类)：

public class Driver<T> {
    
    private T car;
    
    public void drive(T car){
        this.car = car;
        if(car instanceof Buick){
            System.out.println("I am driving a " + car);
            ((Buick)car).run();
        }else if(car instanceof Ford){
            System.out.println("I am driving a " + car);
            ((Ford)car).run();
        }
    }
    
    public T getDrivingCar(){
        return car;
    }
    
    public static void main(String[] args) {
        Driver<Ford> driver1 = new Driver<Ford>();
        driver1.drive(new Ford());
        Driver<Buick> driver2 = new Driver<Buick>();
        driver2.drive(new Buick());
        
        //...执行其它业务逻辑
        
        /** 获取司机1开的福特车执行fly方法 */
        driver1.getDrivingCar().fly();
        
        /** 获取司机2开的别克车执行autoRun方法 */
        driver2.getDrivingCar().autoRun();
        
    }
}

Driver类声明中使用的<T>，即泛型T。你可以把T类型理解成代表任意一种具体类型的类型。同时修改drive方法参数类型和getDrivingCar方法返回值类型及私有属性car都是T类型。那么这样做有什么好处呢？

从main方法的演示使用代码可以看出，在实例化Driver类时，需要指定具体的T类型(driver1中的Ford和driver2中Buick)。实例化之后，调用getDrivingCar方法的返回类型也是相应的具体类型，从而可以直接调用具体类型特定的方法。

比较第一版的Driver类，改进版的Driver类，只需要使用者在类实例化时指定具体的T类型，在后续操作中不需要进行强制类型转换，从而减少出错的可能性，提高了代码的稳健性。

通过泛型T，很轻松对drive方法参数类型、getDrivingCar方法返回值类型及私有属性car类型这三处地方的类型进行了统一，且不失具体性(不像第一版将car申明为Object类型)不需要额外的代码成本，类结构看上去清晰明了。对外部使用者，使用门槛也低，不会出现不小心弄错类型的错误(想出现也不可能，如果指定了错误类型，会在编译期间提示错误)

上面的示例演示了泛型最基本的用法。通过泛型，很容易在类的成员变量或方法参数或方法返回值之间声明为统一类型且不失类型的具体性（在类定义中是泛型，但在实例化时需要指定具体的类型）

联系实际

现在大家应该对泛型有了一个基本的了解。下面举个实例项目中的例子，更进一步说明问题。

项目中一般都需要分页类，简化版如下

/**
 * <简单分页类>
 */
public class SimplePage {
    
    /** 每页显示的记录数*/
    private int numPerPage;
    
    /** 总记录数 */
    private int totalCount;
    
    /** 当前页 */
    private int pageNum;
    
    //...省略其它方法
}

/**
 * <带内容分页类>
 */
public class Pageable<E> extends SimplePage {
    
    /**
     * 本页内容
     */
    private List<E> list;
    
    /**
     * <设置内容>
     * @param list
     */
    public void setList(List<E> list) {
        this.list = list;
    }
    
    /**
     * <获取内容>
     * @return
     */
    public List<E> getList() {
        return list;
    }
}

SimplePage：简单分页类，包含当前页，每页显示记录数，总记录数等基本成员属性。

Pageable：业务数据分页类，继续自简单分页类，带有本页数据信息。

比如要分面查询用户信息时，假设有User类封装用户信息。使用代码如下：

        Pageable<User> pageInfo = new Pageable<User>();
        
        //...分页获取出用户信息,并调用setList方法将用户信息放入pageInfo实例中
        
        /** 其它地方获取到userList，进行其它业务操作 */
        List<User> userList = pageInfo.getList();

码字不易，转载请标明出处

java泛型学习和实践(1)