Java实现打字游戏

时间：2021-12-26 10:22:17

本文实例为大家分享了Java实现打字游戏的具体代码，供大家参考，具体内容如下

新建一个项目，然后在src里面建一个MyGame.java文件，
把代码粘到刚才新建的MyGame.java,
然后把两张图放到src下，就行了

一、代码

  1. import javax.swing.*; 
  2. import javax.swing.event.ChangeEvent; 
  3. import javax.swing.event.ChangeListener; 
  4. import java.awt.*; 
  5. import java.awt.event.*; 
  6.  
  7. public class MyGame { 
  8.  static UIFrame uiFrame;//主界面 
  9.  static playGame playgame;//正式游戏开始界面 
  10.  
  11.  public static void main(String[] args) { 
  12.   uiFrame = new UIFrame("打字游戏"); 
  13.   playgame = new playGame(); 
  14.  } 
  15.  /*游戏主界面*/ 
  16.  static class UIFrame extends JFrame { 
  17.   int width = 500; 
  18.   int height = 700; 
  19.   Font X = new Font("方正舒体", Font.PLAIN, 30); 
  20.   JLabel playjb = new JLabel("开始游戏"); 
  21.   JLabel rulejb = new JLabel("规则"); 
  22.   JLabel exitjb = new JLabel("退出游戏"); 
  23.   JFrame f1 = new JFrame("规则"); 
  24.   /*主界面设置*/ 
  25.   public UIFrame(String text) { 
  26.    super(text); 
  27.    this.setLayout(null); 
  28.    this.setSize(width, height); 
  29.    this.setLocationRelativeTo(null); 
  30.    this.setResizable(false); 
  31.    this.getLayeredPane().setLayout(null); 
  32.    JPanel imgPanel = (JPanel) this.getContentPane(); 
  33.    imgPanel.setOpaque(false); 
  34.    imgPanel.setBounds(0, 0, width, height); 
  35.    imgPanel.setLayout(null); 
  36.    ImageIcon icon = new ImageIcon("src/bg.jpg"); 
  37.    JLabel label = new JLabel(icon); 
  38.    label.setBounds(0, 0, this.getWidth(), this.getHeight()); 
  39.    icon.setImage(icon.getImage().getScaledInstance(label.getWidth(), label.getHeight(), Image.SCALE_DEFAULT)); 
  40.    this.getLayeredPane().add(label, Integer.valueOf(Integer.MIN_VALUE)); 
  41.  
  42.    Title title = new Title();//新建一个标题对象 
  43.    this.add(title);//往窗口中加入标题面板 
  44.    Thread t = new Thread(title);//将标题面板加入一个线程 
  45.    t.start();//启动线程，实现标题面板下落 
  46.  
  47.    buildButton(); 
  48.    add_JB_Listener(); 
  49.    setruleJF(); 
  50.    this.setVisible(true); 
  51.   } 
  52.   /*设置按钮规格*/ 
  53.   public void buildButton() { 
  54.    playjb.setForeground(Color.red); 
  55.    rulejb.setForeground(Color.red); 
  56.    exitjb.setForeground(Color.red); 
  57.    playjb.setFont(X); 
  58.    rulejb.setFont(X); 
  59.    exitjb.setFont(X); 
  60.    playjb.setBounds(width / 3, height * 2 / 6, width / 3, 50); 
  61.    rulejb.setBounds(width / 3, height * 3 / 6, width / 3, 50); 
  62.    exitjb.setBounds(width / 3, height * 4 / 6, width / 3, 50); 
  63.    playjb.setHorizontalAlignment(JLabel.CENTER); 
  64.    rulejb.setHorizontalAlignment(JLabel.CENTER); 
  65.    exitjb.setHorizontalAlignment(JLabel.CENTER); 
  66.  
  67.    this.add(playjb); 
  68.    this.add(rulejb); 
  69.    this.add(exitjb); 
  70.   } 
  71.   /*设置规则窗口*/ 
  72.   public void setruleJF(){ 
  73.    JLabel text1 = new JLabel("<html><body>"+"基本规则：点击开始游戏后可以选择生命值，确认后游戏正式开始游戏开始后会自动下落四个三位"+"<br>"+"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"+"数，在输入框中输入其中之一会自动消除这个三位数，" + 
  74.      "得分增加，并产生新数字,当数字"+"<br>"+"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"+"掉落到屏幕底部时生命值减一，生命值为0游戏结束。(PS：在输入框中输入空格游戏暂"+"<br>"+"&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"+"停，输入任意数字则继续)" +"<br>"+"<br>"+ 
  75.      "难度介绍：游戏难度会随着得分的增加而自动增加，也可使用滑块自己调整数字下落难度等级。"+"<br>"+"<br>"+ 
  76.      "闪烁模式：游戏开始后可以点击开始闪烁按钮来开始闪烁模式，此时数字会隔一段时间消失再出现。"+"<br>"+"<br>"+"好好享受吧！"+"</body></html>"); 
  77.    text1.setVerticalAlignment(JLabel.NORTH);//使其文本位于JLabel顶部 
  78.    text1.setFont(new Font("宋体", Font.PLAIN, 20)); 
  79.    f1.add(text1);//f1为显示规则的窗口 
  80.  
  81.    f1.setResizable(false); 
  82.    f1.setSize(2 * width - 100, height / 2); 
  83.    f1.setLocationRelativeTo(null); 
  84.   } 
  85.   /*按钮添加监听器*/ 
  86.   public void add_JB_Listener() { 
  87.    playjb.addMouseListener(new MouseAdapter() { 
  88.     @Override 
  89.     public void mouseClicked(MouseEvent e) { 
  90.      setVisible(false); 
  91.      Chooselife chooselife = new Chooselife(); 
  92.     } 
  93.  
  94.     @Override 
  95.     public void mouseEntered(MouseEvent e) { 
  96.      playjb.setBorder(BorderFactory.createMatteBorder(2, 2, 2, 2, Color.LIGHT_GRAY)); 
  97.     } 
  98.  
  99.     @Override 
  100.     public void mouseExited(MouseEvent e) { 
  101.      playjb.setBorder(null); 
  102.     } 
  103.    }); 
  104.  
  105.    rulejb.addMouseListener(new MouseAdapter() { 
  106.     @Override 
  107.     public void mouseClicked(MouseEvent e) { 
  108.      f1.setVisible(true); 
  109.     } 
  110.  
  111.     public void mouseEntered(MouseEvent e) { 
  112.      rulejb.setBorder(BorderFactory.createMatteBorder(2, 2, 2, 2, Color.LIGHT_GRAY)); 
  113.     } 
  114.  
  115.     @Override 
  116.     public void mouseExited(MouseEvent e) { 
  117.      rulejb.setBorder(null); 
  118.     } 
  119.    }); 
  120.  
  121.    exitjb.addMouseListener(new MouseAdapter() { 
  122.     @Override 
  123.     public void mouseClicked(MouseEvent e) { 
  124.      System.exit(0); 
  125.     } 
  126.  
  127.     public void mouseEntered(MouseEvent e) { 
  128.      exitjb.setBorder(BorderFactory.createMatteBorder(2, 2, 2, 2, Color.LIGHT_GRAY)); 
  129.     } 
  130.  
  131.     @Override 
  132.     public void mouseExited(MouseEvent e) { 
  133.      exitjb.setBorder(null); 
  134.     } 
  135.    }); 
  136.  
  137.   } 
  138.  } 
  139.  /*选择生命界面*/ 
  140.  static class Chooselife extends JFrame { 
  141.   static Boolean gamePlayflag = false;//第一次开始游戏则为false,否则为true， 
  142.   Chooselife() { 
  143.    setTitle("选择生命值"); 
  144.    setAlwaysOnTop(true);//置于顶部 
  145.    setLayout(null); 
  146.    setSize(300, 100); 
  147.    setLocationRelativeTo(null); 
  148.    setResizable(false); 
  149.    setBotton();//设按钮 
  150.    setVisible(true); 
  151.   } 
  152.   /*设置按钮*/ 
  153.   void setBotton() { 
  154.    ButtonGroup lives = new ButtonGroup();//新建按钮组实现互斥 
  155.    JRadioButton one = new JRadioButton("1", true);//按钮默认选择1 
  156.    JRadioButton two = new JRadioButton("2", false); 
  157.    JRadioButton three = new JRadioButton("3", false); 
  158.    lives.add(one);//按钮添加进按钮组 
  159.    lives.add(two); 
  160.    lives.add(three); 
  161.    JPanel chooselifejp = new JPanel(); 
  162.    chooselifejp.setBounds(0, 0, getWidth(), getHeight() - 60); 
  163.    chooselifejp.add(one);//按钮添加进JPanel 
  164.    chooselifejp.add(two); 
  165.    chooselifejp.add(three); 
  166.    add(chooselifejp);//JPanel添加到JFrame 
  167.  
  168.    JButton play = new JButton("开始"); 
  169.    play.setBounds(getWidth() / 3 + 10, chooselifejp.getHeight(), 70, 25); 
  170.    add(play); 
  171.    /*给开始按钮添加监听器，设置选中的生命值*/ 
  172.    play.addActionListener(new ActionListener() { 
  173.     @Override 
  174.  
  175.     public void actionPerformed(ActionEvent e) { 
  176.      if (one.isSelected()) { 
  177.       playgame.life = 1;//开始游戏后将生命值设成1 
  178.      } else if (two.isSelected()) { 
  179.       playgame.life = 2; 
  180.      } else { 
  181.       playgame.life = 3; 
  182.      } 
  183.      /*后面实现重玩再讲*/ 
  184.      playgame.templife =playgame.life;//为实现重玩功能而新建的临时变量templife，用来保存当前的生命值。 
  185.      if (!gamePlayflag) {//第一次游戏 
  186.       playgame.begin();//调用begin函数来新设置一些变量和线程、控件规格 
  187.       gamePlayflag = true; 
  188.      } else { 
  189.       playgame.injp.replay_func();//选择完生命值之后，使用第一次游戏使用的那些变量、线程、控件， 
  190.              // 然后用重玩的函数功能重置一些变量即可实现开始新一轮游戏的效果 
  191.       playgame.PlayJF.setVisible(true);//显示正式游戏界面 
  192.      } 
  193.      dispose(); 
  194.     } 
  195.    }); 
  196.   } 
  197.  } 
  198.  static class playGame { 
  199.   static int life=1; 
  200.   static int templife=1; 
  201.   static int width = 500; 
  202.   static int height = 700; 
  203.   static int N = 4;//数字列数 
  204.   static int x[] = new int[N]; 
  205.   static int y[] = new int[N]; 
  206.   static String[] num = new String[N]; 
  207.   JFrame PlayJF = new JFrame("打字游戏"); 
  208.   Image lifeicon = Toolkit.getDefaultToolkit().getImage("src/life.jpg"); 
  209.   static int difficult_level = 1;//下落难度 
  210.   static int mindifficult_level = 1;//最小下落难度 
  211.   static int shanshuo_level = 1;//闪烁难度 
  212.   Boolean terminateflag = false; 
  213.   Boolean beginflag = false; 
  214.   Boolean shanshuoflag = false; 
  215.   Boolean zantingshanshuoflag = false;//闪烁且暂停 
  216.   Boolean Gameoverflag = false; 
  217.   JTextField in = new JTextField(3); 
  218.   JLabel showtext = new JLabel(); 
  219.   int score; 
  220.   int count = 3; 
  221.   int allcount; 
  222.   int correctcount; 
  223.   int lianjicount; 
  224.   Boolean lianjiflag = false; 
  225.   MyPanel mp; 
  226.   messageJP injp; 
  227.  
  228.   /*第一次开始游戏调用*/ 
  229.   public void begin() { 
  230.    getrandnum(); 
  231.    PlayJF.setSize(width, height); 
  232.    mp = new MyPanel(); 
  233.    injp = new messageJP(); 
  234.    PlayJF.setResizable(false); 
  235.    PlayJF.setLocationRelativeTo(null); 
  236.    PlayJF.getLayeredPane().setLayout(null); 
  237.    JPanel imgPanel = (JPanel) PlayJF.getContentPane(); 
  238.    imgPanel.setOpaque(false); 
  239.    imgPanel.setBounds(0, 0, width, height); 
  240.    imgPanel.setLayout(null); 
  241.    ImageIcon icon = new ImageIcon("src/bg.jpg"); 
  242.    JLabel label = new JLabel(icon); 
  243.    label.setBounds(0, 0, PlayJF.getWidth(), PlayJF.getHeight()); 
  244.    icon.setImage(icon.getImage().getScaledInstance(label.getWidth(), label.getHeight(), Image.SCALE_DEFAULT)); 
  245.  
  246.    PlayJF.getLayeredPane().add(label, Integer.valueOf(Integer.MIN_VALUE)); 
  247.    PlayJF.getContentPane().add(mp); 
  248.    PlayJF.getContentPane().add(injp, Integer.valueOf(Integer.MAX_VALUE)); 
  249.    Thread t = new Thread(mp); 
  250.    t.start(); 
  251.    PlayJF.setVisible(true); 
  252.    in.requestFocus(); 
  253.   } 
  254.  
  255.   /*产生四个随机三位数*/ 
  256.   public static void getrandnum() { 
  257.    int i, j; 
  258.    for (i = 0; i < N; i++) {//生成数字的字符形式，设置初始横纵坐标 
  259.     num[i] = Integer.toString((int) (Math.random() * 900 + 100));//生成100到999之间随机数 
  260.     x[i] = (int) (0.1 * width + i * 0.20 * width); 
  261.     y[i] = 50; 
  262.    } 
  263.    for (i = 0; i < N; i++) { 
  264.     for (j = i + 1; j < N; j++) { 
  265.      while (num[j].charAt(0) == num[i].charAt(0)) {//若数字与前面的数字首位相同，则重新生成该数字 
  266.       num[j] = Integer.toString((int) (Math.random() * 900 + 100)); 
  267.      } 
  268.     } 
  269.    } 
  270.   } 
  271.   /*数字下落面板*/ 
  272.   class MyPanel extends JPanel implements Runnable { 
  273.    int width = PlayJF.getWidth(); 
  274.    int height = 500; 
  275.    long time;//记录时间，用于闪烁功能的实现 
  276.  
  277.    public MyPanel() { 
  278.     setOpaque(false); 
  279.     setBounds(0, 0, width, height); 
  280.     setBackground(Color.BLACK); 
  281.    } 
  282.  
  283.    public void paint(Graphics g) { 
  284.     super.paint(g); 
  285.  
  286.     if (Gameoverflag) {//游戏结束 
  287.      g.setColor(Color.RED); 
  288.      g.setFont(new Font("宋体", Font.BOLD, 35)); 
  289.      g.drawString("游戏结束！", width / 3, height / 2); 
  290.      g.drawString("您的分数为"+score,width / 3-15,height/2+35); 
  291.      gameoverwork(); 
  292.     } else { 
  293.      if (!beginflag) {//倒计时 
  294.       g.setColor(Color.RED); 
  295.       g.setFont(new Font("宋体", Font.PLAIN, 50)); 
  296.       if (count == 0) { 
  297.        g.drawString("Go!", width / 2, height / 2); 
  298.        in.setEditable(true); 
  299.  
  300.       } else { 
  301.        in.requestFocus(); 
  302.        g.drawString(String.valueOf(count), width / 2, height / 2); 
  303.       } 
  304.      } else {//数字开始掉落 
  305.       g.setFont(new Font("宋体", Font.PLAIN, 20)); 
  306.       g.setColor(Color.WHITE); 
  307.       for (int i = 0; i < N; i++) { 
  308.        if (shanshuoflag) {//进入闪烁模式 
  309.         if (zantingshanshuoflag == false) {//闪烁模式且不在暂停状态 
  310.          if (time % 3000 < 500 * shanshuo_level == false) {//闪烁：若时间满足条件，则绘出数字，否则不绘出数字 
  311.           g.drawString(num[i], x[i], y[i]); 
  312.          } 
  313.         } else {//闪烁模式且暂停，直接显示数字 
  314.          g.drawString(num[i], x[i], y[i]); 
  315.         } 
  316.        } else {//不是闪烁则正常绘出数字 
  317.         g.drawString(num[i], x[i], y[i]); 
  318.        } 
  319.  
  320.       } 
  321.  
  322.       if (terminateflag) {//画出暂停字样 
  323.        g.setColor(Color.BLUE); 
  324.        g.setFont(new Font("宋体", Font.BOLD, 30)); 
  325.        g.drawString("暂停中...", width / 4, height / 2); 
  326.        g.setFont(new Font("宋体", Font.BOLD, 20)); 
  327.        g.drawString("输入任意数字继续...", width / 4, height / 2 + 30); 
  328.  
  329.        if (shanshuoflag) { 
  330.         zantingshanshuoflag = true;//如果是暂停而且是闪烁状态， 
  331.        } 
  332.  
  333.       } else {//不暂停，每次数字纵坐标加一，掉落到底部生命值减一，重置所有数字纵坐标。 
  334.        for (int i = 0; i < N; i++) { 
  335.         y[i] = y[i] + 1; 
  336.         if (y[i] > getHeight()&&templife>0) { 
  337.          templife--; 
  338.          for(int j=0;j<N;j++){ 
  339.           y[j]=50; 
  340.          } 
  341.         } 
  342.        } 
  343.        if(templife==0){//游戏结束 
  344.         Gameoverflag=true; 
  345.        } 
  346.       } 
  347.  
  348.       g.setColor(Color.WHITE); 
  349.       g.setFont(new Font("宋体", Font.PLAIN, 20)); 
  350.       g.drawString("得分：" + score, 2, 20); 
  351.       g.drawString("生命值:", 270, 20); 
  352.       for (int i = 0; i < templife; i++) { 
  353.        g.drawImage(lifeicon, 350 + i * 21, 1, 20, 20, this);//在指定位置根据生命值绘出爱心桃 
  354.       } 
  355.      } 
  356.     } 
  357.    } 
  358.    /*清空输入框和无法输入*/ 
  359.    public void gameoverwork(){ 
  360.     in.setText(""); 
  361.     in.setEditable(false); 
  362.    } 
  363.  
  364.    @Override 
  365.    public void run() { 
  366.     long startTime = System.currentTimeMillis();//记录游戏开始时间 
  367.     while (true) { 
  368.      /*倒计时*/ 
  369.      if (!beginflag) { 
  370.       in.setEditable(false); 
  371.       repaint(); 
  372.       try { 
  373.        Thread.sleep(1000); 
  374.        count--; 
  375.        if (count == -1) { 
  376.         beginflag = true; 
  377.        } 
  378.       } catch (InterruptedException e) { 
  379.        e.printStackTrace(); 
  380.       } 
  381.      } else {//绘出数字 
  382.       repaint(); 
  383.       try { 
  384.        Thread.sleep(40 - difficult_level * 5); 
  385.       } catch (InterruptedException e) { 
  386.        e.printStackTrace(); 
  387.       } 
  388.       long endTime = System.currentTimeMillis(); 
  389.       time = endTime - startTime;//记录从开始到执行这次重绘函数后总共经历的时间 
  390.  
  391.      } 
  392.     } 
  393.    } 
  394.   } 
  395.  
  396.   /*功能面板类*/ 
  397.   class messageJP extends JPanel { 
  398.    JSlider difficultJS = new JSlider(1, 5, 1);//游戏难度滑块 
  399.    JLabel difficultJL = new JLabel();//显示“当前游戏难度为多少”的字样 
  400.    JSlider shanshuo_levelJS = new JSlider(1, 3, 1);//闪烁难度的滑块 
  401.    JLabel shanshuo_levelJL = new JLabel();//显示“闪烁难度等级”的字样 
  402.    JLabel termiJL = new JLabel();//显示“输入空格暂停”字样 
  403.    JButton replay = new JButton("重玩"); 
  404.    JButton gotomain = new JButton("返回主界面"); 
  405.    JButton shanshuoJB = new JButton("开启闪烁"); 
  406.    String input; 
  407.  
  408.    messageJP() { 
  409.     setLayout(null); 
  410.     setBounds(0, mp.getHeight(), PlayJF.getWidth(), PlayJF.getHeight() - mp.getHeight()); 
  411.     set_difficultJS(); 
  412.     set_replay(); 
  413.     set_gotomain(); 
  414.     set_shanshuoJB(); 
  415.     set_in(); 
  416.     set_termiJL(); 
  417.     set_showtext(); 
  418.  
  419.    } 
  420.    /*设置输入框的一些功能*/ 
  421.    void set_in() { 
  422.     in.setCaretPosition(in.getText().length()); 
  423.     in.setBounds(width / 4, getHeight() - 70, width / 3, 30); 
  424.     in.setFont(new Font("宋体", Font.PLAIN, 15)); 
  425.     in.addKeyListener(new KeyAdapter() { 
  426.      public void keyTyped(KeyEvent e) { 
  427.       System.out.println("KeyTyped："+in.getText()); 
  428.      } 
  429.  
  430.      public void keyPressed(KeyEvent e) { 
  431.  
  432.       super.keyPressed(e); 
  433.       System.out.println("KeyPressed："+in.getText()); 
  434.       if (e.getKeyChar() == KeyEvent.VK_SPACE) {//判断输入是否为空格 
  435.        if (terminateflag) { 
  436.         terminateflag = false; 
  437.        } else { 
  438.         terminateflag = true; 
  439.        } 
  440.       } 
  441.      } 
  442.  
  443.      public void keyReleased(KeyEvent e) { 
  444.       System.out.println("KeyReleased："+in.getText()); 
  445.       String s = in.getText().replaceAll(" ", ""); 
  446.       in.setText(s); 
  447.       if(terminateflag==true&&e.getKeyChar()!=KeyEvent.VK_SPACE){ 
  448.        terminateflag = false; 
  449.       } 
  450.       if (in.getText().length() >= 3) { 
  451.        allcount++; 
  452.        input = in.getText(); 
  453.        in.setText(""); 
  454.        lianjiflag = false; 
  455.        for (int i = 0; i < N; i++) { 
  456.         if (input.equals(num[i])) { 
  457.          y[i] = 50; 
  458.          score += 10 * difficult_level; 
  459.          correctcount++; 
  460.          lianjiflag = true; 
  461.  
  462.          if (mindifficult_level < 5 && score > 200) { 
  463.           mindifficult_level = score / 100; 
  464.           difficultJS.setMinimum(mindifficult_level);//设置滑块的最小难度 
  465.           if (difficult_level < mindifficult_level) { 
  466.            difficult_level = mindifficult_level;//如果当前难度比最小难度低，调整最小难度 
  467.           } 
  468.  
  469.           difficultJS.setValue(difficult_level); 
  470.          } 
  471.  
  472.          difficultJL.setText("下落等级:" + difficult_level); 
  473.  
  474.          num[i] = Integer.toString((int) (Math.random() * 900 + 100)); 
  475.          while (true) { 
  476.           for (int j = 0; j < N; j++) { 
  477.            if (num[i].charAt(0) == num[j].charAt(0) && i != j) { 
  478.             num[i] = Integer.toString((int) (Math.random() * 900 + 100)); 
  479.             j = -1; 
  480.            } 
  481.           } 
  482.           break; 
  483.          } 
  484.         } 
  485.        } 
  486.        if (lianjiflag) { 
  487.         lianjicount++; 
  488.        } else { 
  489.         lianjicount = 0; 
  490.        } 
  491.       } 
  492.       showtext.setText("<html>输入总次数：" + allcount + "<br/>正确次数：" + correctcount + "<br/>当前连击数：" + lianjicount + " <br/></html>"); 
  493.      } 
  494.     }); 
  495.     add(in); 
  496.    } 
  497.    /*输入空格暂停字样*/ 
  498.    void set_termiJL() { 
  499.     termiJL.setText("输入空格暂停"); 
  500.     termiJL.setFont(new Font("宋体", Font.PLAIN, 15)); 
  501.     termiJL.setForeground(Color.RED); 
  502.     termiJL.setBounds(width / 4, getHeight() - 95, width / 3, 30); 
  503.     add(termiJL); 
  504.    } 
  505.    /*难度等级滑块*/ 
  506.    void set_difficultJS() { 
  507.     difficultJS.setBounds(10, getHeight() - 110, 80, 40); 
  508.     difficultJS.setMajorTickSpacing(1); 
  509.     difficultJS.setSnapToTicks(true); 
  510.     difficultJS.setPaintTicks(true); 
  511.     difficultJS.setPaintLabels(true); 
  512.     difficultJS.addChangeListener(new ChangeListener() { 
  513.      @Override 
  514.      public void stateChanged(ChangeEvent e) { 
  515.       difficult_level = difficultJS.getValue(); 
  516.       difficultJL.setText("下落等级:" + difficult_level); 
  517.      } 
  518.  
  519.     }); 
  520.     difficultJL.setBounds(10, getHeight() - 85, 100, 50); 
  521.     difficultJL.setFont(new Font("方正姚体", Font.PLAIN, 15)); 
  522.     difficultJL.setText("下落等级:" + difficult_level); 
  523.     add(difficultJL); 
  524.     add(difficultJS, Integer.valueOf(Integer.MIN_VALUE)); 
  525.    } 
  526.    /*重玩按钮的功能*/ 
  527.    void set_replay() { 
  528.     replay.setBounds(width * 3 / 4 + 10, 0, 100, 50); 
  529.     add(replay); 
  530.     replay.addActionListener(new ActionListener() { 
  531.      @Override 
  532.      public void actionPerformed(ActionEvent e) { 
  533.       replay_func(); 
  534.      } 
  535.     }); 
  536.    } 
  537.    /*返回主界面功能*/ 
  538.    void set_gotomain() { 
  539.     gotomain.setBounds(width * 3 / 4 + 10, 55, 100, 50); 
  540.     add(gotomain); 
  541.     gotomain.addActionListener(new ActionListener() { 
  542.      @Override 
  543.      public void actionPerformed(ActionEvent e) { 
  544.       PlayJF.setVisible(false); 
  545.       uiFrame.setVisible(true); 
  546.      } 
  547.     }); 
  548.    } 
  549.    /*闪烁按钮及其功能*/ 
  550.    void set_shanshuoJB() { 
  551.     shanshuoJB.setBounds(width * 3 / 4 + 10, 110, 100, 50); 
  552.     shanshuo_levelJS.setBounds(10, 5, 80, 40); 
  553.     shanshuo_levelJS.setSnapToTicks(true); 
  554.     shanshuo_levelJS.setPaintTicks(true); 
  555.     shanshuo_levelJS.setPaintLabels(true); 
  556.     shanshuo_levelJS.setMajorTickSpacing(1); 
  557.  
  558.     shanshuo_levelJL.setFont(new Font("方正姚体", Font.PLAIN, 15)); 
  559.     shanshuo_levelJL.setText("闪烁等级:" + shanshuo_level); 
  560.     shanshuo_levelJL.setBounds(10, 30, 80, 70); 
  561.     shanshuo_levelJS.setVisible(false); 
  562.     shanshuo_levelJL.setVisible(false); 
  563.     add(shanshuoJB); 
  564.     add(shanshuo_levelJS); 
  565.     add(shanshuo_levelJL); 
  566.     shanshuoJB.addActionListener(new ActionListener() { 
  567.      @Override 
  568.      public void actionPerformed(ActionEvent e) { 
  569.       if (shanshuoflag) {//当前模式是闪烁模式 
  570.        shanshuoflag = false; 
  571.        shanshuo_levelJS.setVisible(false);//隐藏闪烁难度调节滑块 
  572.        shanshuo_levelJL.setVisible(false); 
  573.        shanshuoJB.setText("开启闪烁"); 
  574.        shanshuo_level = 1; 
  575.        shanshuo_levelJS.setValue(1); 
  576.       } else { 
  577.        shanshuoflag = true; 
  578.        shanshuo_levelJS.setVisible(true); 
  579.        shanshuo_levelJL.setVisible(true); 
  580.        shanshuoJB.setText("关闭闪烁"); 
  581.       } 
  582.  
  583.      } 
  584.     }); 
  585.     shanshuo_levelJS.addChangeListener(new ChangeListener() { 
  586.      @Override 
  587.      public void stateChanged(ChangeEvent e) { 
  588.       shanshuo_level = shanshuo_levelJS.getValue(); 
  589.       shanshuo_levelJL.setText("闪烁等级:" + shanshuo_level); 
  590.      } 
  591.     }); 
  592.    } 
  593.    /*显示一些统计信息*/ 
  594.    void set_showtext() { 
  595.     showtext.setFont(new Font("方正姚体", Font.PLAIN, 15)); 
  596.     showtext.setBounds(width / 4, 10, getWidth() / 3, getHeight() / 2); 
  597.     showtext.setText("<html>输入总次数：" + allcount + "<br/>正确次数：" + correctcount + "<br/>当前连击数：" + lianjicount + " <br/></html>"); 
  598.     showtext.setBorder(BorderFactory.createLineBorder(Color.GRAY)); 
  599.     add(showtext); 
  600.  
  601.    } 
  602.    /*实现重玩功能的函数*/ 
  603.    void replay_func() {//就是重置一些变量 
  604.     in.setEditable(true); 
  605.     difficult_level = 1; 
  606.     difficultJS.setMinimum(1); 
  607.     difficultJS.setMaximum(5); 
  608.     difficultJS.setValue(1); 
  609.     templife=life; 
  610.     shanshuo_level = 1; 
  611.     shanshuo_levelJS.setValue(1); 
  612.     shanshuo_levelJS.setVisible(false); 
  613.     shanshuo_levelJL.setVisible(false); 
  614.     terminateflag=false; 
  615.     getrandnum(); 
  616.     score = 0; 
  617.     count = 3; 
  618.     lianjicount = 0; 
  619.     allcount = 0; 
  620.     correctcount = 0; 
  621.     in.setText(""); 
  622.     showtext.setText("<html>输入总次数：" + allcount + "<br/>正确次数：" + correctcount + "<br/>当前连击数：" + lianjicount + " <br/></html>"); 
  623.     lianjiflag = false; 
  624.     shanshuoflag = false; 
  625.     shanshuoJB.setText("开启闪烁"); 
  626.     beginflag = false; 
  627.     Gameoverflag = false; 
  628.  
  629.     in.requestFocus(); 
  630.    } 
  631.   } 
  632.  } 
  633.  
  634. } 
  635.  
  636. /*在一个面板上实现标题自动下落*/ 
  637. class Title extends JPanel implements Runnable { 
  638.  int width = 500; 
  639.  int height = 250; 
  640.  int N = 4; 
  641.  int[] x = new int[N];//存储标题中的每个字的横坐标 
  642.  int[] y = new int[N];//存储标题中的每个字的纵坐标 
  643.  String[] strs = new String[]{"打", "字", "游", "戏"}; 
  644.  
  645.  Title() { 
  646.  
  647.   setBounds(0, 0, width, height);//设置面板大小 
  648.   setOpaque(false);//透明 
  649.   setplace();//设置标题每个字初始的横纵坐标 
  650.  } 
  651.  
  652.  void setplace() { 
  653.   for (int i = 0; i < N; i++) { 
  654.    x[i] = (int) (width * 0.15 + i * 0.2 * width); 
  655.    y[i] = 10; 
  656.   } 
  657.  } 
  658.  
  659.  @Override 
  660.  public void paint(Graphics g) { 
  661.   super.paint(g); 
  662.   g.setColor(Color.RED);//设置画笔颜色为红 
  663.   g.setFont(new Font("方正姚体", Font.PLAIN, 50));//设置画笔字体 
  664.   for (int i = 0; i < N; i++) { 
  665.    g.drawString(strs[i], x[i], y[i]);//在指定位置画出标题的字 
  666.    y[i]++;//标题的字纵坐标下移一像素 
  667.    if (y[i] > height - 50) {//如果到达height-50，则保持在那个位置 
  668.     y[i] = height - 50; 
  669.    } 
  670.   } 
  671.  
  672.  } 
  673.  
  674.  @Override 
  675.  public void run() { 
  676.   while (true) { 
  677.    try { 
  678.     Thread.sleep(10);//实现每10毫秒重绘一次 
  679.    } catch (InterruptedException e) { 
  680.     e.printStackTrace(); 
  681.    } 
  682.    repaint();//调用重绘函数 
  683.   } 
  684.  } 
  685. } 
 

二、图片

bg.jpg

Java实现打字游戏

life.jpg

Java实现打字游戏

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。

原文链接：https://blog.csdn.net/coolyuan/article/details/107741760

标签：

相关文章