java泛型学习和实践(3)

引言

泛型除了像前面两节所讲的在类名后进行定义外，也可以在单独的方法上进行定义。这次我们就讲下如何在方法进行泛型声明和使用

同样的，假设一个汽车改装厂的场景。延用上节中的Runnable接口、Ford类、Buick类。 新增CarRefitFactory类(汽车改装工厂类)。

第一版

代码如下：

public interface Runnable {
    public void run();
}

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

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

public class CarRefitFactory {
    public static Runnable turnTo(Class<?> targetClass, Runnable srcCar) {
        Runnable targetCar = null;
        Object o;
        try {
            o = targetClass.newInstance();
            if( o instanceof Runnable){
                targetCar = (Runnable)o;
                
                //执行改装过程...。例如获取源轿车(srcCar)的属性并赋值给新的车(targetCar)，具体过程省略，非重点。
            }
        }
        catch (InstantiationException e) {
            e.printStackTrace();
        }
        catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        
        return targetCar;
    }
    
    public static void main(String[] args) {
        /** 演示使用 */
        Runnable runable = CarRefitFactory.turnTo(Buick.class, new Ford());
        Buick newBuick = (Buick)runable;
        newBuick.autoRun();
        
        Ford newFord = (Ford)CarRefitFactory.turnTo(Ford.class, new Buick());
        newFord.fly();
    }
}

简单说下CarRefitFactory，其提供一个静态工厂方法turnTo，接收目标car的Class对象及源car对象参数，返回目标car对象。通俗讲就是将一辆车改装成另外一辆车。srcCar参数代表将被改装的车，targetClass代表改装成什么样的车的相关信息，这样说估计大家能理解了。main方法中演示了使用方法。

下面继续思考下turnTo方法的不足之处或别扭的地方。从使用示例可以看出，里面用到了强制类型转换，同样会出现由于人为写错因素造成ClassCastException(如将Ford.class错写成Buick.class)，这种异常在编译期间不会被检出，当系统运行时就可能出错，因此在编程中应尽量避免不必要的强制类型转换。那有没有更好的方式？下面就看方法上的泛型使用。

第二版(只修改CarRefitFactory类)

public class CarRefitFactory {
    public static <E extends Runnable> E turnTo(Class<E> targetClass, Runnable srcCar) {
        E targetCar = null;
        try {
            targetCar = targetClass.newInstance();
                
            //执行改装过程...。例如获取源轿车(srcCar)的属性并赋值给新的车(targetCar)，具体过程省略，非重点。
        }
        catch (InstantiationException e) {
            e.printStackTrace();
        }
        catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        
        return targetCar;
    }
    
    public static void main(String[] args) {
        /** 演示使用 */
        Buick newBuick = CarRefitFactory.turnTo(Buick.class, new Ford());
        newBuick.autoRun();
        
        Ford newFord = CarRefitFactory.turnTo(Ford.class, new Buick());
        newFord.fly();
    }
}

首先在trunTo方法上进行泛型声明<E extends Runnable>，限制E必须是Runnable的子类或Runnable自身。接着，修改参数targetClass类对象类型及返回值类型是E。这样将欲改装成的车类型(参数类型)跟实际返回的车类型(返回值类型)进行了统一，故而在使用turnTo方法时，编译器会自动识别类型，不需要手动进行强制转换。而且代码看上去也简单易懂。

上面演示了方法上声明和使用泛型及分析了泛型带给程序的易读性和安全性好处。细心的读者会发现，方法上泛型声明跟类上的泛型声明一致，使用也一样。下面就对这两种泛型情况进行下总结：

类上泛型跟方法上泛型对比

共同点：

一、都是先声明泛型后使用(感觉是废话，还是强调下要先声明泛型)，泛型声明都是<E> 或<E extends Parent>形式(E只是一个类型标记，可以是其它大写字母，甚至小写字母)。都能声明多个泛型，比如Test<K, V, M>，多个泛型类型之间用逗号分隔。

二、声明后的E类型都看作具体JAVA类型使用。对于无限制的E类型(<E>声明方式)，被当成Object类型对待(因为在类实例化之前或方法调用前都不知道会传哪个具体JAVA类型，所以只能当作一般化的Object处理，很好理解吧)；对于有限制的E类型(<E extends Parent>声明方式)，被当成Parent类型对待(因为E肯定是Parent的子类或自身，这个也很好理解)

不同点：

一、泛型声明的位置不同，类上泛型声明是在类名称后面进行声明(public class Driver<T extends Runnable>)，方法上泛型声明是在方法返值类型的前面(public static <E extends Runnable>  E，在E返回类型前面进行了声明)。实际上，所谓类上泛型跟方法上泛型就是根据泛型声明位置直观的划分，只是方便本人说明泛型的声明和使用，可能别的书籍或网上有不同的叫法，没有关系，只要大家能理解就行，还请大家不要过分纠结在某些概念上。

二、由于泛型声明位置不同，就带来了泛型作用范围的不同。类上声明的泛型，在整个类范围都是可见的；而方法上声明的泛型，只在当前方法体范围内有效。这个也是很自然的，没什么可多说的。

好了就总结这么多了，下面咱们来联系下实际，看下项目中经常用到的泛型。比如Map，List。

联系实际

Map接口和List接口是java.util包下的，大家在项目中经常用到。其典型使用如下：

    Map<String, String> map = new HashMap<String, String>();
    map.put("wz", "网站");
    
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);

作为工具类，方便大家使用，可能大家已经习惯了这种写法，但实际上在JDK1.5之前，还没有出现泛型时，是这样使用的

    Map oldMap = new HashMap();
    oldMap.put("wz", "网站");
    
    List oldList = new ArrayList();
    oldList.add(1);

在JDK1.5之后，上面写法也可以，代码也能正常运行，只是IDE会出现警示。但我要说的是，作为一个有追求的程序员，绝不能按上面的写法去编写代码，JVM之所以在编译期及运行期仍支持这种写法，仅仅是向上兼容以前版本JDK，使基于老版本JDK的项目不需要修改仍能正常运行，仅此而已。

对于这种传统写法不好的地方，我觉得还需要再次申明下，除了不能获得编译期类型安全受检外，代码的可读性也大打折扣，让人不忍直视(no law to see)。

今天就码到这里，明天再共同学习下泛型比较复杂难懂的地方，比如?和super关键字的使用。