设计一个游戏程序，
1开始之后，程序随即给出一个26个大写的英文字母的其中一个；
2程序开始10秒倒计时（这个可以不用显示出来计数）；
3若能再10秒内打出所有字母，并按回车键确认，如果正确。继续下一次循环 ，字母自动增加一位。
   如果时间超出或则顺序错误，认为失败，失败输出“游戏失败！”。
4.若在最后一次成功在10秒内全部打出10个字母，判定这个游戏通关，并输出“祝贺游戏通关！”。
。

自己顶上去

说实话，没怎么看懂这个游戏的过程。刚开始那个随机字母拿来干嘛的？

能在说明白点吗？

杨天皓 发表于 2012-6-9 00:29
说实话，没怎么看懂这个游戏的过程。刚开始那个随机字母拿来干嘛的？

能在说明白点吗？ ...

启动程序之后，就开始进行游戏了呀，那程序就 先给出一个随机字母 让玩家来输入正确的字母。就酱紫~~

感觉木有什么难度啊~~~

判断逻辑并不多，但还是值得学完基础后做一做

基础视频我也看完了，正好拿你这个题来练练手，今天一天我就写了这么个程序，不知道符不符合楼主的功能要求，由于我水平很水，有不足之处望指出
我的思路是创建军三个线程，一个用来随机产生大写字母，一个用来计时，还有一个就是主线程了，用来从键盘输入字母。
这是整体的大思路，具体的还是来看代码吧！

1. package Game.MyselfLittleGame.game;
   
2. 
   
3. import java.io.BufferedReader;
   
4. import java.io.InputStreamReader;
   
5. 
   
6. public class LittleGame {
   
7. 
   
8. public static void main(String[] args)throws Exception
   
9. {
   
10. Time timer = new Time();
    
11. RandomChar2 rc2 = new RandomChar2();
    
12. 
    
13. Thread time = new Thread(timer);
    
14. Thread t2 = new Thread(rc2);
    
15. 
    
16. time.start(); //计时线程开启
    
17. t2.start(); //随机字母生产线程开启
    
18. 
    
19. BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
    
20. StringBuffer sb = new StringBuffer(); //把从键盘录入的字母存入sb中
    
21. while(true)
    
22. {
    
23. String s = buf.readLine(); //读取键盘输入字母
    
24. sb.append(s); //把从键盘录入的字母存入sb中
    
25. synchronized(LittleGame.class)
    
26. {
    
27. if(Time.times<10) //时间不能超过10f秒
    
28. {
    
29. 
    
30. if(sb.toString().equals(rc2.ssb.toString())&&rc2.sign==10) //如果输入无误且达到十次则游戏通过
    
31. {
    
32. System.out.println("恭喜过关,是否继续！Y/N");
    
33. sb.delete(0, sb.length());
    
34. rc2.sign = 0;
    
35. }
    
36. else
    
37. if(sb.toString().equals(rc2.ssb.toString())) //键盘输入字母和随机产生的相同无误则继续
    
38. {
    
39. Time.flag = true; //回车键盘按下后变换标志
    
40. sb.delete(0, sb.length()); //删除sb中的所有元素以免受到上次的影响
    
41. LittleGame.class.notifyAll();
    
42. }
    
43. else
    
44. if(sb.toString().equals("Y")&&rc2.sign==0)
    
45. {
    
46. Time.flag = true;
    
47. sb.delete(0, sb.length());
    
48. LittleGame.class.notifyAll();
    
49. }
    
50. else //输入有误则退出
    
51. {
    
52. System.out.println("游戏失败结束!");
    
53. break;
    
54. }
    
55. 
    
56. }
    
57. else
    
58. {
    
59. System.out.println("时间太长游戏结束！"); //时间超过10秒游戏失败
    
60. break;
    
61. }
    
62. 
    
63. }
    
64. }
    
65. System.out.println(sb.toString());
    
66. 
    
67. 
    
68. }
    
69. 
    
70. }
    

复制代码

接下来是随机产生大写字母的类，它实现Runnable

1. package Game.MyselfLittleGame.game;
   
2. 
   
3. import java.util.Random;
   
