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"";
	}

}

测试运行结果：