java针对泛型创建对象的中存在擦除的弥补方案

在java中不能像才c++那样,直接声明泛型对象即使 T t=new T(); 但是java中针对这种问题也有一些解决方案,在这里提供三种方案

/**
*
* although in c++ could use new T() to creating a instance of type, but java not support this approach, this class
* provider 3 solutions for this situation
* @version $Revision: $ $Name: $
*/
public class CreatingTypesSolutions {
public static void main(String[] args) {
// solution 1: pass in a factory object, and use that to make the new instance
ClassAsFactory<Employ> caf1 = new ClassAsFactory<Employ>(Employ.class);
/*
* This compiles, but fails with ClassAsFactory<Integer> because Integer has no default constructor. Because the
* error is not caught at compile time, this approach is frowned upon by the Sun folks. They suggest instead
* that you use solution2
*/
// ClassAsFactory<Integer> caf2 = new ClassAsFactory<Integer>(Integer.class);
// solution 2:
ClassAsFactory2<Employ> caf21 = new ClassAsFactory2<Employ>(new EmployFactory());
ClassAsFactory2<Integer> caf22 = new ClassAsFactory2<Integer>(new IntegerFactory());
// solution 3: Template Method design pattern
IntegerGeneric ig1=new IntegerGeneric();
System.out.println(ig1.create());
}

}

class Employ {
}

class ClassAsFactory<T> {
public ClassAsFactory(Class<T> t) {
try {
T tObj = t.newInstance();
System.out.println(tObj.getClass().getSimpleName() + " object!");
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}

}

// solution 2 :intgerface
interface FactoryI<T> {
T create();
}

class ClassAsFactory2<T> {
public <F extends FactoryI<T>> ClassAsFactory2(F factory) {
System.out.println(factory.create().getClass().getSimpleName() + " create successful");
}
}

class EmployFactory implements FactoryI<Employ> {

public Employ create() {
return new Employ();
}

}

class IntegerFactory implements FactoryI<Integer> {

public Integer create() {
return new Integer(0);
}

}

// solution 3: Template Method design pattern
abstract class GenericWithCreate<T> {
final T element;

GenericWithCreate() {
element = create();
}

abstract T create();
}

class IntegerGeneric extends GenericWithCreate<Integer> {

@Override
Integer create() {
return new Integer("4");
}

}