Android 随机精灵与精灵池

我想知道雪碧池是如何运作的，因为我不太了解它们。 我试图做的是在用户每次触摸按钮时显示随机精灵（我已经管理了控件），但我的代码似乎不正确，因为它只会一次又一次地显示相同的精灵

这是我的代码：

public class SpritePool extends GenericPool<Sprite> {
    private ITextureRegion mTexture1, mTexture2, mTexture3, mTexture4, mTexture5;

    private VertexBufferObjectManager mVertexBufferObjectManager;

    private Sprite sprite = null;

    public SpritePool(ITextureRegion pTextureRegion1, ITextureRegion pTextureRegion2, ITextureRegion pTextureRegion3
                    , ITextureRegion pTextureRegion4, ITextureRegion pTextureRegion5, VertexBufferObjectManager pVerTexBufferObjectManager){
                    this.mTexture1 = pTextureRegion1;
                    this.mTexture2 = pTextureRegion2;
                    this.mTexture3 = pTextureRegion3;
                    this.mTexture4 = pTextureRegion4;
                    this.mTexture5 = pTextureRegion5;
                    this.mVertexBufferObjectManager = pVerTexBufferObjectManager;          
            }

    @Override
    protected Sprite onAllocatePoolItem() {

            YesOrNoActivity.setRoll_1(MathUtils.RANDOM.nextInt(5) + 1);

            switch(YesOrNoActivity.getRoll_1()){
                    case 1:
                                    sprite = new Sprite(0, 0, this.mTexture1, this.mVertexBufferObjectManager);
                                    break;
                    case 2:
                                    sprite = new Sprite(0, 0, this.mTexture2, this.mVertexBufferObjectManager);
                                    break;
                    case 3:
                                    sprite = new Sprite(0, 0, this.mTexture3, this.mVertexBufferObjectManager);
                            break;
                    case 4:
                                    sprite = new Sprite(0, 0, this.mTexture4, this.mVertexBufferObjectManager);
                                    break;
                    case 5:
                                    sprite = new Sprite(0, 0, this.mTexture5, this.mVertexBufferObjectManager);
                            break;
            }
            return sprite;
    }

    public synchronized Sprite obtainPoolItem(final float pX, final float pY) {
            Sprite sprite = super.obtainPoolItem();
            sprite.setPosition(pX, pY);
            sprite.setVisible(true);        
            sprite.setIgnoreUpdate(false);
            sprite.setColor(1,1,1);
            return sprite;
    }

    @Override
    protected void onHandleRecycleItem(Sprite pItem) {
            super.onHandleRecycleItem(pItem);
            pItem.setVisible(false);
            pItem.setIgnoreUpdate(true);
            pItem.clearEntityModifiers();
            pItem.clearUpdateHandlers();
    }
}

public类SpritePool扩展了GenericPool{
私有ITextureRegion mTexture1、mTexture2、mTexture3、mTexture4、mTexture5；
私有VertexBufferObjectManager mVertexBufferObjectManager；
私有精灵精灵=null；
公共SpritePool（ITextureRegion pTextureRegion1、ITextureRegion pTextureRegion2、ITextureRegion pTextureRegion3
，ITextureRegion PtextureRegion 4，ITextureRegion PtextureRegion 5，VertexBufferObjectManager pVerTexBufferObjectManager）{
this.mTexture1=pTextureRegion1；
this.mTexture2=pTextureRegion2；
this.mTexture3=pTextureRegion3；
this.mTexture4=pTextureRegion4；
this.mTexture5=pTextureRegion5；
this.mVertexBufferObjectManager=pVerTexBufferObjectManager；
}
@凌驾
受保护的精灵onAllocatePoolItem（）{
YesOrNoActivity.setRoll_1（MathUtils.RANDOM.nextInt（5）+1）；
开关（YesOrNoActivity.getRoll_1（））{
案例1：
sprite=新的sprite（0，0，this.mTexture1，this.mVertexBufferObjectManager）；
打破
案例2：
sprite=新的sprite（0，0，this.mTexture2，this.mVertexBufferObjectManager）；
打破
案例3：
sprite=新sprite（0，0，this.mTexture3，this.mVertexBufferObjectManager）；
打破
案例4：
sprite=新sprite（0，0，this.mTexture4，this.mVertexBufferObjectManager）；
打破
案例5：
sprite=新的sprite（0，0，this.mTexture5，this.mVertexBufferObjectManager）；
打破
}
返回精灵；
}
公共同步精灵获取池项目（最终浮点pX，最终浮点pY）{
Sprite Sprite=super.obtainPoolItem（）；
sprite.设置位置（pX，pY）；
sprite.setVisible（真）；
sprite.setIgnoreUpdate（false）；
雪碧色（1,1,1）；
返回精灵；
}
@凌驾
把手上受保护的空隙（雪碧坑）{
super.onHandleRecycleItem（pItem）；
pItem.setVisible（假）；
pItem.setIgnoreUpdate（true）；
pItem.clearEntityModifiers（）；
pItem.clearUpdateHandlers（）；
}
}

