在java中创建静态泛型工厂？

我在使用

getInstance

方法时遇到问题，无论我如何尝试，我都会得到：

无法对非静态类型T进行静态引用。

我怎样才能做到这一点？任何代码审查都会有很大帮助。 我查阅了几篇相关文章，但这似乎是一个特殊的案例

我的代码：

public class Data<Template>
{
    private Template[] data;
    private int id;

    public Data(Template[] data)
    {
        this.data = data;
        id = Arrays.hashCode(data);
        log();
    }

    public Template[] getData()
    {
        return data;
    }

    public Integer getId()
    {
        return id;
    }

    private void log()
    {
        System.out.println(this.toString());
    }

    @Override
    public String toString()
    {
        StringBuilder tString = new StringBuilder();
        tString.append(id + ":");
        for (int i = 0; i < data.length; i++)
        {
            tString.append(data[i] + " ");
        }
        return tString.toString();
    }
}

public class Store<T>
{
    private Queue<Data<T>> queue;
    private ConcurrentHashMap<Integer, Data<T>> inProgress;
    private List<T> results;
    private static Store instance = null;

    private Store()
    {
        queue = new ConcurrentLinkedQueue<Data<T>>();
        inProgress = new ConcurrentHashMap<Integer, Data<T>>(16, 0.9f, 1);
        results = new ArrayList<>();
    }

    public void addToStore(Data<T> elment)
    {
        queue.offer(elment);
    }

    public Data<T> getNextTask()
    {
        Data<T> element = queue.poll();
        inProgress.put(element.getId(), element);
        return element;
    }

    public void taskFinishedSuccessfully(Integer id, T result)
    {
        inProgress.remove(id);
        results.add(result);
    }

    public List<T> getResults()
    {
        return results;
    }

    public static Store getInstance(Class<T> type)
    {
        if (instance == null)
        {
            if (type instanceof Integer)
            {
                instance = new Store<Integer>();
            }

            if (type instanceof Float)
            {
                instance = new Store<Float>();
            }

            if (type instanceof Double)
            {
                instance = new Store<Double>();
            }
        }
        return instance;
    }
}

