软件设计-享元模式

围棋
设计一个围棋软件，在系统中只存在一个白棋对象和一个黑棋对象，但是它们可以在棋盘的不同位置显示多次。

 

类图

 

 

Java

package rjsj.no13;

/**
 * 客户端测试类
 *
 */
public class Client {
    public static void main(String[] args) {
        IgoChessman black1,black2,black3,white1,white2;
        IgoChessmanFactory factory;
        factory = IgoChessmanFactory.getInstance();
        black1 = factory.getIgoChessman("b");
        black2 = factory.getIgoChessman("b");
        black3 = factory.getIgoChessman("b");
        System.out.println("判断两颗黑棋是否相同："+(black1==black2));

        white1 = factory.getIgoChessman("w");
        white2 = factory.getIgoChessman("w");
        System.out.println("判断两颗白棋是否相同："+(white1==white2));

        black1.locate(new Coordinates(1, 1));
        black2.locate(new Coordinates(2, 4));
        black3.locate(new Coordinates(2, 3));
        white1.locate(new Coordinates(3, 5));
        white2.locate(new Coordinates(2, 6));
    }

}

package rjsj.no13;

/**
 * 坐标类：外部状态类
 *
 */
public class Coordinates {
    private int x;
    private int y;

    public Coordinates(int x,int y) {
        // TODO Auto-generated constructor stub
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

}

package rjsj.no13;

/**
 * 围棋棋子类：抽象享元类
 *
 */
public abstract class IgoChessman {
    public abstract String getColor();
    public void locate(Coordinates coord){
        System.out.println("棋子颜色："+this.getColor()+",棋子位置："+coord.getX()+","+coord.getY());
    }
}
/**
 * 黑色棋子类：具体享元类
 * @author fly
 *
 */
class BlackIgoChessman extends IgoChessman{

    @Override
    public String getColor() {
        // TODO Auto-generated method stub
        return "黑色";
    }

}
/**
 * 白色棋子类：具体享元类
 * @author fly
 *
 */
class WhiteIgoChessman extends IgoChessman{

    @Override
    public String getColor() {
        // TODO Auto-generated method stub
        return "白色";
    }

}

package rjsj.no13;

import java.util.Hashtable;

/**
 * 围棋棋子工厂类：享元工厂类
 *
 */
public class IgoChessmanFactory {
    private static IgoChessmanFactory instance = new IgoChessmanFactory();
    private static Hashtable ht;

    public IgoChessmanFactory() {
        // TODO Auto-generated constructor stub
        ht = new Hashtable();
        IgoChessman black,white;
        black = new BlackIgoChessman();
        ht.put("b", black);
        white = new WhiteIgoChessman();
        ht.put("w", white);
    }

    public static IgoChessmanFactory getInstance(){
        return instance;
    }

    public static IgoChessman getIgoChessman(String color){
        return (IgoChessman)ht.get(color);
    }

}

 

C++

#include <iostream>
#include <map>
#include <vector>
using namespace std;

typedef struct Coordinates{
    int x;
    int y;

    Coordinates(){}
    Coordinates(int a, int b){x=a;y=b;}

    bool operator <(const Coordinates& other) const{
        if (x<other.x) return true;
        else if (x==other.x) return y<other.y;
        return false;
    }
}POINT;

typedef enum PieceColorTag{
    BLACK,
    WHITE
}PIECECOLOR;

class CPiece{
public:
    CPiece(PIECECOLOR color) : m_color(color){}
    PIECECOLOR GetColor() { return m_color; }
    void SetPoint(POINT point) { m_point = point; }
    POINT GetPoint() { return m_point; }

protected:
    PIECECOLOR m_color;
    POINT m_point;
};

class CGomoku : public CPiece{
public:
    CGomoku(PIECECOLOR color) : CPiece(color){}
};

class IgoChessmanFactory{
public:
    CPiece *GetPiece(PIECECOLOR color){
        CPiece *pPiece = NULL;
    if (m_vecPiece.empty()){
        pPiece = new CGomoku(color);
        m_vecPiece.push_back(pPiece);
    }
    else{
        for (vector<CPiece *>::iterator it = m_vecPiece.begin(); it != m_vecPiece.end(); ++it){
            if ((*it)->GetColor() == color){
                pPiece = *it;
                break;
            }
        }
        if (pPiece == NULL){
            pPiece = new CGomoku(color);
            m_vecPiece.push_back(pPiece);
        }
     }
        return pPiece;
    }

    ~IgoChessmanFactory(){
        for (vector<CPiece *>::iterator it = m_vecPiece.begin(); it != m_vecPiece.end(); ++it){
            if (*it != NULL){
                delete *it;
                *it = NULL;
            }
        }
    }

private:
    vector<CPiece *> m_vecPiece;
};

class IgoChessman{
public:
    void Draw(CPiece *piece){
        if (piece->GetColor()){
            cout<<"白色棋子位置："<<piece->GetPoint().x<<","<<piece->GetPoint().y<<endl;
        }
        else{
            cout<<"黑色棋子位置："<<piece->GetPoint().x<<","<<piece->GetPoint().y<<endl;
        }
        m_mapPieces.insert(pair<POINT, CPiece *>(piece->GetPoint(), piece));
    }

    void ShowAllPieces(){
        for (map<POINT, CPiece *>::iterator it = m_mapPieces.begin(); it != m_mapPieces.end(); ++it){
            if (it->second->GetColor()){
                cout<<"("<<it->first.x<<","<<it->first.y<<")白色棋子"<<endl;
            }
            else{
                cout<<"("<<it->first.x<<","<<it->first.y<<")黑色棋子"<<endl;
            }
        }
    }

private:
    map<POINT, CPiece *> m_mapPieces;
};

int main(){
    IgoChessmanFactory *pPieceFactory = new IgoChessmanFactory();
    IgoChessman *pCheseboard = new IgoChessman();
    CPiece *pPiece = pPieceFactory->GetPiece(WHITE);
    pPiece->SetPoint(POINT(1, 1));
    pCheseboard->Draw(pPiece);
    pPiece = pPieceFactory->GetPiece(BLACK);
    pPiece->SetPoint(POINT(3, 5));
    pCheseboard->Draw(pPiece);
    pPiece = pPieceFactory->GetPiece(WHITE);
    pPiece->SetPoint(POINT(2, 2));
    pCheseboard->Draw(pPiece);
    pPiece = pPieceFactory->GetPiece(BLACK);
    pPiece->SetPoint(POINT(1, 4));
    pCheseboard->Draw(pPiece);
}

 

运行截图