JAVA课程设计纸牌游戏

合集下载

JAVA课程设计纸牌游戏

JAVA课程设计纸牌游戏

一、问题分析和任务定义1.题目:纸牌游戏:编号为1-52张牌,正面向上,从第2张开始,以2为基数,是2的倍数的牌翻一次,直到最后一张牌;然后,从第3张开始,以3为基数,是3的倍数的牌翻一次,直到最后一张牌;然后…从第4张开始,以4为基数,是4的倍数的牌翻一次,直到最后一张牌;。

再依次5的倍数的牌翻一次,6的,7的直到以52为基数的翻过,输出:这时正面向上的牌有哪些?2.要求和任务:①该题目的要求如下:(1)将52张牌编号。

(2)从2开始,依次作为基数对基数的倍数的牌进行翻转,直到以52为基数的翻转。

(3)最后输出正面向上的牌。

②基本任务为:(1)按照要求翻转纸牌。

(2)输出最后正面向上的纸牌的编号。

3.原始数据的输入及输出格式:原始数据要求输入纸牌的基础编号,编号的输入为整型。

输出的是经过规律翻转后正面向上的纸牌的编号。

输入的数据信息如下:纸牌:1、2、3……、51、52。

(注:图中“√”表示翻转一次。

)二.数据结构的选择和概要设计1.数据结构按照题目要求,整个主体包括一个嵌套的循环,外循环控制从2开始每张纸牌都作为基数进行翻牌,内循环控制对所有纸牌进行判断,如果是当前循环中基数的倍数,则对其进行翻转操作。

具体代码如下:for(i=2;i<=52;i++){for(j=1;j<=52;j++){if(j%i==0)data[j-1]=data[j-1]*Flag;}}2.概要设计按照题目的要求,首先,应对52张牌进行编号并且保存它们的编号信息,编号的类型为整型,而对于这样固定的数据,使用整型数组是最好的,因此,我们需要在程序的开始定义一共整型的数组,同时,为了方便对翻转过程的记录,在定义记录编号信息的同时,定义一个与之相对应的标记数组,数组类型为整型。

该程序的核心为一个嵌套的循环,所以定义两个变量i,j作为循环条件。

接着开始对变量进行初始化,首先是编号信息数组,使用for循环对数组进行1到52的赋值,代表52张纸牌,然后对标记数组赋值,将数组内的所有的值初始化为零,方便在接下来的循环中统计每张牌的翻牌数。

【VIP专享】JAVA课程设计纸牌游戏

【VIP专享】JAVA课程设计纸牌游戏
















……
按照题目要求,整个主体包括一个嵌套的循环,外循环控制从 2 开始每张纸牌都作为基数 进行翻牌,内循环控制对所有纸牌进行判断,如果是当前循环中基数的倍数,则对其进行 翻转操作。具体代码如下:
for(i=2;i<=52;i++) { for(j=1;j<=52;j++) { if(j%i==0) data[j-1]=data[j-1]*Flag; } }
一、问题分析和任务定义 1.题目:
纸牌游戏: 编号为 1-52 张牌,正面向上,从第 2 张开始,以 2 为基数,是 2 的倍数的 牌翻一次,直到最后一张牌;然后,从第 3 张开始,以 3 为基数,是 3 的倍数 的牌翻一次,直到最后一张牌;然后 …从第 4 张开始,以 4 为基数,是 4 的倍 数的牌翻一次, 直到最后一张牌; 。。。 再依次 5 的倍数的牌翻一次, 6 的, 7 的直到 以 52 为基数的 翻过,输出:这时正面向上的牌有哪些?
2.概要设计 按照题目的要求,首先,应对 52 张牌进行编号并且保存它们的编号信息,编号的类型
为整型,而对于这样固定的数据,使用整型数组是最好的,因此,我们需要在程序的开始 定义一共整型的数组,同时,为了方便对翻转过程的记录,在定义记录编号信息的同时, 定义一个与之相对应的标记数组,数组类型为整型。该程序的核心为一个嵌套的循环,所 以定义两个变量 i,j 作为循环条件。
接着开始对变量进行初始化,首先是编号信息数组,使用 for 循环对数组进行 1 到 52 的赋值,代表 52 张纸牌,然后对标记数组赋值,将数组内的所有的值初始化为零,方便在 接下来的循环中统计每张牌的翻牌数。数据初始化结束后,开始按照要求对纸牌进行翻转, 在嵌套循环中,定义了一个全局变量 Flag,值为-1,负数定义为向下,正数定义为向上, 这样,翻转一次,即乘以 Flag,同时,符合翻转条件时,标记数组相应的编号的纸牌翻牌 次数+1。

java课程设计 蜘蛛纸牌游戏设计课程设计报告

java课程设计 蜘蛛纸牌游戏设计课程设计报告

《面向对象程序设计》课程设计报告题目: 下拉列表运算器设计专业: xxxxx班级: xxx姓名: xx指导教师: xx成绩:xxxxxx 年 x 月xx 日xx目录1设计内容及要求 (2)1.1 设计内容 (2)1.2 设计要求 (2)2概要设计 (2)2.1代码功能功能模块设计: (2)2.2程序的总体设计流程图: (3)2.3模块一的详细介绍: (3)2.3.1主要的类: (3)2.3.2主要的变量: (4)2.3.3主要的方法: (4)2.4模块二的详细介绍: (5)2.4.1主要的类: (5)2.4.2主要的变量: (5)2.4.3主要的方法: (5)2.5模块三的详细介绍: (6)2.5.1主要类介绍: (6)2.5.2主要变量: (6)2.5.3主要方法: (7)2.6模块四的详细介绍: (7)2.6.1主要的类: (8)2.6.2主要的变量: (8)2.6.3主要的方法: (8)3设计过程或程序代码 (9)3.1需要实现的主要功能: (9)3.2功能设计流程图: (10)3.3主要功能的代码实现: (10)3.3.1游戏菜单栏内游戏菜单及帮助菜单功能展示: (10)3.3.2主界面的设计: (11)3.3.3纸牌的初始化以及发牌操作 (13)3.3.4纸牌的移动以及放置 (18)3.3.5显示当前纸牌可行的操作: (19)3.3.6回收纸牌: (21)4设计结果与分析 (22)4.1运行程序: (22)4.2发布程序: (23)4.3总结: (24)5参考文献 (24)1设计内容及要求1.1 设计内容相信很多人都玩过蜘蛛纸牌这款休闲游戏,现在随着生活水平的提高,人们拥有充分的时间来享受休闲游戏带来的快乐,越来越多的人亲睐蜘蛛纸牌游戏。

谈起这款游戏,大家并不陌生。

