设计模式——工厂方法&模版方法

　　Java的泛型一直是我比较感兴趣的部分，但是既然说起泛型，就不得不提到擦除。Java泛型是使用擦除实现的，使用泛型时，具体的类型信息都被“擦除”了。举个例子：List<String>和List<Integer>在运行时实际上都是相同的类型，都被擦除成了“原生的”类型，即List。

　　泛型类型参数将擦除到它的第一个边界，如List<T>将被擦除成List，而普通的类型变量在未指定边界的情况下被擦除成Object。

package com.test.generic;

public class Erased<T> {
    private final int SIZE = 100;
    public static void f(Object arg) {
        if(arg instanceof T) {} //编译报错
        T var = new T(); //编译报错
        T[] array = new T[SIZE]; //编译报错
        T[] array = new Onject[SIZE]; //编译报错
    }
}

工厂方法

　　在上面的代码中，创建一个new T()的操作无法实现，部分原因就是擦除，另一部分原因是因为编译器不能验证码T具有默认（无参）的构造器。Java的解决方案是传递一个工厂对象，并使用它来创建新的实例。最便利的工厂对象就是Class对象，如下代码所示：

package com.test.generic;

class ClassAsFactory<T> {
    T x;
    public ClassAsFactory(Class<T> kind) {
        try {
            x  = kind.newInstance();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

class Employee {}

public class InstantiateGenericType {

    public static void main(String[] args) {
        ClassAsFactory<Employee> fe = new ClassAsFactory<Employee>(Employee.class);
        System.out.println("ClassAsFactory<Employee> succeeded");
        
        try {
            ClassAsFactory<Integer> fi = new ClassAsFactory<Integer>(Integer.class);
        } catch (Exception e) {
            System.out.println("ClassAsFactory<Employee> failed");
        }
    }

}

运行结果如下

从运行结果看到，可以编译，但是会因为ClassAsFactory<integer>而失败，因为Integer没有任何默认的构造器。因为这个错误不是在编译期捕获的。Sun公司建议使用显式的工厂，并限制类型，只能接受实现了这工厂的类，如下代码所示：

package com.test.generic;

interface FactoryI<T> {
    T create();
}

class Foo2<T> {
    private T x;
    public <F extends FactoryI<T>> Foo2(F factory) {
        x = factory.create();
    }
}

class IntegerFactory implements FactoryI<Integer> {
    public Integer create() {
        return new Integer(0);
    }
}

class Widget {
    public static class Factory implements FactoryI<Widget> {
        @Override
        public Widget create() {
            return new Widget();
        }
    }
}
public class FactoryConstraint {
    public static void main(String[] args) {
        new Foo2<Integer>(new IntegerFactory());
        new Foo2<Widget>(new Widget.Factory());
    }
}

Class<T>碰巧是创建内建的工厂对象，而通过上面那样显示的创建一个工厂对象，可以获得编译期的检查。

模版方法：

　　另一种方法是使用模版方法设计模式，通过实现抽象类（模版）的抽象方法来创建对象，同样能获得编译期的类型检查，下面是代码：

package com.test.generic;

abstract class GenericWithCreate<T> {
    final T element;
    GenericWithCreate() {
        element = create();
    }
    abstract T create();
}

class X {}

class Creator extends GenericWithCreate<X> {
    @Override
    X create() {
        return new X();
    }
    void f() {
        System.out.println(element.getClass().getSimpleName());
    }
}
public class CreatorGeneric {
    public static void main(String[] args) {
        Creator c = new Creator();
        c.f();
    }
}    

总结：

　　在使用泛型的过程中，因为擦除的存在，任何在运行时需要知道确切类型信息的操作都没法好好工作。通过反射配合工厂方法或者模版方法的使用，我们能在编译器就知道创建对象时传递的参数类型是否正确。