公共类数据
{
私有模板[]数据；
私有int-id；
公共数据（模板[]数据）
{
这个数据=数据；
id=Arrays.hashCode（数据）；
log（）；
}
公共模板[]获取数据（）
{
返回数据；
}
公共整数getId（）
{
返回id；
}
私有无效日志（）
{
System.out.println（this.toString（））；
}
@凌驾
公共字符串toString（）
{
StringBuilder tString=新的StringBuilder（）；
tString.append（id+“：”）；
对于（int i=0；i

不清楚你为什么不只是在写作

public static <T> Store<T> getInstance() {
  return new Store<T>();
}

公共静态存储getInstance（）{
返回新店（）；
}

不清楚你为什么不只是在写作

public static <T> Store<T> getInstance() {
  return new Store<T>();
}

公共静态存储getInstance（）{
返回新店（）；
}

所以这就是我最后要做的：

public class Store<T> {
private Queue<Data<T>> queue;
private ConcurrentHashMap<Integer, Data<T>> inProgress;
private List<T> results;
private static Store<Double> doubleInstance = null;
private static Store<Integer> integerInstance = null;
private static Store<Float> floatInstance = null;

private Store() {
    queue = new ConcurrentLinkedQueue<Data<T>>();
    inProgress = new ConcurrentHashMap<Integer, Data<T>>(16, 0.9f, 1);
    results = new ArrayList<>();
}

public void addToStore(Data<T> elment) {
    queue.offer(elment);
}

public Data<T> getNextTask() {
    Data<T> element = queue.poll();
    inProgress.put(element.getId(), element);
    return element;
}

public void taskFinishedSuccessfully(Integer id, T result) {
    inProgress.remove(id);
    results.add(result);
}

public List<T> getResults() {
    return results;
}

private static <T> Store<T> getInstance() {
    return new Store<T>();
}

public static Store<Double> getDoubleInstance() {
    if (doubleInstance == null) {

        doubleInstance = Store.<Double> getInstance();
    }
    return doubleInstance;
}

public static Store<Integer> getIntegerInstance() {
    if (integerInstance == null) {

        integerInstance = Store.<Integer> getInstance();
    }
    return integerInstance;
}

public static Store<Float> getFloatInstance() {
    if (floatInstance == null) {

        floatInstance = Store.<Float> getInstance();
    }
    return floatInstance;
}

公共类存储{
专用队列；
进程中的私有ConcurrentHashMap；
私人名单结果；
私有静态存储doubleInstance=null；
私有静态存储integerInstance=null；
私有静态存储floatInstance=null；
私家店（）{
队列=新的ConcurrentLinkedQueue（）；
inProgress=新的ConcurrentHashMap（16,0.9f,1）；
结果=新的ArrayList（）；
}
公共void addToStore（数据元素）{
排队。报价（elment）；
}
公共数据getNextTask（）{
数据元素=queue.poll（）；
inProgress.put（element.getId（），element）；
返回元素；
}
public void taskFinishedSuccessfully（整数id，T结果）{
正在进行。删除（id）；
结果。添加（结果）；
}
公共列表getResults（）{
返回结果；
}
私有静态存储getInstance（）{
返回新店（）；
}
公共静态存储getDoubleInstance（）{
if（doubleInstance==null）{
doubleInstance=Store.getInstance（）；
}
返回双实例；
}
公共静态存储getIntegerInstance（）{
if（integerInstance==null）{
integerInstance=Store.getInstance（）；
}
返回整数；
}
公共静态存储getFloatInstance（）{
if（floatInstance==null）{
floatInstance=Store.getInstance（）；
}
返回实例；
}

---

}

所以这就是我最后要做的：

public class Store<T> {
private Queue<Data<T>> queue;
private ConcurrentHashMap<Integer, Data<T>> inProgress;
private List<T> results;
private static Store<Double> doubleInstance = null;
private static Store<Integer> integerInstance = null;
private static Store<Float> floatInstance = null;

private Store() {
    queue = new ConcurrentLinkedQueue<Data<T>>();
    inProgress = new ConcurrentHashMap<Integer, Data<T>>(16, 0.9f, 1);
    results = new ArrayList<>();
}

public void addToStore(Data<T> elment) {
    queue.offer(elment);
}

public Data<T> getNextTask() {
    Data<T> element = queue.poll();
    inProgress.put(element.getId(), element);
    return element;
}

public void taskFinishedSuccessfully(Integer id, T result) {
    inProgress.remove(id);
    results.add(result);
}

public List<T> getResults() {
    return results;
}

private static <T> Store<T> getInstance() {
    return new Store<T>();
}

public static Store<Double> getDoubleInstance() {
    if (doubleInstance == null) {

        doubleInstance = Store.<Double> getInstance();
    }
    return doubleInstance;
}

public static Store<Integer> getIntegerInstance() {
    if (integerInstance == null) {

        integerInstance = Store.<Integer> getInstance();
    }
    return integerInstance;
}

public static Store<Float> getFloatInstance() {
    if (floatInstance == null) {

        floatInstance = Store.<Float> getInstance();
    }
    return floatInstance;
}

公共类存储{
专用队列；
进程中的私有ConcurrentHashMap；
私人名单结果；
私有静态存储doubleInstance=null；
私有静态存储integerInstance=null；
私有静态存储floatInstance=null；
私家店（）{
队列=新的ConcurrentLinkedQueue（）；
inProgress=新的ConcurrentHashMap（16,0.9f,1）；
结果=新的ArrayList（）；
}
公共void addToStore（数据元素）{
排队。报价（elment）；
}
公共数据getNextTask（）{
数据元素=queue.poll（）；
inProgress.put（element.getId（），element）；
返回元素；
}
public void taskFinishedSuccessfully（整数id，T结果）{
正在进行。删除（id）；
结果。添加（结果）；
}
公共列表getResults（）{
返回结果；
}
私有静态存储getInstance（）{
返回新店（）；
}
公共静态存储getDoubleInstance（）{
if（doubleInstance==null）{
doubleInstance=Store.getInstance（）；
}
返回双实例；
}
公共静态存储getIntegerInstance（）{
if（integerInstance==null）{
integerInstance=Store.getInstance（）；
}
返回整数；
}
公共静态存储getFloatInstance（）{
if（floatInstance==null）{
floatInstance=Store.getInstance（）；
}
返回实例；
}

---

}

现在还不清楚你想在这里做什么，或者它如何能够正确工作/做任何有用的事情。@BrianRoach好的想法是你在大的csv文件中读取，每一行都是一个任务（一个数字数组），当有人开始处理该任务时，这些任务被放入队列中，因为它正在进行中，但与此同时，其他人也可以获得队列中的任务。我的意思是，试图制作一个可以以某种方式改变类型的单例位。如果您已经创建并试图返回一个

存储

，那么调用

getInstance（Integer.class）

将如何工作呢？您是对的，我没有想清楚，我只是关注所有客户端都应该使用sam这一事实