java撲克識別演算法

Ⅰ java撲克牌編程

1.定義撲克的對象 有兩個參數a。花色，b數字Poke{ int number, String color, Poker(String color,int number) { this.color=color; this.number=number; }} 2.每一張牌都實例化一個撲克對象。 poke1= new Poke("紅桃","10");poke2=new Poke("黑桃","9"); 3.定義游戲規則類，類里定義一個方法，用來比較大小。public comparePoke(Poke poke1,Poke poke2){ if(花色比較){ return 結果； } if(數字比較){ return 結果； }}。調用方法就能比較

Ⅱ 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

Ⅲ 用Java for 編寫關於撲克牌的程序！急！

存儲時可以用數字，最後顯示時可以裝換為字母
import java.util.Random;

public class Poker {
public static void main(String[] args) {
Random random = new Random();
int[] computer = new int[5];
int[] player = new int[5];
for (int i = 0; i < 5; i++) {// 發牌
computer[i] = random.nextInt(13) + 2;// 2到14的隨機數，14表示A
player[i] = random.nextInt(13) + 2;// 2到14的隨機數，14表示A
}
int result = Judge(player, computer);
Show(player, computer, result);
}

// 比較
private static int Judge(int[] player, int[] computer) {
int p = 0, c = 0;
for (int i = 0; i < 5; i++) {
if (14 == player[i])
p++;
if (14 == computer[i])
c++;
}
if (p > 0 && 0 == c)
return 1;
if (p == 0 && c > 0)
return 2;
return 0;

}

private static void Show(int[] player, int[] computer, int result) {
System.out.print("Your cards are:");
for (int i = 0; i < 5; i++) {
PrintCard(player[i]);
}
System.out.print("\nThe computer's cards are:");
for (int i = 0; i < 5; i++) {
PrintCard(computer[i]);
}
switch (result) {
case 0:
System.out.print("\nYou and the computer are tied for the highest single card.");
break;
case 1:
System.out.print("\nYou has the highest single card.");
break;
case 2:
System.out.print("\nThe computer has the highest single card.");
break;

}

}

private static void PrintCard(int card) {
switch (card) {
case 11:
System.out.print("J ");
break;
case 12:
System.out.print("Q ");
break;
case 13:
System.out.print("K ");
break;
case 14:
System.out.print("A ");
break;
default:
System.out.print(card + " ");
}
}

void m() {
int[] personCard = new int[5];
int[] computerCard = new int[5];
int personCount = 0;
int computerCount = 0;

System.out.print("Your cards are: ");
for (int i = 0; i < 5; i++) {
personCard[i] = (int) (Math.random() * 13) + 2;
if (personCard[i] == 11) {
System.out.print("J" + "\t");
} else if (personCard[i] == 12) {
System.out.print("Q" + "\t");
} else if (personCard[i] == 13) {
System.out.print("K" + "\t");
} else if (personCard[i] == 14) {
personCount++;
System.out.print("A" + "\t");
} else {
System.out.print(personCard[i] + "\t");
}
}
System.out.println("\n");
System.out.print("The computer's cards are:");
for (int i = 0; i < 5; i++) {
computerCard[i] = (int) (Math.random() * 13) + 1;
if (computerCard[i] == 11) {
System.out.print("J" + "\t");
} else if (computerCard[i] == 12) {
System.out.print("Q" + "\t");
} else if (computerCard[i] == 13) {
System.out.print("K" + "\t");
} else if (computerCard[i] == 14) {
computerCount++;
System.out.print("A" + "\t");
} else {
System.out.print(computerCard[i] + "\t");
}
}
System.out.println("\n");
if (personCount > 0 && computerCount == 0) {
System.out.println("You has the highest single card");
} else if (personCount == 0 && computerCount > 0) {
System.out.println("The computer has the highest single card");
} else if (personCount == 0 && computerCount == 0) {
System.out.println("You and the computer are tied for the highest single card");
} else if (personCount > 0 && computerCount > 0) {
System.out.println("Both you and the computer have the highest single card");
}

}
}

Ⅳ 用java如何判斷撲克牌同花順

撲克牌有兩個屬性,花色和牌面大小,可以分別比較花色和牌面大小是否遞增或遞減來確定是不是同花順.但是由於撲克牌會有JQKA,所以牌面大小最好以數組或者字元串的方式實現,通過比較下標來比較大小,以下是大概的代碼