从WINDOWS2000系统开始,就嵌入了蜘蛛纸牌游戏,可是随着微软系统的不段升级,蜘蛛纸牌游戏的功能业变得越来越强大,游戏的界面也更加美观。

Java程序设计之扑克牌

Java程序设计之扑克牌

Java程序设计之扑克牌 这段代码的主要实现功能扑克牌的洗牌和发牌功能,⼀副牌,红桃,⿊桃,梅花,⽅⽚,A~K,不含⼤⼩王。

构造⼀个class。

⾸先是声明花⾊:private String[] sign={"⽅⽚","红桃","⿊桃","梅花"};//扑克的四种花⾊ 然后是洗牌功能,意味花⾊与A~K结合构造成顺序的52张扑克牌,构造⼀个ArrayList对象存储扑克牌的值。

private static ArrayList<String> List; 接下来再类中实现此⽅法,构造出⼀副扑克牌。

public void Init(){List = new ArrayList();for(String str:sign){for(int i = 1;i<=13;i++){String extra_sign = ""; //将数字与扑克匹配if(i == 1){extra_sign = "A";List.add(str+extra_sign);}else if(i == 11){extra_sign = "J";List.add(str+extra_sign);}else if(i == 12){extra_sign = "Q";List.add(str+extra_sign);}else if(i == 13){extra_sign = "K";List.add(str+extra_sign);}else{List.add(str+i);}}}} 此时⾐服扑克牌已经构造完成,接下来通过⽅法实现扑克牌的乱序发放到四⼈的⼿中。

public void Hands(){int i = 0,j=0;Collections.shuffle(List);//Collection类中的shuffle⽅法将<List>乱序排列for(String str:List){if(j == 4)break;if(i == 0){hands[j] = str+" ";i++;}//这⾥不使⽤for(i<13){// hands[j] = str+" ";// i++;//}是因为第⼀个下标为0的元素为null,所以多了⼀步判断if(0<i && i<13){hands[j] +=str+" " ;i++;}else{i = 0;j++;}}} 洗牌和分牌步骤已经完成,下⾯贴上完整代码:package com;import java.util.ArrayList;import java.util.Collections;import java.util.Iterator;public class Pokes {private String[] sign={"⽅⽚","红桃","⿊桃","梅花"};private static String[] hands = new String[4];private static ArrayList<String> List;Pokes(){}public void Init(){List = new ArrayList();for(String str:sign){for(int i = 1;i<=13;i++){String extra_sign = "";if(i == 1){extra_sign = "A";List.add(str+extra_sign);}else if(i == 11){extra_sign = "J";List.add(str+extra_sign);}else if(i == 12){extra_sign = "Q";List.add(str+extra_sign);}else if(i == 13){extra_sign = "K";List.add(str+extra_sign);}else{List.add(str+i);}}}}public void Hands(){int i = 0,j=0;Collections.shuffle(List);for(String str:List){if(j == 4)break;if(i == 0){hands[j] = str+" ";i++;}if(0<i && i<13){hands[j] +=str+" " ;i++;}else{i = 0;j++;}}}public static void main(String[] args) {Pokes p = new Pokes();p.Init();p.Hands();System.out.println(hands[0]);System.out.println(hands[1]);System.out.println(hands[2]);System.out.println(hands[3]);}}通过debug结果如下:第⼀次输出结果:⿊桃2 ⿊桃2 红桃A 红桃8 ⿊桃9 ⿊桃7 梅花4 梅花8 ⿊桃5 梅花3 红桃10 ⽅⽚Q ⽅⽚K⿊桃6 ⿊桃6 ⽅⽚8 红桃4 红桃7 ⿊桃3 梅花K 红桃J ⿊桃J 梅花2 梅花10 红桃Q ⽅⽚9⽅⽚A ⽅⽚A 梅花Q ⿊桃8 梅花J 红桃3 ⽅⽚3 红桃6 红桃2 ⽅⽚7 梅花9 红桃5 梅花5⽅⽚6 ⽅⽚6 梅花A 红桃K ⿊桃K ⽅⽚10 ⿊桃A 梅花7 ⽅⽚J 梅花6 ⽅⽚5 ⿊桃10 红桃9第⼆次输出结果:⿊桃10 ⿊桃10 红桃5 ⿊桃7 ⽅⽚3 ⽅⽚Q 红桃8 ⽅⽚6 梅花5 ⽅⽚9 ⽅⽚2 红桃Q 红桃9⿊桃5 ⿊桃5 ⿊桃2 红桃2 ⿊桃K 梅花8 梅花2 ⿊桃9 红桃7 ⿊桃8 红桃6 梅花9 ⿊桃6红桃10 红桃10 梅花3 ⿊桃A 梅花10 ⽅⽚7 ⽅⽚10 ⿊桃4 ⿊桃Q 梅花7 红桃K ⿊桃3 红桃3梅花6 梅花6 梅花A 梅花K 红桃A 梅花J ⽅⽚8 红桃J ⿊桃J ⽅⽚4 ⽅⽚A 红桃4 ⽅⽚5 简单的Java扑克牌程序,初始化构造⼀副扑克牌,利⽤Collection.shuffle(<List>)将List中的元素打乱顺序,依次分配给四个String[]。

Java实训报告纸牌游戏黑杰克

Java实训报告纸牌游戏黑杰克

《Java实训》设计报告纸牌游戏黑杰克专业:软件技术班级:09-23班学号:*********姓名:***石家庄科技信息职业学院信息工程系2011年10月15日项目简介纸牌游戏黑杰克一、项目需求黑杰克简称为21点,1700年左右法国赌场就有这种21点的纸牌游戏。

该游戏由 2 到 6 个人玩,使用除大小王之外的52 张牌,游戏者的目标是使手中的牌的点数之和不超过21 点且尽量大。

有着悠久的历史。

发牌:一开始给每个玩家发一张牌,这张牌是底牌,只有玩家自己知道是什么,然后只发给要牌的玩家。

如果所有玩家都不再要牌,则开牌计分。

计分:2到10都是按牌面计算点数,直接累加。

J、Q、K按10点计算,A一般记作11点累加,此时如果点数大于21点则将A记作1点。

爆分:21点为最大点数值,如果玩家手中的牌点数大于21点,则属于爆分,玩家手中点数将归0,判定为输。

要牌:玩家在底牌之后可以继续要牌,知道点数满意或爆分为止。

下注:玩家在每局开局前可下注,定当前局输赢的钱数。

输赢:21点位最大点数,哪个玩家点数大,就哪个玩家赢。

二、项目设计下面是5个Java源文件的总体设计。

(1)BlackJack.java(主类)BlackJack 类负责创建主窗口,该类含有main方法,游戏从该类开始执行。

BlackJack类有5种类型的对象,分别是:Dealer,Scanner,Player,Computer,Card,对象。

(2)Card.java对于一张扑克牌来说,主要有牌面值及花色,Card类用faces数组及suits数组分别存储所有牌面值及花色,并提供了getFace()方法及getSuit()方法获取一张扑克的面值及花色信息。

(3)CardsInHand.java玩家手上的牌。

(4)Dealer.java荷官的抽象只是实现了两个较核心的能力,一个是发牌,一个是洗牌。

发牌涉及到一个随机算法的问题,是比较重要的运算处理。

(5)Player.java玩家类的抽象是非常明显的,完全模拟了现实中一个玩家的属性及行为,属性有:赢次数、输次数、拥有现金数、手上的牌。

(完整版)Java毕业课程设计蜘蛛纸牌李娜

(完整版)Java毕业课程设计蜘蛛纸牌李娜

Java课程设计——蜘蛛纸牌游戏1 引言1.1 背景相信很多人都玩过蜘蛛纸牌这款休闲游戏,现在随着生活水平的提高,人们拥有充分的时间来享受休闲游戏带来的快乐,越来越多的人亲睐蜘蛛纸牌游戏。

谈起这款游戏,大家并不陌生。

从WINDOWS2000系统开始,就嵌入了蜘蛛纸牌游戏,可是随着微软系统的不段升级,蜘蛛纸牌游戏的功能业变得越来越强大,游戏的界面也更加美观。

用户的体验感受也更加美好。

所以,蜘蛛纸牌游戏的开发对于人类的生活娱乐更加有意义。

本游戏通过java语言编写,实现了游戏的难度选择、开局、重新发牌以及可视化的相关操作界面。

并通过设计鼠标事件,引入线程,构建游戏程序框架完成了对该游戏的难度选择、开局、发牌、显示可执行操作的各个基本功能。

1.2 目标该游戏通过鼠标操作,将电脑多次分发的纸牌,按照相同的花色由大到小排列起来,直到桌面上的纸牌全都消失,即为胜利。

包括如下功能:(a)难度选择:包括简单(单色)、中级(双色)、高级(四色)。

(b)开局:任何时候可以重新开始一盘新的游戏。

(c)发牌。

(d)显示可行操作:提示当前可行操作。

(e)简单的帮助文档:对软件的简单介绍和编制说明。

2 开发工具介绍2.1 java语言概述java是由Sun Microsystems公司于1995年5月推出的java程序设计语言和java平台的总称。

用java实现的浏览器显示它的魅力:跨平台的特点使得它越来越受到许多程序员的亲睐。

java除了可以开发动态的Web 页还可以开发各种系统软件。

java平台由java虚拟机和各种java应用编程接口(简称API)构成。

java应用编程接口为java提供了一个独立于操作系统的标准接口,可分为基本部分和扩展部分。

在操作系统上安装一个java平台就可以运行任何一个java程序啦。

现在java平台已经几乎嵌入到所有的操作系统中。

这样java程序就可以只编译一次,就可以在各种系统当中运行。

2.2 java语言的特点java语言是一种简单的、面向对象的、分布式的、健壮的、安全的、与平台无关的、多线程、高性能的、动态程序设计语言。

java实现24点纸牌游戏

java实现24点纸牌游戏

java实现24点纸牌游戏本⽂题⽬为⼤家分享了java实现24点纸牌游戏的具体代码,供⼤家参考,具体内容如下题⽬24点游戏是经典的纸牌益智游戏。

常见游戏规则:从扑克中每次取出4张牌。

使⽤加减乘除,第⼀个能得出24者为赢。

(其中,J代表11,Q代表12,K代表13,A代表1),按照要求编程解决24点游戏。

基本要求:随机⽣成4个代表扑克牌牌⾯的数字字母,程序⾃动列出所有可能算出24的表达式,⽤擅长的语⾔(C/C++/Java 或其他均可)实现程序解决问题。

分析⽤穷举法列出四个数加上三个运算符号所构成的表达式所有可能的结果算法实现import java.util.*;public class point24 {static int sum=0;static int[] sum()//产⽣随机数并显⽰的⽅法{Random rand=new Random();int r1=(1+rand.nextInt(13));int r2=(1+rand.nextInt(13));int r3=(1+rand.nextInt(13));int r4=(1+rand.nextInt(13));System.out.print("发出的牌为:");switch(r1){case 1 :System.out.print("A");break;case 11:System.out.print("J");break;case 12:System.out.print("Q");break;case 13:System.out.print("K");break;default:System.out.print(r1);break;}switch(r2){case 1 :System.out.print(" A");break;case 11:System.out.print(" J");break;case 12:System.out.print(" Q");break;case 13:System.out.print(" K");break;default:System.out.print(" "+r2);break;}switch(r3){case 1 :System.out.print(" A");break;case 11:System.out.print(" J");break;case 12:System.out.print(" Q");break;case 13:System.out.print(" K");break;default:System.out.print(" "+r3);break;}switch(r4){case 1 :System.out.println(" A");break;case 11:System.out.println(" J");break;case 12:System.out.println(" Q");break;case 13:System.out.println(" K");break;default:System.out.println(" "+r4);break;}int [] s=new int[] {r1,r2,r3,r4};return s;}static int js(int i,int j,int x)//两个数之间计算符号确认{int m=0;switch(x){case 0:m=i+j;break;case 1:m=i-j;break;case 2:m=i*j;break;case 3:m=i/j;if(i%j!=0) m=-1;//如果除不尽直接让m=-1,以便直接结束此次循环break;}return m;}static String prin(int s1,int s2,int s3,int s4,int x1,int x2,int x3)//打印解的表达式 {String ch="";switch(s1){case 1 :System.out.print("A");ch="A";break;case 11:System.out.print("J");ch="J";break;case 12:System.out.print("Q");ch="Q";break;case 13:System.out.print("K");ch="K";break;default:System.out.print(s1);ch=(String)(s1+"0");break;}switch(x1){case 0:System.out.print("+");ch+="+";break;case 1:System.out.print("-");ch+="-";break;case 2:System.out.print("*");ch+="*";break;case 3:System.out.print("/");ch+="/";break;}switch(s2){case 1 :System.out.print("A");ch+="A";break;case 11:System.out.print("J");ch+="J";break;case 12:System.out.print("Q");ch+="Q";break;case 13:System.out.print("K");ch+="K";break;default:System.out.print(s2);ch+=(String)(s2+"");break;}switch(x2){case 0:System.out.print("+");ch+="+";break;case 1:System.out.print("-");ch+="-";break;case 2:System.out.print("*");ch+="*";break;case 3:System.out.print("/");ch+="/";break;}switch(s3){case 1 :System.out.print("A");ch+="A";break;case 11:System.out.print("J");ch+="J";break;case 12:System.out.print("Q");ch+="Q";break;case 13:System.out.print("K");ch+="K";break;default:System.out.print(s3);ch+=(String)(s3+"");break;}switch(x3){case 0:System.out.print("+");ch+="+";break;case 1:System.out.print("-");ch+="-";break;case 2:System.out.print("*");ch+="*";break;case 3:System.out.print("/");ch+="/";break;}switch(s4){case 1 :System.out.println("A");ch+="A";break;case 11:System.out.println("J");ch+="J";break;case 12:System.out.println("Q");ch+="Q";break;case 13:System.out.println("K");ch+="K";break;default:System.out.println(s4);ch+=(String)(s4+"");break;}// System.out.println(" "+ch);return ch;}static String[] con(int s[])//枚举计算是否存在解{boolean flag=false;String[] ch=new String [100];int js1,js2,js3=0;for(int i = 0;i<4;i++){for(int j=0;j<4;j++){if(i!=j){for(int k=0;k<4;k++){if(i!=j&&j!=k&&i!=k){for(int l=0;l<4;l++){if(i!=j&&j!=k&&k!=l&&i!=k&&i!=l&&j!=l){for(int x1=0;x1<3;x1++){for(int x2=0;x2<3;x2++){for(int x3=0;x3<3;x3++){js1=js(s[i],s[j],x1);if(js1==-1) continue;js2=js(js1,s[k],x2);if(js2==-1) continue;js3=js(js2,s[l],x3);if(js3==-1) continue;if(js3!=-1){if(js3==24){ ch[sum]=prin(s[i],s[j],s[k],s[l],x1,x2,x3);flag=true;sum++;}}}}}}}}}}}}if(flag==false){System.out.println("不存在⼀组解使其成为\"24点\""); }return ch;}public static void main(String[] args){boolean f=false;Scanner in=new Scanner(System.in);while(!f){int [] s=sum();//产⽣4个随机纸牌con(s);//求解并打印System.out.println();System.out.println("继续 (1)or结束(0)");if(in.nextInt()==1){f=false;}else{f=true;}}}}运⾏结果随机数产⽣测试:运⾏:更多精彩游戏⼩代码,请点击阅读以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。

java学习案例-斗地主洗牌发牌

java学习案例-斗地主洗牌发牌

斗地主洗牌发牌【案例介绍】1.任务描述扑克牌游戏“斗地主”,相信许多人都会玩,本案例要求编写一个斗地主的洗牌发牌程序,要求按照斗地主的规则完成洗牌发牌的过程。

一副扑克总共有54张牌,牌面由花色和数字组成(包括J、Q、K、A字母)组成,花色有♠、♥、♦、♣ 四种,分别表示黑桃、红桃、方块、梅花,小☺、大☻分别表示小王和大王。

斗地主游戏共有3位玩家参与,首先将这54张牌的顺序打乱每人轮流摸一次牌,剩余3张留作底牌,然后在控制台打印3位玩家的牌和3张底牌。

2.运行结果任务运行结果如图6-1所示:图6-1 运行结果图【任务介绍】●学会分析“斗地主之洗牌发牌”任务的实现思路。

●根据思路独立完成“斗地主之洗牌发牌”任务的源代码编写、编译及运行。

●掌握List集合和Map集合特点及常用方法的使用。

●掌握集合遍历的方式。

【实现思路】(1)要实现纸牌程序,首先需要完成纸牌的组装。

牌面是由花色(包括♠、♥、♦、♣花色)和数字(包括J、Q、K、A字母)两部分组成,可以创建两个ArrayList集合作为花色集合与数字集合,存储时需要注意。

比10大的牌的数字用J、Q、K表示,1用A表示。

(2)将花色集合与数字集合这两个循环进行嵌套循环,将花色与数字组合,形成52章牌,并赋予其编号。

将组合后的牌存放到一个HashMap集合中,集合的Key值是编号,value值是组装完成的纸牌。

还有两张牌是大小王(小☺表示小王、大☻表示大王)。

由于组装规则不一致,需单独使用add()方法将这两张牌加入到HashMap集合中。

(3)创建一个数字集合,用这个数字集合代替纸牌完成洗牌和发牌操作。

由于纸牌的数量是54张,所以创建集合范围是0~53。

(4)可以使用Collection类的shuffle()方法完成打乱数字集合的操作,实现洗牌效果。

由于只有3个人,所以可以使用for循环,通过将数字与3取余的方法,将代表不同纸牌的数字分配给不同人与底牌,实现发牌效果。

Java课程设计报告蜘蛛纸牌游戏

Java课程设计报告蜘蛛纸牌游戏

目录1. 选题目的与系统概述 (2)2. 系统可行性分析与相关技术背景分析 (3)2.1系统可行性分析 (3)2.2相关技术背景分析 (3)3. 系统设计与关键技术 (4)3.1系统设计 (4)3.2关键技术 (5)4.系统测试与操作实施方法 (9)4.1进入游戏运行界面 (9)4.2 游戏的具体的操作过程 (9)4.3进入“帮助”菜单 (10)4.4游戏中的异常处理情况 (11)5.系统设计总结与回顾 (12)6.附录 (13)6.1 AboutDialog.java (13)6.2 PKCard.java (14)6.3 Spider.java (20)6.4 Spider M enuBar.java (29)1.选题目的与系统概述随着经济全球一体化的逐步加剧,人们的生活节奏越来越快。

蜘蛛纸牌游戏的一种,旨在让工作学习之后疲惫的玩家有一个轻愉快的放松方式。

与普通的纸牌相比,降低了一点难度。

游戏简单级别由8组A-K的清一色黑桃牌面组成,取消了红黑相间的游戏规则,更突然出强化了玩家在安排事物方面的能力。

蜘蛛纸牌游戏实现了与Windows系列操作系统中自带的蜘蛛纸牌游戏类似的功能。

该游戏程序中采用Windows系列中游戏的图片,运用Java语言设计了线程、鼠标事件、纸牌的装载、图形界面的构造、组件监听接口的实现、生成蜘蛛纸牌游戏的框架、实现游戏中的方法,是一种休闲益智游戏。

2.系统可行性分析与相关技术背景分析2.1系统可行性分析蜘蛛纸牌游戏规则是:(1)将电脑分发给你的牌按照相同的花色又打至小排列起来,直到桌面上的牌全都消失。

(2)可执行的牌必须为明牌(3)单牌移动规则(4)多拍移动规则游戏分三个等级:(1)简答:单一花色;(2)中级:双花色;(3)四花色。

2.2相关技术背景分析2.2.1蜘蛛纸牌游戏是基于Eclipse平台的Java程序。

Eclipse的背景如下:Eclipse最初是IBM公司的一个软件产品。

Java实现简易扑克牌游戏的完整实例

Java实现简易扑克牌游戏的完整实例

Java实现简易扑克牌游戏的完整实例功能描述1、创建扑克牌。

包括四种花⾊(⿊桃,红⼼,梅花,⽅块),⼗三种点数(2-10,J,Q,K),不考虑⼤⼩王。

2、创建两个玩家。

包括玩家id、姓名、⼿牌等集合,⼿牌为扑克牌的集合。

3、洗牌。

将创建好的扑克牌打乱。

4、发牌。

将洗牌之后的扑克牌集合,从第⼀张开始,发给两个玩家,安装⼀⼈⼀张的⽅式,每⼈发两张。

5、游戏。

⽐较两名玩家⼿中的扑克牌。

规则为:去两名玩家⼿上点数最⼤的牌进⾏⽐较,点数⼤的赢,若点数⼀样⼤,就按照⾊花进⾏⽐较。

难点分析:1、洗牌,如何将扑克牌进⾏打乱。

(主要知识点Random,list.contains())2、扑克牌如何进⾏⼤⼩⽐较。

(主要知识点collections.sort() , comparable)实现代码Card.java(扑克牌类)package com.betty.dome2;public class Card implements Comparable<Card>{// 牌⾯private String num;// 花⾊private String name;public Card(){}public Card(String num,String name){this.num = num; = name;}public String getNum() {return num;}public void setNum(String num) {this.num = num;}public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + ((name == null) ? 0 : name.hashCode());result = prime * result + ((num == null) ? 0 : num.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())Card other = (Card) obj;if (name == null) {if ( != null)return false;} else if (!name.equals())return false;if (num == null) {if (other.num != null)return false;} else if (!num.equals(other.num))return false;return true;}// 获取牌⾯⼤⼩private Integer getNumValue(String num){switch(num){case "A": return 12;case "2": return 13;case "3": return 1;case "4": return 2;case "5": return 3;case "6": return 4;case "7": return 5;case "8": return 6;case "9": return 7;case "10": return 8;case "J": return 9;case "Q": return 10;case "K": return 11;}return -1;}// 获取花⾊⼤⼩private Integer getNameValue(String name){switch(name){case "⿊桃": return 4;case "红⼼": return 3;case "梅花": return 2;case "⽅块": return 1;}return -1;}@Overridepublic int compareTo(Card card) {// 如果牌⾯相同就看花⾊int numCompare = getNumValue(this.num).compareTo(getNumValue(card.num)); if(numCompare == 0){return getNameValue().compareTo(getNameValue());}return numCompare;}}Player.java(⾓⾊类)package com.betty.dome2;import java.util.ArrayList;import java.util.List;public class Player {// ⾓⾊idprivate Integer ID;// ⾓⾊姓名private String name;// ⾓⾊获得的牌List<Card> cardList;public Player(){}public Player(Integer ID,String name){ = name;this.cardList = new ArrayList<Card>();}public Integer getID() {return ID;}public void setID(Integer iD) {ID = iD;}public String getName() {return name;}public void setName(String name) { = name;}}Welcome.java(主程序)package com.betty.dome2;import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Random;import java.util.Scanner;public class Welcome {String[] nums = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"}; String[] names = {"⿊桃","红⼼","梅花","⽅块"};List<Card> cardStartList; // 开始创建扑克牌时的序列List<Card> cardEndList; // 洗牌后的序列List<Player> playerList; // 玩家列表public Welcome(){this.cardStartList= new ArrayList<Card>();this.cardEndList = new ArrayList<Card>();this.playerList = new ArrayList<Player>();}// 创建扑克牌void createCard(){System.out.println("-----------创建扑克牌---------------");for (String name : names) {for (String num : nums) {cardStartList.add(new Card(num,name));}}System.out.println("---------扑克牌创建成功--------------");System.out.print("[");for(int i=0;i<cardStartList.size();i++){Card card = cardStartList.get(i);if(i%13!=0) System.out.print(",");if((i+1)%13==1 && i!=0){System.out.println("]");System.out.print("[");}System.out.print(card.getName()+card.getNum());}System.out.println("]");}// 洗牌void shuffleCard(){System.out.println("-----------开始洗牌---------------");Random random = new Random();Integer listSize = cardStartList.size();for(int i=0;i<listSize;i++){Card cd = new Card();cd = cardStartList.get(random.nextInt(listSize));}while(cardEndList.contains(cd));cardEndList.add(cd);}System.out.println("-----------洗牌结束---------------");}// 输⼊⾓⾊姓名@SuppressWarnings("resource")private String getName() {System.out.print("输⼊姓名:");Scanner input = new Scanner(System.in);return input.next();}// 输⼊⾓⾊id && 输⼊整数判断@SuppressWarnings("resource")private Integer getId() {Scanner input = new Scanner(System.in);Integer id;while(true){try {System.out.print("输⼊ID:");id = input.nextInt();break;} catch (Exception e) {System.out.println("请输⼊整数");input = new Scanner(System.in);}}return id;}// 创建⾓⾊private void createPlayers() {Integer playerNum = 2;for(int i=0;i<playerNum;i++){playerList.add(new Player(getId(), getName()));}for (Player player : playerList) {System.out.println("----欢迎玩家 :" + player.getName());}}// 给⾓⾊发牌private void sendCard() {System.out.println("-----------开始发牌---------------");int cardSendNum = 2,index = 0;for(int i=0;i<cardSendNum;i++){for(int j=0;j<playerList.size();j++){Player player = playerList.get(j);player.cardList.add(cardEndList.get(index++));System.out.println("----玩家 :" + player.getName()+" 拿牌"); }}System.out.println("-----------发牌结束---------------");}// 游戏开始private void playGame() {System.out.println("-----------游戏开始---------------");Card maxCard = new Card("0","⽅块");Player winner = new Player();for(int i=0;i<playerList.size();i++){Player player = playerList.get(i);List<Card> cardList = player.cardList;Collections.sort(cardList);Card card = cardList.get(cardList.size()-1);if(pareTo(card)<0){maxCard = card;winner = player;}System.out.println("----玩家:"+ player.getName()+ "最⼤的牌为:" + card.getName()+ card.getNum());}System.out.println("玩家各⾃的⼿牌为:");for(int j=0;j<playerList.size();j++){Player player = playerList.get(j);System.out.print("玩家 :" + player.getName()+"[");for(int i=0;i<player.cardList.size();i++){if(i!=0) System.out.print(",");System.out.print(player.cardList.get(i).getName()+player.cardList.get(i).getNum());}System.out.print("]\n");}}public static void main(String[] args) {Welcome we = new Welcome();we.createCard(); // 创建扑克牌we.shuffleCard(); // 洗牌we.createPlayers(); // 创建⾓⾊we.sendCard(); // 给⾓⾊发牌we.playGame(); // 游戏开始}}实现的效果图:总结到此这篇关于Java实现简易扑克牌游戏的⽂章就介绍到这了,更多相关Java扑克牌游戏内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。

java扑克牌课程设计

java扑克牌课程设计

java扑克牌课程设计一、课程目标知识目标:1. 学生能理解Java面向对象编程的基本概念,如类、对象、继承、封装等;2. 学生能掌握Java集合框架的使用,如ArrayList、HashMap等;3. 学生能运用Java异常处理机制处理程序异常;4. 学生能运用Java多线程技术开发简单的并发程序。

技能目标:1. 学生能运用所学知识设计并实现一个简单的Java扑克牌游戏;2. 学生能通过编写代码,实现扑克牌的洗牌、发牌、排序等基本功能;3. 学生能运用Java多线程技术实现扑克牌游戏的并发操作;4. 学生能通过调试和优化代码,提高程序的稳定性和性能。

情感态度价值观目标:1. 学生通过课程学习,培养对编程的兴趣和热情,增强学习Java的自信心;2. 学生在小组合作中,培养团队协作能力和沟通表达能力;3. 学生在解决实际问题的过程中,培养分析问题和解决问题的能力,形成积极向上的学习态度;4. 学生通过扑克牌游戏的设计与实现,认识到编程在生活中的广泛应用,激发对科技创新的热情。

二、教学内容1. Java面向对象编程基础:复习类与对象的概念、构造方法、成员变量、成员方法等,重点讲解继承、封装和多态性的应用。

相关教材章节:第3章 类与对象,第4章 继承与多态。

2. Java集合框架:介绍ArrayList、LinkedList、HashMap等常用集合类的使用方法,通过案例演示集合框架在实际编程中的应用。

相关教材章节:第6章 集合框架。

3. Java异常处理:讲解异常的概念、分类,掌握try-catch-finally结构,学会编写健壮的代码处理可能出现的异常。

相关教材章节:第7章 异常处理。

4. Java多线程编程:介绍线程的概念、创建、同步与通信,通过扑克牌游戏案例讲解多线程技术在游戏并发操作中的应用。

相关教材章节:第9章 多线程编程。

5. 扑克牌游戏设计与实现:结合所学知识,设计并实现一个简单的扑克牌游戏,涵盖洗牌、发牌、排序等功能,锻炼学生综合运用Java编程知识解决实际问题的能力。

Java实现扑克小游戏课程设计

Java实现扑克小游戏课程设计

Java实现扑克小游戏课程设计一、课程目标知识目标:1. 学生能理解Java面向对象编程的基本概念,包括类、对象、封装、继承和多态。

2. 学生能够掌握Java异常处理机制,理解扑克游戏中可能出现的异常类型。

3. 学生能够运用Java集合框架中的数据结构,如List和ArrayList,存储和管理扑克牌。

技能目标:1. 学生能够设计并实现一个简单的扑克牌类,包括牌面值和花色的属性及相应的构造方法。

2. 学生能够编写方法实现洗牌、发牌、比大小等基本扑克游戏功能。

3. 学生通过编程实践,掌握调试和测试Java程序的能力,确保游戏逻辑的正确性。

情感态度价值观目标:1. 学生在小组合作完成项目的过程中,培养团队协作精神和沟通能力。

2. 学生通过解决编程中遇到的问题,培养勇于尝试、克服困难的积极态度。

3. 学生能够体验编程带来的乐趣,激发对计算机编程和软件开发的长远兴趣。

课程性质:本课程为实践性较强的Java编程课程,通过实现扑克小游戏,将理论知识与实践相结合,提高学生的实际编程能力。

学生特点:学生为高中生,具备一定的编程基础和逻辑思维能力,对游戏编程有较高的兴趣。

教学要求:课程要求学生在理解基本概念的基础上,通过动手实践完成游戏开发,注重培养学生的实际编程能力和团队合作能力。

通过分解课程目标为具体学习成果,使学生在完成课程后能够独立设计和实现简单的Java程序。

二、教学内容1. 面向对象编程基础:- 类的定义与使用(教材第3章)- 对象的创建与引用(教材第4章)- 封装、继承和多态的概念及应用(教材第5章)2. 异常处理机制:- 异常类型与捕获处理(教材第7章)- 自定义异常(教材第7章)3. Java集合框架:- List接口及其实现类ArrayList的使用(教材第8章)- 集合的常用方法(添加、删除、遍历等)4. 扑克牌类的设计与实现:- 定义扑克牌类及其属性(牌面值、花色)- 实现扑克牌类的构造方法、访问器和修改器5. 扑克游戏功能实现:- 洗牌算法(教材第6章,排序与查找)- 发牌逻辑- 比较牌面大小的方法6. 程序调试与测试:- 使用JUnit进行单元测试(教材第11章)- 程序调试技巧(教材第12章)7. 团队合作与项目实践:- 小组分工与协作- 项目进度安排与验收教学内容安排与进度:第1-2课时:面向对象编程基础第3-4课时:异常处理机制第5-6课时:Java集合框架第7-8课时:扑克牌类的设计与实现第9-10课时:扑克游戏功能实现第11-12课时:程序调试与测试,团队合作与项目实践教学内容根据课程目标和教材章节顺序进行组织,确保学生在掌握基础知识的同时,能够逐步实现扑克小游戏的功能。

Java~实现简单的扑克牌,洗牌,发牌,玩捉鬼游戏(讲解详细,代码齐全)

Java~实现简单的扑克牌,洗牌,发牌,玩捉鬼游戏(讲解详细,代码齐全)

Java~实现简单的扑克牌,洗牌,发牌,玩捉⿁游戏(讲解详细,代码齐全)⽬录⾸先⼀副扑克牌是54张,这⾥我们去掉⼤⼩王,也就是52张扑克牌有♣,♠,♥,◆,四种花⾊,每种花⾊对应1到13张⼀.扑克牌的定义1.牌的定义我们定义⼀个Card类,来表⽰⼀张扑克牌,上⾯有花⾊suit和牌的值rank。

这⾥我重写了toString⽅法,⽅便我们打印每⼀张牌这⾥我还重写了equals⽅法,如果判断两张牌是否相同,会⽤到注意:如果没有重写equals⽅法,那么⽐较的就是两个Card是不是同⼀个对象,⽽不是花⾊和数值是否相同了,达不到我们想要的效果/*** Created with IntelliJ IDEA.* User: 13498* Date: 2021/12/10* Time: 20:07* Description: No Description*/public class Card {String suit; //花⾊int rank; //⼤⼩public Card(String suit, int rank) {this.suit = suit;this.rank = rank;}@Overridepublic boolean equals(Object obj) {if (obj == null){return false;}if (!(obj instanceof Card)){return false;}Card card = (Card)obj;return this.suit.equals(card.suit) && this.rank == card.rank;}@Overridepublic String toString() {return String.format("[%s %d]",suit,rank); //注意⼀下这种输出⽅式}}2.玩家的定义除了牌本⾝,我们还要对玩家进⾏定义,所以我们这⾥定义了⼀个Player类来表⽰玩家,每⼀个玩家都有⼿牌,我们⽤⼀个Card类型的顺序表来保存,注意这⾥的顺序表后⾯new了,也就是初始化了,这个不能少,不然后⾯还要专门为每个玩家的⼿牌初始化,会⽐较⿇烦;同时,玩家还有⼀个姓名。

JAVA课程设计21点扑克牌

JAVA课程设计21点扑克牌

通信专业课程设计一(论文)太原科技大学课程设计(论文)设计(论文)题目:基于JAVA的21点扑克牌姓名学号班级学院指导教师2011年 12 月 23日太原科技大学课程设计(论文)任务书学院(直属系):时间: 2011年月日学生姓名指导教师设计(论文)题目基于JA V A的21点扑克牌游戏设计主要研究内容1.JA V A语言的初级编程。

2.JA V A语言的21点扑克牌的编程及设计。

3.JA V A平台软件eclipse的使用。

研究方法使用软件eclipse对21点游戏进行编程,设计游戏算法,实现游戏功能。

主要技术指标(或研究目标) 1. 21点游戏的基本功能的实现。

2. 程序中胜负的判别方法。

3. 递归法的理解与使用。

教研室意见教研室(负责人)签字:年月日目录第一章绪论............................................................. - 4 - 1.1JAVA工作平台的简介. (4)1.2本次设计的主要内容 (4)第二章设计任务的分析.................................................. - 5 - 2.1二十一点游戏介绍.. (5)2.2实现以下功能: (5)第四章程序的图形结果及分析............................................ - 10 - 第五章小结........................................................... - 16 - 参考文献............................................................... - 17 - 附录................................................................... - 18 -基于JAVA的点扑克牌设计第一章绪论1.1 JAVA工作平台的简介Java不依赖平台的特点使得它受到广泛的关注,Java已成为网络时代最重要的语言之一。

java课程设计-扑克游戏

java课程设计-扑克游戏

pane.setComponentZOrder(groundLabel[i], 105 + i);}}2.3功能模块图图1 功能模块图2.4程序流程图图2 程序流程图3.设计结果与分析(1)首先是对游戏中主菜单的设计,设计的菜单包括两个大部分,选项和帮助,如图3所示:图3 显示菜单通过如下代码实现:JMenu jNewGame = new JMenu("选项");JMenu jHelp = new JMenu("帮助");(2)在选项菜单下面包含7级子菜单,如图4所示:图4 显示菜单通过如下代码实现:JMenuItem jItemOpen = new JMenuItem("开局");JMenuItem jItemPlayAgain = new JMenuItem("重发牌");JRadioButtonMenuItem jRMItemEasy = new JRadioButtonMenuItem("简单");JRadioButtonMenuItem jRMItemNormal = new JRadioButtonMenuItem("较难");JRadioButtonMenuItem jRMItemHard = new JRadioButtonMenuItem("困难");;JMenuItem jItemExit = new JMenuItem("退出");JMenuItem jItemValid = new JMenuItem("显示可执行行操作");(3)帮助下面包含2级子菜单,分别为游戏规则和声明,如图5所示:图5 显示帮助通过如下代码实现:JTabbedPane jTabbedPane = new JTabbedPane();private JPanel jPanel1 = new JPanel();private JPanel jPanel2 = new JPanel();(4)主窗体通过类Spider实现。

Java课程设计报告—蜘蛛纸牌

Java课程设计报告—蜘蛛纸牌

面向对象程序设计课程设计报告JA V A程序设计课程设计之蜘蛛纸牌.学院:年级:`班级:指导老师:小组成员:!时间:\目录第一章课程设计要求......................................... 错误!未定义书签。

题目名称 ................................................. 错误!未定义书签。

题目类型 ................................................. 错误!未定义书签。

课程设计目的.............................................. 错误!未定义书签。

实验原理 ................................................. 错误!未定义书签。

实验内容 ................................................. 错误!未定义书签。

第二章设计概要............................................. 错误!未定义书签。

《功能设计 ............................................... 错误!未定义书签。

程序流程 ............................................... 错误!未定义书签。

功能分析 ................................................. 错误!未定义书签。

1. 主要界面:........................................ 错误!未定义书签。

2初始化纸牌及发牌操作:............................. 错误!未定义书签。

3纸牌移动放置操作:................................. 错误!未定义书签。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

else System.out.printf("******* (提示: 输入错误, 默认为继续。 )******** \n") 整个 do-while 语句的结束条件为:choice=0,所以如果用户输入为 N,则直接将 0 赋值给 choice,则符合循环结束的条件,则直接结束程序,如果输入为 Y,则 break,继续循环, 输入错误,没有对 choice 任何的赋值操作,即不能满足结束条件,则无论输入什么都默认 为继续,break 后继续循环。由于程序默认的将回车操作通过 getchar()赋值给 n,导致不能 正常的实现下面的判断,而直接显示为输入错误,所以加入两个 n=getchar()语句,保证第 二句能够正确的实现功能,让用户自行输入条件,进行下一步的操作。在整个程序中,存在 着大量的输入判断条件,如下: if(num<1&&num>52) System.out.printf("\t 输入错误!\n"); 这两句代码就是对输入的 num 值进行判断,由于纸牌序号为 1-52,所以不在这个范围的值 都为错误值,需要有一个错误信息的反馈,所以需要对输入的信息进行判断,然后通过不同 的值对数据进行相应的操作,这对于程序的正确运行,有着至关重要的作用。 四.上机调试过程: 该程序任务相对比较简单,思路较明确。 在一开始编写代码的时候,在嵌套循环中,外循环 for 的条件(i=2;i<=52;i++),写成 (i=1;i<=52;i++) ,导致对每个纸牌的翻转都多判断了一次,按照一开始定义的大于零的 编号数为正面向上的条件,最后输出的结果正好相反,经过修改调试后,问题解决。 在每个 case 中加入独立的判断是否回到主菜单的语句,一开始 getchar()总是不能 正确录入,没有输入就直接运行下一个语句,在加入控制语句后经过调试发现,程序把上 一个输入的回车直接默认赋值给 getchar(),导致没有输入,直接进行下一个语句,后来 使用了两个连续的 getchar()语句,第一个 getchar()语句默认为回车,但是后面一个 getchar()语句可以正确的重新输入判断值,经过重新的调试,运行正常,问题解决,但是 希望能找到更完善的答案。 在判断是否继续输入纸牌编码的功能中, 同样遇到了这个问题, 按照相同的解决办法解决。 整个程序由一个大的 do-while 语句和 switch 语句组合实现界面的不同功能, do-while 语句通过 choice=0 作为结束的条件,在 case 3 中,有一个小的 do-while 语句实现纸牌编 号的重复输入,在整个程序中有很多信息的输入,需要根据输入的信息正确与否来反馈信 息,否则会导致程序出错,所以在调试的过程中加入了很多判断条件,可以解决信息输入 错误的情况,但是仍然存在输入非整型值程序出错的问题,所以在输入条件中加入提示信 息,以保证信息类型输入正确。 五.测试结果及其分析 1.测试结果如下图 1-12; 2 结果分析以注释的形式写在图的下方;
(图 10) (注:纸牌游戏程序结束画面。 )
附录: 程序源代码: package Cartgame; import java.util.Scanner; public class Main { private static Scanner sc = new Scanner(System.in); static int Flag = -1; //定义一个全局变量作为正反面的判断条件。 public static void main(String[] args) { int i,j,choice,num;//建立两个数组,一个存放 52 张牌的编号,另外一个存 放相应编号的纸牌的翻牌记录。 int[] data = new int[52]; int[] flag = new int[52]; String n,m; System.out.println("温馨提示:欢迎进入纸牌游戏程序!"); for(i=1;i<=52;i++) { data[i-1]=i;//录入 52 张牌的编号。 flag[i-1]=0;//将相应编号纸牌的翻牌数初始化为 0。 } for(i=2;i<=52;i++)//外循环,基数循环。 { for(j=1;j<=52;j++)//内循环,基数倍数条件判断。 { if(j%i==0) { data[j-1]=data[j-1]*Flag;//将翻转后的结果更新 data 中的 数据。 flag[j-1]++;//翻牌一次,即记入 flag 数组中。 }
一、问题分析和任务定义 1.题目: 纸牌游戏: 编 号 为 1-52 张 牌 , 正 面 向 上 , 从 第 2 张 开 始 , 以 2 为 基 数 , 是 2 的 倍 数 的 牌 翻 一 次 ,直 到 最 后 一 张 牌 ;然 后 ,从 第 3 张 开 始 ,以 3 为 基 数 ,是 3 的 倍 数 的 牌 翻 一 次 ,直 到 最 后 一 张 牌 ;然 后 … 从 第 4 张 开 始 ,以 4 为 基 数 ,是 4 的 倍 数 的 牌 翻 一 次 , 直 到 最 后 一 张 牌 ;。。。再 依 次 5 的 倍 数 的 牌 翻 一 次 , 6 的 , 7 的 直 到 以 52 为 基 数 的 翻 过 , 输 出 : 这 时 正 面 向 上 的 牌 有 哪 些 ? 2.要求和任务: ① 该题目的要求如下: (1)将 52 张牌编号。 (2)从 2 开始,依次作为基数对基数的倍数的牌进行翻转,直到以 52 为基数的翻转。 (3)最后输出正面向上的牌。 ② 基本任务为: (1)按照要求翻转纸牌。 (2)输出最后正面向上的纸牌的编号。 3.原始数据的输入及输出格式: 原始数据要求输入纸牌的基础编号, 编号的输入为整型。输出的是经过规律翻转后正面向上 的纸牌的编号。 输入的数据信息如下: 纸牌:1、2、3……、51、52。 问题直观分析表: 1 1 2 3 4 5 6 7 8 9 10 11 12 …… (注:图中“√”表示翻转一次。 ) √ √ √ √ √ √ √ √ √ √ √ …… √ √ √ √ √ √ √ √ √ √ √ √ 2 3 4 5 6 7 8 9 10 11 12 ……
for(i=1;i<=52;i++) { data[i-1]=i;//录入 52 张牌的编号。 flag[i-1]=0;//将相应编号纸牌的翻牌数初始化为 0。 } for(i=2;i<=52;i++)//外循环,基数循环。 { for(j=1;j<=52;j++)//内循环,基数倍数条件判断。 { if(j%i==0) { data[j-1]=data[j-1]*Flag;//将翻转后的结果更新 data 中的数 据。 flag[j-1]++;//翻牌一次,即记入 flag 数组中。 } } } System.out.printf("\t 最后所有正面向上的牌有:\n"); for(i=0;i<52;i++) { if(data[i]>0)//所有大于 0 的数即为正面向上的纸牌。 System.out.printf(" 第%d 张牌 ",i+1); } System.out.printf("\n");以上为程序主要代码的分析。 在程序中,主要还包括功能界面,如下: System.out.printf("\t-----------------------------------------------------\n"); System.out.printf("\t-----------------------------------------------------\n"); System.out.printf("\t------欢迎进入纸牌游戏 --------\n"); System.out.printf("\t------1.查看题目 --------\n"); System.out.printf("\t------2.查看所有纸牌的翻牌次数 --------\n"); System.out.printf("\t------3.查看指定编号纸牌翻牌记录 --------\n"); System.out.printf("\t------4.查看最终正面向上的纸牌编号 --------\n"); System.out.printf("\t------5.制作人信息 --------\n"); System.out.printf("\t------0.按 0 键结束 --------\n"); System.out.printf("\t-----------------------------------------------------\n"); System.out.printf("\t-----------------------------------------------------\n"); 同时,整个功能实现由 do-while 语句和 switch 语句组合而成,do-while 语句可以保证界 面最少运行一次,switch 语句保证每个功能独立实现,通过 choice 的输入来进入不同的功 能,同时在每个小的独立功能内,我都添加了独立判断是否回到主菜单的语句,如下: System.out.printf("是否回到主菜单?(Y/N):"); n = sc.next(); if(n.equals("Y"))break; else if(n.equals("N")) choic3) (注:纸牌游戏程序功能 1:查看题目。 )
(图 4) (注:纸牌游戏程序功能 2:查看所有纸牌的翻牌次数。 )
相关文档
最新文档