---

希望你们能帮助我，谢谢：）

我将向你们展示我的应用程序中的一个简单的奶牛池，让你们了解这些池是如何工作的。“我的牛池”被用作生成牛生物的来源（NPC奶牛，它们四处走动、吃草，通常做你期望从奶牛身上做的事情）。代码如下：

public class CowPool extends GenericPool<CowCritter> {
private final String        TAG = this.getClass().getSimpleName();

public CowPool() {
    super();
}

@Override
protected CowCritter onAllocatePoolItem() {
    return new CowCritter();
}

protected void recycle(CowCritter cow) {
    this.recyclePoolItem(cow);
}

}

公共类CowPool扩展了GenericPool{
私有最终字符串标记=this.getClass（）.getSimpleName（）；
公共牛池（）{
超级（）；
}
@凌驾
受保护的CowCriter onAllocatePoolItem（）{
返回新的CowCritter（）；
}
受保护的空隙回收（CowCritter cow）{
这是一种可回收的沸石（牛）；
}
}

您将看到有两种方法，一种是分配池项目（生成新的cow），另一种是回收cow。当我需要cow时，我不调用这两个方法中的任何一个，而是调用cowPool.ActainPoolItem（）。如果池中有一头奶牛，它会将奶牛退回。如果没有，它将调用onAllocatePoolItem（），创建一个新的cow，并返回该cow。当我处理完给定的奶牛后，我使用recycle（）方法将其扔回池中

这一切有什么意义？

首先要注意的是，我不必做这些。相反，当我需要一头奶牛时，我可以实例化一头新奶牛，然后把它扔掉。要理解的关键点是，当我实例化一个新的cow时，它会有开销。它分配内存资源。等等同样，当我处理一头牛时，它也有资源。在某个时候，垃圾收集将不得不清理这头奶牛，这需要一点处理时间

联营本质上只是一种循环利用的形式。我知道我将来还需要一头牛，所以我不是永久性地处理这头牛，而是把它放在水池里，等我需要牛的时候，牛就在那里等着我。不涉及垃圾收集，因为池中有多余的奶牛。实例化一个新的cow速度更快，因为我并不是真的实例化一个新的cow，cow已经在池中了（除非cow没有，否则它会生成一个）

了解池是一种优化形式也很重要。通过共享，您不会获得新的功能；相反，您正在获得一种潜在的更智能的资源处理方式。我说可能，因为池对象并不总是有意义的

我建议你不要仅仅为了拼凑而拼凑。换句话说，确保你在解决一个实际问题。分析代码并找出真正的瓶颈所在。如果对象的创建或处理占用了实时或内存，则可能需要启动池。汇集资金的最佳机会是子弹。想象一下，你正在喷洒成吨的子弹，制造新的子弹，处理旧的子弹。在这种情况下，您可以通过池来获得真正的性能优势

---

希望这有帮助。

哇，这真的很有帮助。然后，我真的不需要池，因为我没有太多相同的精灵加载。但是怎么做呢