objectpool.java

J2ME飞机设计游戏,希望对学习J2ME的程序员有所帮助

/*
 * ActorPool.java
 *
 * Created on 2007年9月17日, 上午9:46
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

/**
 *
 * @author wangquan84
 */
public class ObjectPool {
//    public Actor getFirstUsed() {
//        return firstUsed;
//    }
    
//    public ActorPool(Actor[] initObjects) {
//        if (initObjects == null && initObjects.length < 2)
//            return;
//        firstFree = initObjects[0];
//        lastFree = initObjects[initObjects.length - 1];
//        // 组成双向链表结构(可用对象链表)
//        for (int i = 0; i < initObjects.length; i++) {
//            // 指向下一个
//            if (i < initObjects.length - 1) {
//                initObjects[i].setNextLinked(initObjects[i + 1]);
//            } else {
//                initObjects[i].setNextLinked(null);
//            }
//            
//            // 指向上一个
//            if (i > 0) {
//                initObjects[i].setPrevLinked(initObjects[i - 1]);
//            } else {
//                initObjects[i].setPrevLinked(null);
//            }
//        }
//    }
    
    public ObjectPool(Object[] initObjects) {
		freeActor = new Object[initObjects.length];
		//usedActor = new Object[initObjects.length];
		for (int idx = 0; idx < initObjects.length; idx++) {
			freeActor[idx] = initObjects[idx];
			((Actor) freeActor[idx]).setNotUsed(true);
		}
	}
    
// public Actor getNextFree() {
//        // 如果(可用对象链表)有对象的情况
//        if (firstFree != null) {
//            
//            // 如果firstFree下一个引用不为空
//            if (firstFree.getNextLinked() != null) {
//                // 让得到下一个的链表的节点指向上一个节点为空
//                firstFree.getNextLinked().setPrevLinked(null);
//            }
//            Actor newFirstFree = firstFree.getNextLinked();
//            
//            // 设置firstFree的下一个引用为NULL
//            firstFree.setNextLinked(null);
//            
//            if (lastUsed != null) {
//                firstFree.setPrevLinked(lastUsed);
//                lastUsed.setNextLinked(firstFree);
//            }
//            
//            // (已用对象链表)最后一个节点为firstFree
//            lastUsed = firstFree;
//            
//            // 标示为最老占用的对象
//            if (oldestUsed == null) {
//                oldestUsed = firstFree;
//            }
//            
//            // 如果(已用对象链表)的头节点为空的时候
//            if (firstUsed == null) {
//                firstUsed = firstFree;
//            }
//            
//            // 如果可用链表的头节点和尾节点一样
//            if (lastFree == firstFree) {
//                lastFree = null;
//            }
//            
//            Actor r = firstFree;
//            firstFree = newFirstFree;
//            return r;
//        } else {
//            Actor oldReturn = oldestUsed;
//            // 如果(已用对象链表)被遍历一次后重置
//            if (oldestUsed == null) {
//                oldestUsed = firstUsed;
//                oldReturn = oldestUsed;
//            }
//            
//            // 最老的对象给(已用对象链表)节点的下一个节点
//            oldestUsed = oldestUsed.getNextLinked();
//                    
//            return oldReturn;
//        }
//    }
//    
//    public void releasUsed(Actor releasActor) {
//        // (已用对象链表)里是否有对象
//    	if (releasActor.getPrevLinked() != null)
//			// join the break in the used list
//			releasActor.getPrevLinked().setNextLinked(
//					releasActor.getNextLinked());
//		if (releasActor.getNextLinked() != null)
//			releasActor.getNextLinked().setPrevLinked(
//					releasActor.getPrevLinked());
//
//		// if this actor was the oldestUsed then make it's next take that place
//		if (oldestUsed == releasActor)
//			oldestUsed = releasActor.getNextLinked();
//		if (firstUsed == releasActor)
//			firstUsed = releasActor.getNextLinked();
//		if (lastUsed == releasActor)
//			lastUsed = releasActor.getPrevLinked();
//
//		// now move this actor onto the end of the free list
//		releasActor.setNextLinked(null);
//		if (firstFree == null) {
//			firstFree = releasActor;
//			releasActor.setPrevLinked(null);
//		}
//
//		if (lastFree != null) {
//			releasActor.setPrevLinked(lastFree);
//			lastFree.setNextLinked(releasActor);
//		} else
//			releasActor.setPrevLinked(null);
//
//		lastFree = releasActor;
//	}
    
    public Object getNextFree(){
    	for(int idx = 0;idx<freeActor.length;idx++){
    		if(((Actor)freeActor[idx]).isNotUsed() == true){
    			((Actor)freeActor[idx]).setNotUsed(false);
    			++useObjectNum;
    			return freeActor[idx];
    		}
    	}
    	
    	return null;          
    }
    
    public void releasUsed(Object releasActor){
    	((Actor)releasActor).setNotUsed(true);
    	--useObjectNum;
    }
    
    public Object [] getFreeActor(){
    	return freeActor;
    }
    
    public int getUseObjectNum() {
		return useObjectNum;
	}
    
    public void cleanObjectPool() {
		for (int idx = 0; idx < freeActor.length; idx++) {
			freeActor[idx] = null;
		}
	}
    
    public void realeaseAllObjectPool() {
		for (int idx = 0; idx < freeActor.length; idx++) {
			System.out.println("isNotUsed====" + ((Actor) freeActor[idx]).isNotUsed());
			if (((Actor) freeActor[idx]).isNotUsed() == false) {
				((Actor) freeActor[idx]).setNotUsed(true);
				--useObjectNum;
			}
		}
	}

// private Actor firstFree; // 第一个空闲
//    
//    private Actor lastFree; // 最后一个空闲
//    
//    private Actor firstUsed; // 第一个使用
//    
//    private Actor lastUsed; // 最后一个使用
//    
//    private Actor oldestUsed; // 最老的使用
    
    private Object [] freeActor;
    
    //private Object [] usedActor;
    
    private int useObjectNum = 0; //可用对象的个数
}