Java 泛型对象池-如何返回泛型类？

我正在尝试开发一个ObjectPool，它可以与任何对象一起使用，而无需更改池或对象的源-但我找不到任何方法来编写get（）-函数（“Maincode”从池中获取某些对象），因为存在类型不匹配（无法从对象转换为TestObject）

以下是我目前的代码：

对象池：

public Object get() {
        int first = availableObjects.get(0);
        availableObjects.remove(0);
        return objects.get(first);
    }

    TestObject test = objectPoolS.get();

在对象（ArrayList）中，池中有所有对象，可用对象 只包含所有可用对象的列表。我基本上只是返回第一个可用对象并将其标记为不可用

main代码：

public Object get() {
        int first = availableObjects.get(0);
        availableObjects.remove(0);
        return objects.get(first);
    }

    TestObject test = objectPoolS.get();

如何使get（）-方法更通用/特定，使其在每次使用不同类时都不调整池，也不解析主代码的情况下工作

---

更新： 对于该池的更通用版本，get（）-方法的正确外观如何
（非常感谢任何其他反馈！）
更新：以下主代码的工作（固定）版本

更新2:
我刚刚意识到它不能像这样工作，我需要在池中创建新的对象——如果不为每种对象调整池，这几乎是不可能的。
那么，我是否可以删除池中所有对象之间的引用？（由于我使用baseObject初始化所有对象，实际上我只有5个对1个对象的引用）
还是有更好的管理方法？（不强制用户在其代码中创建对象）

到目前为止的完整代码：

ObjectPool

public class ObjectPoolS<T> {

    int numberOfObjects;
    boolean autoExtending;

    T baseObject;
    ArrayList<T> objects;
    ArrayList<Integer> availableObjects;


    public  ObjectPoolS(T baseObject, int capacity, boolean allowAutoExtending) {
        this.numberOfObjects = capacity;
        this.baseObject = baseObject;
        this.autoExtending = allowAutoExtending;

        objects = new ArrayList<T>(capacity);
        availableObjects = new ArrayList<Integer>(capacity);

        initialize(baseObject, capacity);
    }


    private void initialize(T baseObject, int capacity) {

        // Initialize List of Objects
        for(int i = 0; i < capacity; i++) {
            objects.add(baseObject);
        }

        // Initialize Index of Objects
        for(int i = 0; i < capacity; i++) {
            availableObjects.add(new Integer(i));
        }
    }


    public T get() {
        int first = availableObjects.get(0);
        availableObjects.remove(0);
        return objects.get(first);
    }
}

ObjectPoolS objectPoolS = new ObjectPoolS(new TestObject(0), 5, true);
TestObject test = objectPoolS.get();

Maincode（固定）

您可以尝试：

public <T> T get() {
    // Your code for objectToReturn
    return (T) objectToReturn;
}

public T get（）{
//您的objectToReturn代码
return（T）objectToReturn；
}
哦，在你的主代码中

ObjectPoolS objectPoolS = new ObjectPoolS(new TestObject(0), 5, true);

you must add "<TestObject>" and becomes

ObjectPoolS<TestObject> objectPoolS
=new ObjectPoolS<TestObject> (new TestObject(0),5,true);

just like where you declare ArrayList, it contains "<T>" and "<Integer>", isn't it?

您不是池：您只使用对象的单个实例

通用对象池如下所示：

public class ObjectPool<T> {
    private List<T> objects;
    private Class<T> clazz;
    private int size;

    public ObjectPool(Class<T> clazz, int size) throws IllegalStateException {
        this.clazz = clazz;
        this.size = size;
        this.objects = new ArrayList<T>();
        for (int i = 0;i < size;i++) {
            objects.add(newInstance());
        }
    }

    // You can override this method with anonymous class
    protected T newInstance() {
        try {
            return clazz.newInstance()
        } catch (Exception exception) {
            throw new IllegalStateException(exception);
        }
    }

    public synchronized T getInstance() {
        if (objects.isEmpty()) {
            return null;
        }
        return objects.remove(objects.size() - 1);
    }

    public synchronized void returnInstance(T instance) {
        if (objects.size() < size) {
            objects.add(instance);
        }
    }
}

公共类对象池{
私有列表对象；
私人课堂；
私有整数大小；
公共对象池（类clazz，int size）抛出IllegalStateException{
this.clazz=clazz；
这个。大小=大小；
this.objects=new ArrayList（）；
对于（int i=0；i

不幸的是，我没有编译器来测试代码，但它应该给你一个改变的提示。
如果这将被多个请求调用，我在这里看到一个线程问题。所以我最好将它与synchronized一起使用？是的，你将需要同步该部分。。。您永远不希望允许从列表中添加/删除超过1个线程…是否还有其他问题？更新后，如果在类级别声明了类型参数
T
，则看起来您的思路是正确的。主代码仍然存在类型不匹配问题，我无法解决。您不使用泛型
ArrayList
（或
Queue
）？@BheshGurung在什么情况下会发生这种情况？泛型的目的之一是类型安全，您不希望这样的显式强制转换。在这种情况下，将推断实际类型，如果使用错误的类型创建引用，则会得到一个CCE。将类本身设置为泛型，假设池中的所有对象都是同一类型。-1这比强制调用方强制强制强制转换更糟糕，因为调用站点上没有可见的迹象表明可能出现错误。使用此代码，调用者可以要求提供一个
列表
，并得到一个
列表
，然后在稍后遇到一个无法解释的
类异常
。忘了它-现在可以用了！感谢您的提示，我没有意识到.remove（）实际上返回了一些东西，这与我所要查找的内容（update2）非常接近-目前唯一的问题是编译错误：“未处理的异常类型IllegalAccessException”在向对象添加新实例时-顺便说一句，我不应该“重置”吗/在将对象返回池时重新初始化对象？newInstance（）需要公共默认构造函数。我将稍微修改一下代码，这样您就可以通过重写方法来创建没有默认构造函数的类的实例
public class ObjectPool<T> {
    private List<T> objects;
    private Class<T> clazz;
    private int size;

    public ObjectPool(Class<T> clazz, int size) throws IllegalStateException {
        this.clazz = clazz;
        this.size = size;
        this.objects = new ArrayList<T>();
        for (int i = 0;i < size;i++) {
            objects.add(newInstance());
        }
    }

    // You can override this method with anonymous class
    protected T newInstance() {
        try {
            return clazz.newInstance()
        } catch (Exception exception) {
            throw new IllegalStateException(exception);
        }
    }

    public synchronized T getInstance() {
        if (objects.isEmpty()) {
            return null;
        }
        return objects.remove(objects.size() - 1);
    }

    public synchronized void returnInstance(T instance) {
        if (objects.size() < size) {
            objects.add(instance);
        }
    }
}