面向对象-纸牌游戏实验

 实验项目名称：纸牌游戏 

实验目的：

设计一个简单的CardGames程序，运用面向对象封装、继承、抽象类、抽象方法、多态、动态绑定等概念。

实验目标与要求：

参考windows的纸牌游戏

使用语言：java

实验内容：

单人纸牌游戏，牌桌上有7个堆共28张牌，第一堆1张牌，第二堆2张，。。。第7堆7张，每一堆的第一张牌朝上，其他朝下。牌桌上还有4个suitpiles，一个deck card堆和一个discard card堆，布局如下（参考windows的纸牌游戏）

 

程序的总体设计：

利用CRC (Class,Responsibility,and Collaboration)　方法来设计，由于实验是自己一人独立完成，在设计时没有多人参与crc设计，自己扮演了多个角色。

UML图：

 

 

 

 

 

主要代码及其说明:

1.     发配算法：

位于solitaire.game.Game类里面

1. static{ 
2.         //初始化纸牌 
3.         allCard = new ArrayList<Card>(); 
4.         for (int i = 0; i < 4; i++) 
5.             for (int j = 0; j <= 12; j++)  
6.                 allCard.add(new Card(j, i)); 
7.         Random generator = new Random(); 
8.         for (int i = 0; i < 52; i++) { 
9.             int j = Math.abs(generator.nextInt() % 52); 
10.                 // swap the two card values 
11.             Card temp = allCard.get(i); 
12.             allCard.set(i, allCard.get(j)); 
13.             allCard.set(j, temp); 
14.         } 
15.         //初始化牌堆 
16.         allPiles = new CardPile[13]; 
17.         suitPile = new SuitPile[4]; 
18.         tablePile = new TablePile[7]; 
19.             // then fill them in 
20.         allPiles[0] = deckPile = new DeckPile(200, 40); 
21.         allPiles[1] = discardPile = new DiscardPile(200+Card.width+50, 40); 
22.         for (int i = 0; i < 4; i++) 
23.             allPiles[2+i] = suitPile[i] = 
24.                 new SuitPile(200+Card.width+50 + Card.width + 150 + (40+Card.width) * i, 40); 
25.         for (int i = 0; i < 7; i++) 
26.             allPiles[6+i] = tablePile[i] = 
27.                 new TablePile(200 + (50+Card.width) * i, 40 + Card.height + 40, i);  
28.         for (int i = 0; i < 7; i++){ 
29.             ArrayList<Card> al = new ArrayList<Card>(); 
30.             for(int j = 0;j < tablePile[i].getCardNum();j++){ 
31.                 al.add(allCard.remove(allCard.size()-1)); 
32.             } 
33.             tablePile[i].addCard(al); 
34.             tablePile[i].setCardNum(tablePile[i].getNotFlipNum()+1); 
35.             //System.out.println(tablePile[i].getCardNum()); 
36.             tablePile[i].top().setFaceup(true); 
37.         } 
38.         int rest =  allCard.size(); 
39.         for(int i = 0;i < rest;i++ ){ 
40.             deckPile.addCard(allCard.remove(allCard.size()-1)); 
41.             //System.out.println( i); 
42.         } 
43.         moveCard = new MoveCardPile(); 
44.     } 

说明：该算法先创建52张纸牌（Card）对象，并放置allCard（ArrayList）中，然后模拟现实当中的洗牌操作，主要是利用java的Random来打乱allCard里牌的排列顺序，然后初始化各个牌堆类: deckPile, discardPile, tablePile, suitPile, moveCard。此外还建了一个数组allPiles（CardPile[]），用于存储所有的牌堆类。最后将allCard中的纸牌牌(Card)对象分发至各个堆里。

2. select方法（solitaire.pile. CardPile）：

传给该函数坐标用于判断点中该牌堆中的某张纸牌（还有个include方法用于判断是否点中牌堆），其中因为TablePile要支持选中多张纸牌，要改写CardPile的方法。

CardPile的select方法：