4. 
   
5. public class RandomChar2 implements Runnable
   
6. {
   
7. private String str = null;
   
8. public static int sign = 0;
   
9. public StringBuffer ssb = new StringBuffer();
   
10. public void run()
    
11. {
    
12. int a;
    
13. int k = 1;
    
14. System.out.println("开始");
    
15. while(true)
    
16. {
    
17. synchronized(LittleGame.class)
    
18. {
    
19. 
    
20. for(int j= 0 ;j<k;j++) //循环输出随机大写字母，当 k =1,2,3,4.....时分别输出相应的字母数
    
21. {
    
22. a = new Random().nextInt(26); //随机产生一个数
    
23. switch(a)
    
24. {
    
25. case 0: str = "A";break;case 1: str = "B";break;case 2: str = "C";break;case 3: str = "D";break;
    
26. case 4: str = "E";break;case 5: str = "F";break;case 6: str = "G";break;case 7: str = "H";break;
    
27. case 8: str = "I";break;case 9: str = "J";break;case 10: str = "K";break;case 11: str = "L";break;
    
28. case 12: str = "M";break;case 13: str = "N";break;case 14: str = "O";break;case 15: str = "P";break;
    
29. case 16: str = "Q";break;case 17: str = "R";break;case 18: str = "S";break;case 19: str = "T";break;
    
30. case 20: str = "U";break;case 21: str = "V";break;case 22: str = "W";break;case 23: str = "X";break;
    
31. case 24: str = "Y";
    
32. break;
    
33. case 25: str = "Z";
    
34. break;
    
35. 
    
36. }
    
37. ssb.append(str);
    
38. 
    
39. }
    
40. 
    
41. k++; //循环一次k就增大一下
    
42. sign++; //判断标记，
    
43. System.out.println(ssb.toString());
    
44. if(sign==10)
    
45. k = 1 ;
    
46. 
    
47. // System.out.println("\n");
    
48. 
    
49. 
    
50. try{LittleGame.class.wait();}catch(Exception e){}
    
51. ssb.delete(0, ssb.length()); //每次线程唤醒后就把ssb中的元素清空
    
52. }
    
53. }
    
54. }
    
55. }
    

复制代码

接下来是计时的类了，没用计时器，用了sleep()的方法让它睡一秒钟，我感觉这里我做我不好

1. package Game.MyselfLittleGame.game;
   
2. 
   
3. public class Time implements Runnable
   
4. {
   
5. public static int times= 0;
   
6. public static boolean flag = false;
   
7. 
   
8. public void run()
   
9. {
   
10. while(true)
    
11. {
    
12. times++;
    
13. try{Thread.sleep(1000);}catch(Exception e){}
    
14. if(flag)
    
15. {
    
16. // System.out.println("用时："+times);
    
17. flag=false; //每次按下回车键时，就会执行这里的代码一次，
    
18. times=0; //把flag变回false 和times置零
    
19. }
    
20. if(RandomChar2.sign==10)
    
21. {
    
22. synchronized(LittleGame.class)
    
23. {
    
24. try{LittleGame.class.wait();}catch(Exception e){} // sign等于十次时，线程等待
    
25. }
    
26. }
    
27. }
    
28. }
    
29. 
    
30. }
    

复制代码

下面是程序运行截图，不知道楼主要实现的功能是不是这样子的（说实话楼主的功能描述的不是很清楚，我是琢磨出的）

               开始时随机产生一个字母，我输入一个字母，如果正确，那么又随机产生两个字母，正确，又随机产生三个，又输入，直到最后产生十个字母时，输入正确后，提示游戏通关，是否要不要继续               
    当时间太长了或输入错误游戏就结束。
写完之后感觉有很多不足的地方，首先静态变量用的太多了，其次计时器其实会不太准，锁也是为了用wait()方法才用的锁的，不过由于水平限制除了这么干我还真想不出再能怎么干了。

jxj4227982333 发表于 2012-6-9 20:16
基础视频我也看完了，正好拿你这个题来练练手，今天一天我就写了这么个程序，不知道符不符合楼主的功能要求 ...

哇，基础一看完就能写出这程序厉害啊

