在平时编程的过程中，为了尽可能多的兼容更多的类型，通常会使用到泛型。虽然，使用泛型能带来很多的好处，比如最明显的就是省去了强制类型转换。但同时也带来了一些麻烦。例如，如果代码中有下面这样的需求

public class Practice {
T mParam;
public Practice() {
mParam = new T();//报错 Type parameter 'T' cannot be instantiated directly
}
}

产生这种错误的原因主要有两点

1.泛型擦除

2.编译器不知道该类型是否有默认的构造器

通常为了使用泛型，同时还要避免这样的问题出现，会花很多时间寻找可替代方案。有没有同时兼顾的办法呢？答案是肯定的。利用Class对象就可以达到想要的实现的效果，看代码

public class Practice {
T mType;
public Practice(Class clz) {
mType = clz.newInstance(); //为了方便，这里省略了 try...catch代码块
}
static class Trainer {
public void print() {
System.out.println("Trainer创建成功");
}
}
public static void main(String[] args) {
Practice trainerPractice = new Practice<>(Trainer.class);
Trainer trainer = trainerPractice.mType;
trainer.print();
}
}

输出结果：Trainer创建成功

看到这有没有点小激动，既使用了泛型，同时创建了一个“泛型实例”。不过，先别急着激动，当把自己定义的Trainer类替换成Integer上述代码就会报错了，原因是Integer没有任何默认的构造器。这个错误不是 在编译期捕获的，所以当我们使用Integer运行的时候就会报错

Caused by: java.lang.NoSuchMethodException: java.lang.Integer.()

at java.lang.Class.getConstructor0(Class.java:3082)

at java.lang.Class.newInstance(Class.java:412)

... 7 more

从报错信息也可以看出，找不到初始化的方法。

带着这个问题，我们观察一下上面最初提出的解决问题的方案，不论是什么类型，都将实例化的过程都用了同一种的实例化方法

mType = clz.newInstance();

这样做，即便不使用Integer，当我们需要把某个自定义的类默认构造方法声明为private时，上面的方法也不适用了。那怎样解决这个问题呢？答案就是java编程的六大基本原则之一的面向接口编程。接口的好处就是把具体实现分割开，针对不同的需求，各自实现自己想要的结果，互相之间不干扰。

有了思路，下面就开始解决这个问题。首先声明一个接口，接口里声明一个方法，此方法用来创建泛型所代表类的实例

public interface Creator {
T create();
}

这里还是以自定义的Trainer类实例化为例。创建一个用来把泛型类和实例化结果关联起来的工厂类，工厂类不关心具体的实例化过程，它只负责将实例化结果赋值给泛型类。工厂类的构造方法是一个泛型方法，泛型的边界是接口Creator，同时构造方法的参数是实现了Creator接口的子类。在子类的create()方法里是具体的类实例化过程。

public class Factory {
private T t;
public > Factory(C creator) {
t = creator.create();
}
}

在Factory类里，通过调用实现了Creator接口子类的create()方法创建实例。接下来，创建一个TrainerCreator类来实现Creator接口

public class TrainerCreator implements Creator {
@Override
public Trainer create() {
return new Trainer();
}
public static void main(String[] args) {
Factory factory = new Factory<>(new TrainerCreator());
Trainer trainer = factory.getT();
System.out.println(trainer.toString());
}
}

输出结果：Trainer

为了方便我把Trainer类的代码也贴出来

public class Trainer {

@Override

public String toString() {

return "Trainer";

}

}

至此，改进版的代码就完成了。可以看到，类的实例化也就是new动作放在了具体的实现类里，而Factory的作用类似于适配器一样，它负责将Creator接口实现类的create()方法返回的类实例赋值给泛型类。这样做，大大降低了代码的耦合度。假如，此时需要一个Integer类型的值。那么只需要实现Creator接口创建一个新的用于创建Integer实例的实现类就可以了

public class IntegerCreator implements Creator {
@Override
public Integer create() {
return 1;
}
public static void main(String[] args) {
Factory factory = new Factory<>(new IntegerCreator());
Integer integer = factory.getT();
System.out.println(integer.toString());
}
}

输出结果：1