1. public int select (int tx, int ty) { 
2.  
3.     if(includes(tx,ty)){ 
4.  
5.        if(isEmpty()) 
6.  
7.            return -2; 
8.  
9.        else 
10.  
11.            return thePile.size() - 1; 
12.  
13.     } 
14.  
15.     else 
16.  
17.        return -1; 
18.  
19. } 

TablePile的select方法:

1. public int select(int tx, int ty) { 
2.  
3.        // TODO Auto-generated method stub 
4.  
5.        if(!(isEmpty())){ 
6.  
7.        int beginX,beginY,endX,endY; 
8.  
9.        //System.out.println(notFlipNum+"  "+cardNum); 
10.  
11.        beginX = x  ; 
12.  
13.        beginY = y + unFlipCardSeparation * notFlipNum; 
14.  
15.        endX = x + Card.width; 
16.  
17.        endY =  beginY  + unFlipCardSeparation * notFlipNum + separation * (thePile.size() - 1 - notFlipNum) + Card.height; 
18.  
19.        boolean flip_include =  beginX <= tx && tx <= endX && beginY <= ty && ty <= endY; 
20.  
21.        //System.out.println(beginY+"   "+endY); 
22.  
23.        if(flip_include){ 
24.  
25.          
26.  
27.         int c = (ty - beginY)/separation + notFlipNum; 
28.  
29.         if(c >= thePile.size()){ 
30.  
31.            c =  thePile.size() - 1; 
32.  
33.         } 
34.  
35.         return c;//从零开始 
36.  
37.        } 
38.  
39.        else 
40.  
41.            return -1; 
42.  
43.        } 
44.  
45.        else 
46.  
47.            return -1; 
48.  
49.     } 
50.  
51.   

3. isCanAdd方法

用于判断某张纸牌是否可以放于SuitePile或TablePile

CardPile类：

1. public boolean isCanAdd(Card card){ 
2.  
3.     return false; 
4.  
5. } 

SuitePile类：

1. public boolean isCanAdd(Card card) { 
2.  
3.         // TODO Auto-generated method stub 
4.  
5.         if (isEmpty()) 
6.  
7.             return card.getNum() == 0; 
8.  
9.         Card toptopCard = top(); 
10.  
11.         return (card.getType() == topCard.getType()) && 
12.  
13.             (card.getNum() ==  topCard.getNum() + 1); 
14.  
15.         
16.  
17.     } 

Tablepile类：

1. public boolean isCanAdd(Card card){ 
2.  
3.         // TODO Auto-generated method stub 
4.  
5.         if ( isEmpty()) 
6.  
7.             return card.getNum() == 12; 
8.  
9.         Card toptopCard = top(); 
10.  
11.         return (card.getColor() != topCard.getColor()) && 
12.  
13.             (card.getNum() ==  topCard.getNum()-1 ); 
14.  
15.     } 

4. refreshTablePile

用于刷新Tablepile，主要用于处理一走TablePile中的纸牌时剩余纸牌都是背面的时候，将最上面的纸牌翻转过来。

1. public static void refreshTablePile(){ 
2.  
3.     //  System.out.println("refreshTablePile"); 
4.  
5.            
6.  
7.         for(int i=0;i<7;i++){ 
8.  
9.             if(tablePile[i].top() != null) 
10.  
11.             if(!(tablePile[i].top().isFaceup())){ 
12.  
13.                 tablePile[i].top().setFaceup(true); 
14.  
15.                 tablePile[i].setNotFlipNum(tablePile[i].getNotFlipNum()-1); 
16.  
17.             } 
18.  
19.         } 
20.  
21.     } 

实验截图：

 实验心得：

结合课堂上的学习，利用了面向对象的思想：继承，多态（改写，多台变量），范型等等，对面向对象思想有了更好的把握。

后来学习了设计原则，我觉得还得自己写的代码违背了许多原则，例如Game里面的CardPile不是抽象的，应将其声明为抽象的以便让其他类依赖抽象。此外我觉得可利用mvc架构来设计纸牌游戏，利用观察者模式来处理model的更改来更新view，用组成模式来设计view，利用策略模式来设计control。目前只初步设计了一下新的纸牌游戏。

转载于:https://blog.51cto.com/zhbhun/750109