publicclassPuKe{
	privateStringcolor;
	privateStringnum;
	publicStringgetColor(){
		returncolor;
	}
	publicvoidsetColor(Stringcolor){
		this.color=color;
	}
	publicStringgetNum(){
		returnnum;
	}
	publicvoidsetNum(Stringnum){
		this.num=num;
	}
	
	publicPuKe(Stringcolor,Stringnum){
		super();
		this.color=color;
		this.num=num;
	}
	publicstaticvoidmain(String[]args){
		List<PuKe>card=newArrayList<PuKe>();
		card.add(newPuKe("black","2"));
		card.add(newPuKe("black","3"));
		card.add(newPuKe("black","4"));
		card.add(newPuKe("black","5"));
		card.add(newPuKe("black","6"));
		//這里因為10是兩位數且牌面裡面用不到1,所以直接用1代替10
		Stringcheck="234567891JQKA";
		booleanflage=true;
		//自定義比較器,用num在check里的下標大小作為比較依據排序
		Collections.sort(card,newComparator<Object>(){
			@Override
			publicintcompare(Objecto1,Objecto2){
				PuKeer1=(PuKe)o1;
				PuKeer2=(PuKe)o2;
				Integerorg1=(int)(er1.getNum()==null?0.0:check.indexOf(er1.getNum()));
				Integerorg2=(int)(er1.getNum()==null?0.0:check.indexOf(er2.getNum()));
				returnorg1.compareTo(org2);
			}
		});
		for(inti=0;i<card.size()-1;i++){
			//遍歷所有的牌,如果顏色不一樣直接跳出循環,不是同花順
			if(!card.get(i).getColor().equals(card.get(i+1).getColor())){
				flage=false;
				break;
			}
			//如果上一張減去下一張的差值不是1,說明牌面不是順子,也不是同花順,跳出循環
			if((int)check.indexOf(card.get(i+1).getNum())-(int)check.indexOf(card.get(i).getNum())!=1){
				flage=false;
				break;
			}
		}
		if(flage){
			System.out.println("牌面是同花順");
		}else{
			System.out.println("牌面不是同花順");
		}
	}
}

不過這種方法唯一不好的地方是check中不能直接用10,將來展示的時候需要判定,展示的是1時直接改成10.

其實實現方法很多,我這么寫是因為最近在復習,這么寫用到的知識點相對會多一點.

Ⅳ java 二位數組中 判斷撲克的最大的牌型

寫代碼不難..給你一個思路 你就按照這個思路寫.
首先按照7張牌的大小 存到一個hashmap<integer,integer> 存的每種數字 及其 出現的次數..
當 hashMap 的count <5 意味著 他們不可能存在 同花順 同花之類的..那麼你可以輕松的判斷裡面到底是 4條 3條之類的 這個很簡單...
當 count >= 5的時候 你就需要判斷是否為同花 或者同花順了..
這個也簡單 你在按照花色 進行一次 hashmap 然後看看是否有同一個花色超過5的的..如果沒有 則不可能為同花...同樣 順子的判斷也根據所有的數字 去重復之後排序..看有沒有5個連續的數字..如果沒有 就不是順子..
這樣就可以搞定了

Ⅵ Java撲克牌問題

使用JAVA編寫以下程序：
1、請定義一個名為Card的撲克牌類，該類有兩個private訪問許可權的字元串變數face和suit；分別描述一張牌的牌面值（如：A、K、Q、J、10、9、……3、2等）和花色（如：「黑桃」、「紅桃」、「梅花」、「方塊」）；定義Card類中的public訪問許可權的構造方法，為類中的變數賦值；定義protected訪問許可權的方法getFace()，得到撲克牌的牌面值；定義protected訪問許可權的方法getSuit()，得到撲克牌的花色；定義方法toString()，返回表示撲克牌的花色和牌面值字元串（如「紅桃A」、「梅花10」等）。

2、若應用程序的main方法中，定義字元串數組f和s；分別表示撲克牌的牌面值和花色；定義52個元素的Card類型數組deck，用來存放4個花色的52張牌。如下所示。
String f[] = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
String s[] = {"黑桃","紅桃","梅花","方塊"};
Card deck = new Card[52]；
（1）使用Card類的構造方法給deck數組的52張牌賦值，要求數組中先存放黑桃花色的A、2、3、……、K；然後是紅桃花色的A、2、3、……、K；梅花花色的A、2、3、……、K；方塊花色的A、2、3、……、K。請寫出實現上述功能的程序段。
（2）請編寫模擬洗牌的完整程序，即把數組deck中的撲克牌隨機打亂存放順序。

原題如下：

引用內容
private String face; // A, K, Q, J, 10, ... 2
private String suit; // Spade, Heart, Club, Diamond
public Card(String suit, String face) {
this.face = face;
this.suit = suit;
}

protected String getFace() {
return face;
}

protected String getSuit() {
return suit;
}

public String toString() {
return suit + " " + face;
}

解題，完成程序解：

程序代碼
package poker;

