泛型实例化

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

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

1.泛型擦除

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

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

public class Practice<T> {
    T mType;

    public Practice(Class<T> clz) {
        mType = clz.newInstance(); //为了方便，这里省略了 try...catch代码块
    }

    static class Trainer {
        public void print() {
            System.out.println("Trainer创建成功");
        }
    }

    public static void main(String[] args) {
        Practice<Trainer> trainerPractice = new Practice<>(Trainer.class);
        Trainer trainer = trainerPractice.mType;
        trainer.print();
    }
}


输出结果：Trainer创建成功

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

 

Caused by: java.lang.NoSuchMethodException: java.lang.Integer.<init>()
    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> {
    T create();
}

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

 

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

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

public class TrainerCreator implements Creator<Trainer> {
    @Override
    public Trainer create() {
        return new Trainer();
    }

    public static void main(String[] args) {
        Factory<Trainer> 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<Integer> {
    @Override
    public Integer create() {
        return 1;
    }

    public static void main(String[] args) {
        Factory<Integer> factory = new Factory<>(new IntegerCreator());
        Integer integer = factory.getT();
        System.out.println(integer.toString());
    }
}

输出结果：1

作者：半生黑豆
链接：https://www.jianshu.com/p/e618b81aadb4
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

使用反射新建实例

Type superclass = getClass().getGenericSuperclass();
ParameterizedType parameterizedType = null;
if (superclass instanceof ParameterizedType) {
   parameterizedType = (ParameterizedType) superclass;
   Type[] typeArray = parameterizedType.getActualTypeArguments();
   if (typeArray != null && typeArray.length > 0) {
      clazz = (Class<T>) typeArray[0];
                
   }
}

执行结果

控制台输出

 完整代码

package com.learn.genericinstance;


import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class GenericInstanceLearn {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        UserDao userDao = new UserDao();
        System.out.println(userDao.toString());
    }
}


class Dao<T> {
    public Class<T> clazz;
    public T user;
    public Dao() throws IllegalAccessException, InstantiationException {
        Type superclass = getClass().getGenericSuperclass();
        ParameterizedType parameterizedType = null;
        if (superclass instanceof ParameterizedType) {
            parameterizedType = (ParameterizedType) superclass;
            Type[] typeArray = parameterizedType.getActualTypeArguments();
            if (typeArray != null && typeArray.length > 0) {
                clazz = (Class<T>) typeArray[0];
                user= clazz.newInstance();
            }
        }
    }

    @Override
    public String toString() {
        return "Dao{" +
                "user=" + user.toString() +
                '}';
    }
}

class UserDao extends Dao<User> {

    public UserDao() throws IllegalAccessException, InstantiationException {
    }

    @Override
    public String toString() {
        return super.toString();
    }
}

class User {
    String name;

    public User() {
        this.name = "default name";
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

 

本文作者：夜空中最亮的盖子
本文链接：Java泛型实例化 - 夜空中最亮的盖子 - 博客园
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！