java撲克游戲

A. java 52張 撲克牌 問題

識別類：
一張牌：public class Card{};
一副牌：public class Poker{};
帶main方法的類用於實現洗牌和切牌：public class Shuffle{};

識別屬性：
class Card:
一張牌應該具有花色和點數這兩個屬性：
private color; //花色
private value; //點數
class Poker:
一副牌有54張牌，四種花色，每種花色都有2~A的點數：
static Card[] cards=new Card[54]；// 每副撲克都有54張牌；
static String[] colors={"紅桃","黑桃","方塊","梅花"}； //每副牌都有四種花色；
static String values[]={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};//每個花
色的點數
定義類：
public class Card{
String color;
String value;
//定義一個構造函數用於初始化點數2~A的牌
public Card(String color,String value){
this.color = color;
this.value = value;
}
//定義一個構造函數用於初始化大王和小王
public Card(String value){
this.color=""; //如果不給color賦值的話，洗牌和切牌後的大小王前面會顯示「null」
this.value = value;
}
// 取一張牌的花色
public String getcolor() {
return color;
}
// 取一張牌的值
public String getvalue() {
return value;
}
}
public class Poker{
static Card[] cards=new Card[54];
static String[] colors={"紅桃","黑桃","方塊","梅花"};
static String values[]={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
//構造方法Poker（）用於初始化這副撲克
public Poker() {
for (int i = 0; i < colors.length; i++) {
for (int j = 0; j < values.length; j++) {
cards[i * 13 + j] = new Card(colors[i], values[j]);
}
}
cards[52] = new Card("小王");
cards[53] = new Card("大王");
}
//方法getCard()用於獲取一張牌的花色和點數
public Card[] getCard() {
return Poker.cards;
}
//方法Show()用於顯示一副新的撲克
public void Show() {
……………………
}

public class Shuffle {
static Poker poker = new Poker();
static Card[] cards = new Card[54];
//方法random用於返回一個不重復的數組
public static int[] random(int length) {
int[] a = new int[length];
for (int i = 0; i < length; i++) {
a[i] = (int) (Math.random() * length);//產生一個0到length的隨機數
for (int j = 0; j < i; j++) {
if (a[j] == a[i]) {//比較是否相等，如果相等則重新產生
i--;
break;
}
}
}
return a;
}
//方法xipai（）用於將所得的隨機數組的值賦值給牌的下標
public static void xipai() {
int[] b = new int[54];
b = random(54);//調用random方法產生一個長度為54的不重復的隨機數組
cards = poker.getCard();
Card temp = null;
for(int i = 0; i < b.length; i++){ //開始遍歷數組實現重新排列
int k = b[i];
temp = cards[k];
cards[i] = cards[k];
cards[k] = temp;}
//輸出洗牌後的撲克
……………………
……………………
}

//方法qiepai（）實現撲克的切牌操作
public static void qiepai(int length) {
int number = (int) (Math.random() * length);//產生一個隨機數
System.out.println("隨機數為:" + number);//顯示隨機數是多少
Card[] temp = new Card[length];
int start = number;//設置切牌後的起點位置
for (int i = 0; i < length - number; i++) {
temp[i] = cards[start++];//將切點後面的牌暫時放入temp數組中
}
for (int j = 0; j < number; j++) {
temp[length - number + j] = cards[j];//將切點前面的牌加入temp數組中
}
for (int k = 0; k < length; k++) {
cards[k] = temp[k];}
//輸出切牌後的撲克
……………………
……………………
}
//main方法
public static void main(String[] args) {
Poker newpoker = new Poker();
newpoker.Show();//調用Show()方法顯示一副新撲克
xipai();//調用xipai()方法顯示洗牌過後的撲克
qiepai(54);//調用qiepai()方法顯示切牌以後的撲克
}
}
參考資料：http://greenchen84.spaces.live.com/blog/cns!7aa735406579b132!111.entry

B. 用java寫撲克牌游戲，怎麼判斷兩張牌相同呢我用equals怎麼不能成功

應該是沒重寫撲克類的equals()方法，和hashCode()方法
java中equals方法不重寫的話，默認比較的是兩個對象的內存地址，你new兩個撲克類，打死它們倆的內存地址也不可能是相同的。。。。
重寫equals()方法即可，判斷條件是花色和點數相同即為相等的牌。
同時別忘了重寫hashCode()方法，如果只單獨重寫equals方法可能造成撲克對象在Map中的散列值沖突，後果就是你向Map中放入兩張不一樣的牌有可能因為兩張牌的散列值一樣，後添加的覆蓋了前一張牌。

C. 用Java寫一個撲克牌類，撲克牌有花色和大小，並且有一個tostring方法，返回撲克牌的信息

Card[] cards = new Card[54]; // 這是一個數組，是一個普通對象。
Player[] players = new Player[3]; // 這是一個數組，是一個普通對象。
第一行，調用了數組 cards 上索引為 0 的元素的 toString 方法，對應於 Card 類的 toString 方法。
第二行，調用了數組 cards 的 toString 方法，對應於 Card[] 類的 toString 方法，繼承自 Object 類。
第三行，調用了 Arrays 類的 toString 方法，傳入參數是數組 cards ，具體可查找該方法的源碼。
第四行，調用了數組 players 上索引為 0 的元素的 toString 方法，對應於 Player 類的 toString 方法。
第五行，調用了數組 players 的 toString 方法，對應於 Player[] 類的 toString 方法，繼承自 Object 類。
第六行，調用了 Arrays 類的 toString 方法，傳入參數是數組 players ，具體可查找該方法的源碼。
簡單說一下 Arrays.toString() ，它返回是由數組內所有元素的字元串化（toString）合並而成的字元串對象。
因此：
1. 不是同一個 toString 方法，任何對象都可調用自身的 toString 方法。
2. 因為 Player 類的 toString 方法內曾調用了「 Arrays.toString(cards) 」。
4. 任何對象都可調用自身的 toString 方法，數組是對象。
5. 數組是對象，一樣有對應的類型，其類型一樣繼承自 Object 類，繼承了 toString 方法。
最後，有任何疑問請追問。

D. java的問題（撲克牌）

代碼僅供參考，如有疑問，歡迎追問：

importjava.util.ArrayList;
importjava.util.List;
importjava.util.Scanner;

/**
*隨機撲克牌
*@authorSTONE
*@version2015-10-28
*/
publicclassPoker{
	//用於記錄丟失的手牌數
	privatestaticIntegerlostTotal=0;
	//用於存放已下發的撲克
	privatestaticInteger[]its1=newInteger[54];
	//用於存放當前的撲克
	privatestaticInteger[]its2=newInteger[54];
	privatestaticList<Integer>lostList=newArrayList<Integer>();
	
	publicstaticvoidmain(String[]args){
		Scannerscn=newScanner(System.in);
		for(inti=0;i<54;i++){
			its1[i]=0;
			its2[i]=0;
		}
		System.out.println("系統開始發牌...");
		givePoker(5);
		System.out.println("發牌完畢，當前手牌為：");
		printPoker(its2);
		IntegergameTotal=0;
		while(gameTotal<10){//循環跑10次，請注意此處發牌沒做限制，如果循環次數過大，會導致死循環
			System.out.println("請輸入需要丟棄的手牌(多張牌格式如下：黑桃1,黑桃2,黑桃3)：");
			Stringlost=scn.nextLine();
			checkLost(lost);
			System.out.println("丟失手牌完畢，當前手牌：");
			printPoker(its2);
			System.out.println("系統開始重發手牌...");
			givePoker(lostTotal);
			System.out.println("重發發牌完畢，當前手牌為：");
			printPoker(its2);
			gameTotal++;
		}
		scn.close();
	}
	
	publicstaticvoidgivePoker(Integernum){//隨機分發手牌
		inttotal=0;
		while(total<num){
			intpoke=(int)(Math.random()*54);
			if(its1[poke]==0){
				its1[poke]=1;
				its2[poke]=1;
				total++;
			}
		}
		lostTotal=0;
	}
	
	publicstaticBooleancheckLost(Stringlost){//檢查需要丟失的手牌
		if(lost==null||lost.equals("")){
			System.out.println("輸入手牌錯誤，系統無法處理...");
			returnfalse;
		}
		if(lost.indexOf("黑桃")<0&&lost.indexOf("紅心")<0&&lost.indexOf("梅花")<0&&lost.indexOf("方塊")<0){
			System.out.println("輸入手牌錯誤，系統無法處理...");
			returnfalse;
		}
		String[]strs=lost.split(",");
		Booleanbol=false;
		for(Stringstr:strs){
			str=str.trim();
			if(str==null||str.equals(""))continue;//去掉，防止空格
			bol=getPokerNum(str);
		}
		if(bol){
			losePoker();
		}
		returnfalse;
	}
	
	publicstaticvoidlosePoker(){//丟掉手牌
		lostTotal=lostList.size();
		for(Integeritr:lostList){//丟掉手牌
			its2[itr-1]=0;
		}
		lostList=newArrayList<Integer>();
	}
	
	(Stringstr){//獲取手牌點數並去掉
		try{
			Integeritr=0;
			if(str.indexOf("黑桃")==0){
				str=str.replace("黑桃","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("輸入手牌不存在：黑桃"+str);
					returnfalse;
				}
				if(its2[itr-1]==1){
					lostList.add(itr);
				}
			}elseif(str.indexOf("紅心")==0){
				str=str.replace("紅心","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("輸入手牌不存在：紅心"+str);
					returnfalse;
				}
				if(its2[itr+12]==1){
					lostList.add(itr+13);
				}
			}elseif(str.indexOf("梅花")==0){
				str=str.replace("梅花","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("輸入手牌不存在：梅花"+str);
					returnfalse;
				}
				if(its2[itr+25]==1){
					lostList.add(itr+26);
				}
			}elseif(str.indexOf("方塊")==0){
				str=str.replace("方塊","");
				itr=Integer.parseInt(str);
				if(itr>13){
					System.out.println("輸入手牌不存在：方塊"+str);
					returnfalse;
				}
				if(its2[itr+38]==1){
					lostList.add(itr+39);
				}
			}elseif(str.indexOf("小王")==0){
				if(its2[52]==1){
					lostList.add(53);
				}
			}elseif(str.indexOf("大王")==0){
				if(its2[53]==1){
					lostList.add(54);
				}
			}
			returntrue;
		}catch(Exceptione){
			System.out.println("輸入手牌有誤...");
			returnfalse;
		}
	}
	
	publicstaticvoidprintPoker(Integer[]its){//列印當前手牌
		Stringresult="";
		for(inti=0;i<its.length;i++){
			if(its[i]==1){//等於1表示當前手牌存在
				result+=pukerCheck(i+1)+",";
			}
		}
		System.out.println(result);
	}
	
	publicstaticStringpukerCheck(Integeritr){//判斷撲克類型
		/**
		*1~13黑桃花色、14~26紅心花色、27~39梅花花色
		*40~52方塊花色、53小王、54大王
		*/
		if(1<=itr&&itr<=13){
			return"黑桃"+itr;
		}elseif(14<=itr&&itr<=26){
			return"紅心"+(itr-13);
		}elseif(27<=itr&&itr<=39){
			return"梅花"+(itr-26);
		}elseif(40<=itr&&itr<=52){
			return"方塊"+(itr-39);
		}elseif(itr==53){
			return"小王";
		}elseif(itr==54){
			return"大王";
		}
		return"";
	}

}

測試運行結果：