public class Card {

private String face; // A, K, Q, J, 10, ... 2
private String suit; // Spade, Heart, Club, Diamond
public Card(String suit, String face) {
this.face = face;
this.suit = suit;
}

protected String getFace() {
return face;
}

protected String getSuit() {
return suit;
}

public String toString() {
return suit + " " + face;
}

public static void shuffle(Card[] deck, int startIndex, int size,
int splitIndex) { //shuffle洗牌
System.out.println("startIndex:" + startIndex);
if (splitIndex * 2 > size) { //if rand is 30
Card.swap(deck, startIndex, splitIndex, size - splitIndex); //[52]、0、30、22
shuffle(deck, size - splitIndex, splitIndex, size - splitIndex); //[52]、22、30、22
} else if (splitIndex * 2 < size) { //if rnd is 10
Card.swap(deck, startIndex, size - splitIndex, splitIndex); //[52]、0、42、10
shuffle(deck, startIndex, size - splitIndex, splitIndex); //[52]、0、42、10
} else {
Card.swap(deck, startIndex, splitIndex, splitIndex);
}

}

public static void swap(Card[] deck, int srcIndex, int dstIndex, int size) { //交換
//SRC是在本位置顯示：source的縮寫，源的意思 HREF是點擊後連接的目標：HyperlinkReference，超鏈接引用
String face = "";
String suit = "";
for (int i = 0; i < size; i++) {
face = deck[srcIndex + i].face;
suit = deck[srcIndex + i].suit;
deck[srcIndex + i].face = deck[dstIndex + i].face;
deck[srcIndex + i].suit = deck[dstIndex + i].suit;
deck[dstIndex + i].face = face;
deck[dstIndex + i].suit = suit;
}
}

/**
* @param args
*/
public static void main(String[] args) {
//第一問解答
Card[] deck = new Card[52];
String f[] = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J",
"Q", "K"};
String s[] = {"Spade", "Heart", "Club", "Diamond"};
for (int i = 0; i < s.length; i++) {
for (int j = 0; j < f.length; j++) {
deck[i * 13 + j] = new Card(s[i], f[j]); //依次存入數組之中，每13張一回合
}
}
//第二問解答
int rnd = 0;
int numOfShuffle = 10;
for (int i = 0; i < numOfShuffle; i++) {
rnd = (int) Math.abs(Math.random() * 52); //Math.random()返回大於或等於 0.0 但小於 1.0 的偽隨機 double 值。

Card.shuffle(deck, 0, deck.length, rnd);
}
// Test
/*
for (int i=0; i<deck.length; i++)
{
System.out.println(deck[i]);
} */
}

}

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

}

測試運行結果：

Ⅷ JAVA編程判斷撲克牌大小

importjava.util.*;

publicclassMain{
	publicstaticvoidmain(String[]args){
		Scannerscanner=newScanner(System.in);
		List<String>list=newArrayList<String>();
		while(scanner.hasNextLine()){
			Stringstring=scanner.nextLine();
			list.add(string);
			if(list.size()==5){
				intr=getCard(list);
				System.out.println(r);
				list.clear();
			}
		}
	}

	privatestaticintgetCard(List<String>list){
		inttemp=7;
		intsize=list.size();
		List<String>numList=newArrayList<String>();
		Set<String>numSet=newTreeSet<String>();
		List<String>colourList=newArrayList<String>();
		Set<String>colourSet=newTreeSet<String>();
		for(inti=0;i<list.size();i++){
			Stringnum=list.get(i).split("")[0];
			Stringcolour=list.get(i).split("")[1];
			if(num.equals("J")){
				numList.add("11");
				numSet.add("11");
			}elseif(num.equals("Q")){
				numList.add("12");
				numSet.add("12");
			}elseif(num.equals("K")){
				numList.add("13");
				numSet.add("13");
			}elseif(num.equals("A")){
				numList.add("14");
				numSet.add("14");
			}else{
				numList.add(num);
				numSet.add(num);
			}
			colourList.add(colour);
			colourSet.add(colour);
		}
		//同花順,或者同花
		if(colourSet.size()==1){
			Collections.sort(numList);
			for(inti=0;i<numList.size()-1;i++){
				if(Integer.parseInt(numList.get(i+1))-Integer.parseInt(numList.get(i))==1){
					if(i==numList.size()-2){
						temp=1;
					}
					continue;
				}else{
					if(temp>4){
						temp=4;
					}
				}
			}
		}
		//四條或者葫蘆
		if(numSet.size()==2){
			Collections.sort(numList);
			//四條
			if(!numList.get(0).equals(numList.get(1))||!numList.get(size-1).equals(numList.get(size-2))){
				if(temp>2){
					temp=2;
				}
			}else{
				if(temp>3){
					temp=3;
				}
			}
		}
		//三條
		if(numSet.size()==3){
			if(temp>6){
				temp=6;
			}
		}
		//順子
		if(colourSet.size()>1){
			Collections.sort(numList);
			for(inti=0;i<numList.size()-1;i++){
				if(Integer.parseInt(numList.get(i+1))-Integer.parseInt(numList.get(i))==1){
					if(i==numList.size()-2){
						if(temp>5){
							temp=5;
						}
					}
				}else{
					break;
				}
			}
		}
		returntemp;
	}
}

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

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

Ⅹ 用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 方法。
最後，有任何疑問請追問。