jxj4227982333 发表于 2012-6-9 20:16
基础视频我也看完了，正好拿你这个题来练练手，今天一天我就写了这么个程序，不知道符不符合楼主的功能要求 ...

其实你能做出来已经非常厉害了，这题是我的一个学弟问我的。我自己写了一天也写不出来，后来去问了以前大学教我JAVA的老师才搞定，觉得这个问题对刚学完JAVA基础还是有不小的难度的。

这个是在老师的帮助下写的另外一种方法

ps：老师果然是老师。。姜还是老的辣啊

1. 
   
2. 
   
3. import java.util.Random;//随机数生成器
   
4. import java.util.Scanner;//一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器
   
5. import java.util.Timer;//计时器
   
6. import java.util.TimerTask;
   
7. 
   
8. public class MyGame
   
9. {
   
10.     //用户产生随机数
    
11.     public final static  Random random = new Random();
    
12.     //输出的字符串,用户给用户提供一个打印模板
    
13.     public final static StringBuffer sb = new StringBuffer("");
    
14.     //每次都会让用户输入的数+1,用作统计用户输入的数
    
15.     private static int charCounter = 1;
    
16.     //设定输入时间,因为游戏叫做"是男人就坚持10秒",所以默认值是10
    
17.     private static final int cancelSecond = 10;
    
18.     //设定闯关成功字符数
    
19.     private static final int OK = 10;
    
20.     public static void main(String[] args)
    
21.     {
    
22.         new MyGame().start();
    
23.     }
    
24. 
    
25.         //游戏主体
    
26.     public void start()
    
27.     {
    
28.         final Scanner scanner = new Scanner(System.in);
    
29.         final Timer timer = new Timer();
    
30.                 //下面我用了内部类
    
31.         timer.schedule(new TimerTask()//schedule()方法:安排在指定的时间执行指定的任务。
    
32.         {
    
33.             public void run()
    
34.              {
    
35.                  long startSecond = System.currentTimeMillis();
    
36.                   for(int i=0;i<charCounter;i++)
    
37.                   {
    
38.                       int randNum=random.nextInt(26);
    
39.                       char character =(char)(randNum+'A');
    
40.                       sb.append(character);
    
41.                   }
    
42.                        System.out.println(sb);
    
43.                         while(true)
    
44.                           {
    
45.                             String inputString = scanner.next();
    
46.                              //如果当前时间-开始时间>默认时间
    
47.                              if(System.currentTimeMillis()-startSecond>cancelSecond*1000)
    
48.                              {
    
49.                                  System.out.println("连"+cancelSecond+"秒都坚持不了,还算不算男人");
    
50.                                  System.exit(0);//游戏失败，退出。
    
51.                              }
    
52.                              //如果用户输入正确,进入下一关
    
53.                              if(inputString.toUpperCase().equals(sb.toString()))
    
54.                               {
    
55.                                   if(charCounter == OK)
    
56.                                    {
    
57.                                         System.out.println("恭喜闯关成功");
    
58.                                          System.exit(0);
    
59.                                     }
    
60.                                     System.out.println("Go next level");
    
61.                                     charCounter++;
    
62.                                     sb.delete(0,sb.length());
    
63.                                     break;
    
64.                                     //否则,提示继续闯关
    
65.                               }else
    
66.                               {
    
67.                                     startSecond = System.currentTimeMillis();
    
68.                                     System.out.println("Go on to write it");
    
69.                                     System.out.println(sb);
    
70.                               }
    
71.                      }
    
72.                }
    
73.          },0, 1000);
    
74.     }
    
75. }

复制代码

都比较厉害，我才看了4天视频，感觉会的太少了，只能写点超级简单的小程序

小张童鞋 发表于 2012-6-9 21:36
这个是在老师的帮助下写的另外一种方法

ps：老师果然是老师。。姜还是老的辣啊 ...

我的代码是这两倍了，老师就是老师！
正则表达式的视频我刚刚看，不过那个随机生成字母的代码太绝了，我咋就没想到呢！

好像大家都是用线程写的？  不用线程可以不  能不能用递归来搞定   不好意思 我只是想想~~~~