[关闭]
@Darcy 2017-08-11T03:17:32.000000Z 字数 17511 阅读 2847

第十一章 回归图形—乒乓球游戏

JavaForKids

在5,6,7章中，我们使用到了一些AWT和Swing的组件。现在我将向你展示如何在窗口中绘制和移动类似椭圆，矩形，线条类型的对象。你还会学到如何处理鼠标和键盘事件。为了增添一些乐趣，在这一章中我们将会通过创建乒乓球游戏的形式来学习。这个游戏会有两个玩家，我将他们分别称作小孩和电脑。

1. 游戏策略

先列出这个游戏的一些规则：

  1. 当其中一个玩家(小孩或者电脑)拿到21分时，游戏结束。
  2. 小孩的球拍由电脑鼠标来控制操作。
  3. 游戏分数展示在窗口的底部。
  4. 当一名玩家按下N键时开始一轮新游戏，按下Q键结束当局游戏，按下S键进行发球。
  5. 只有小孩可以发球。
  6. 把球击过竖线而且对方没有接到，获得一分。
  7. 电脑击中球后，只能水平向右移动。
  8. 如果小孩的球拍在桌子上半部分击中球，那么球应该向左上方移动；如果在桌面下半部分接到球，就向左下方移动。

你一定觉得这个程序太难写不出来。秘诀是我们可以将一个复杂的任务分解成一系列更小更简单的任务，再逐个击破。

这个秘诀叫做分散思维，这种思维方式不仅能帮助我们编程，还能在生活中广泛应用：如果你不能达到某个大目标，不要沮丧，将这个目标分解成一系列的小目标，然后逐一实现。

这也是为什么第一个版本的游戏只实现三条规则：只需要绘制球台，移动球拍，点击鼠标时能展示鼠标指针的坐标。

分散思维例子:

与其说“我的电脑不能使用了”（一个大问题），还不如尝试看看到底是哪个地方出问题了（找到小问题）。
1. 电脑有接通电源吗（是/否）？ 是。
2. 当我开机时，有看到屏幕上有这些图标吗（是/否）？ 是。
3. 我的鼠标能在屏幕上移动吗？（是/否）？ 否。
4. 鼠标线有插紧了吗？（是/否）？ 否。
只需要把鼠标插好，电脑就能再次工作了！一个大问题的解决方式仅仅只是插紧鼠标线而已。

2. 代码结构

这个游戏将由下面三个类组成：

乒乓球台看起来如下图所示：

游戏第一版将只完成三件事：

  1. 显示绿色的乒乓球台。
  2. 在你点击鼠标时显示鼠标指针的坐标。
  3. 将小孩的球拍上下移动。

在下面内容中你会看到PingPongGreenTable是Swing包中JPanel类的子类。请务必要对照代码阅读以下内容:

由于在游戏中需要鼠标指针的确切位置，在这里我们通过在PingPongGreenTable的构造方法中创建PingPongGameEngine这个监听器实例来实现。当小孩点击鼠标或者移动鼠标时，PingPongGameEngine类会做出事件响应。

addPaneltoFrame()方法创建了一个展示鼠标坐标的标签。

这个类并不是一个applet 程序，这也是为什么我们要用paintComponent()方法而不是paint()。paintComponent()方法在两种情况下会被JVM调用：在程序需要刷新窗口时，或者当程序调用了repaint()方法时。前面已经学习过，repaint()方法内部调用了paintComponent()，并回传Graphics对象，这样你就能绘制窗口了。每一次重新计算了球拍或者球的坐标后，我们都需要调用repaint()方法使球拍或者球展示在正确的位置上。

为了绘制球拍，首先设置需要的颜色，然后用fillRect()方法将颜色填充到矩形内。这个方法需要知道矩形左上角的x坐标、y坐标以及矩形宽度width、高度height，它们的单位都是像素。球的绘制使用fillOval()方法，这个方法需要知道椭圆的中心点坐标(x,y)，高度height和宽度width。当椭圆的高度和宽度一致时，就成了圆。

在窗口中，x坐标从左向右递增，y坐标至上向下递增。比如，下面这个矩形的宽度是100个像素，高度是70个像素：

x和y的坐标写在圆括号中展示在矩形的各个角附近。

getPreferredSize()方法也很有意思。我们创建一个Dimension类的实例来设置球桌的尺寸。JVM通过调用PingPongGreenTable对象的getPreferredSize()方法来获得窗口的大小。这个方法会根据球台的尺寸给JVM返回一个Dimension对象。

球台和引擎类都用到到不需要改变的常量值。比如PingPongGreenTable用到了球台的宽度和高度，PingPongGameEngine需要知道球的移动增量：增量越小，移动越平滑。在接口中声明这些常量（final变量）是很方便的。在我们的游戏程序中，接口名称是GameConstants。如果一个类需要用到这些值，只需要在类声明时加上implements GameConstants，然后就可以任意使用接口类中的所有final变量的，就像已经在自身类中声明了一样。这也是为什么PingPongGreenTable和PingPongGameEngine都实现了GameConstants接口。

如果你想要改变球台，球或者球拍的尺寸，只需要在一个地方进行改动—GameConstants接口中。现在来看看PingPongGreenTable类和GameConstants接口。

我们先来看看接口类GameConstants，所有的变量值单位都是像素，使用大写字母来命名final变量。

  1. package screens;
  3. public interface GameConstants {
  4.     public final int TABLE_WIDTH = 320;
  5.     public final int TABLE_HEIGHT = 220;
  6.     public final int KID_RACKET_Y_START = 100;
  7.     public final int KID_RACKET_X_START = 300;
  8.     public final int TABLE_TOP = 12;
  9.     public final int TABLE_BOTTOM = 180;
  10.     public final int RACKET_INCREMENT = 4;
  11. }

程序在运行中不能修改声明为final类型的变量的值。但如果你一定要修改，比如你想要将球台的尺寸扩大，那么就需要修改TABLE_WIDTH和TABLE_HEIGHT的值，然后重新编译GameConstants接口。

下面是我们游戏中创建的乒乓球台的有关常量大小:

下面是乒乓球桌的实现类，你可以对照着上面的图或者运行的效果来阅读下面的代码。

  1. /**
  2.  * 
  3.  * 这个类负责绘制绿色的乒乓球桌，球拍，鼠标点击会显示坐标
  4.  * 
  5.  */
  6. public class PingPongGreenTable extends JPanel implements GameConstants {
  7.     JLabel label;
  8.     public Point point = new Point(0, 0);
  10.     public int ComputerRacket_X = 15;
  11.     private int kidRacket_Y = KID_RACKET_Y_START;
  13.     Dimension preferredSize = new Dimension(TABLE_WIDTH, TABLE_HEIGHT);
  15.     // 这个方法会被JVM调用来设置窗口框架的大小
  16.     public Dimension getPreferredSize() {
  17.         return preferredSize;
  18.     }
  20.     // 构造方法。创建并添加各种事件
  21.     PingPongGreenTable() {
  23.         PingPongGameEngine gameEngine = new PingPongGameEngine(this);
  24.         // 监听鼠标的点击并显示点击坐标
  25.         addMouseListener(gameEngine);
  26.         // 监听鼠标移动，让球拍随之移动
  27.         addMouseMotionListener(gameEngine);
  28.     }
  30.     // 把当前的面板和一个提示标签添加到窗口框架中
  31.     void addPaneltoFrame(Container container) {
  32.         container.setLayout(new BoxLayout(container, BoxLayout.Y_AXIS));
  33.         container.add(this);
  34.         label = new JLabel("点击显示该点坐标");
  35.         container.add(label);
  36.     }
  38.     // 重绘窗口。当刷新屏幕或者调用repaint()的时候会被JVM调用
  39.     @Override
  40.     public void paintComponent(Graphics g) {
  42.         super.paintComponent(g);
  43.         g.setColor(Color.GREEN);
  44.         // 绘制绿色的球桌
  45.         g.fillRect(0, 0, TABLE_WIDTH, TABLE_HEIGHT);
  47.         // 绘制右边小孩的黄色球拍
  48.         g.setColor(Color.yellow);
  49.         g.fillRect(KID_RACKET_X_START, kidRacket_Y, 5, 30);
  51.         // 绘制左边电脑的蓝色球拍
  52.         g.setColor(Color.blue);
  53.         g.fillRect(ComputerRacket_X, 100, 5, 30);
  55.         // 绘制红色小球
  56.         g.setColor(Color.red);
  57.         g.fillOval(25, 110, 10, 10);
  59.         // 绘制四周和中间的白线
  60.         g.setColor(Color.white);
  61.         g.drawRect(10, 10, 300, 200);
  62.         g.drawLine(160, 10, 160, 210);
  64.         // 显示一点2×2像素大小的矩形小点
  65.         if (point != null) {
  66.             label.setText("Coordinates (x,y): " + point.x + ", " + point.y);
  67.             g.fillRect(point.x, point.y, 2, 2);
  68.         }
  69.     }
  71.     /**
  72.      * 设置小孩球拍的Y坐标
  73.      * 
  74.      * @param yCoordinate
  75.      *            从球桌顶部开始向下算，单位是像素
  76.      */
  77.     public void setKidRacket_Y(int xCoordinate) {
  78.         this.kidRacket_Y = xCoordinate;
  79.     }
  81.     /**
  82.      * 获取小孩球拍的Y坐标
  83.      * 
  84.      * @return
  85.      */
  86.     public int getKidRacket_Y(int xCoordinate) {
  87.         return kidRacket_Y;
  88.     }
  90.     public static void main(String[] args) {
  91.         // 创建窗口框架实例
  92.         JFrame f = new JFrame("乒乓球游戏");
  93.         // 设置点击窗口右上角的关闭按钮可退出
  94.         f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  96.         PingPongGreenTable table = new PingPongGreenTable();
  97.         table.addPaneltoFrame(f.getContentPane());
  99.         // 自适应尺寸和显示窗口
  100.         f.pack();
  101.         f.setVisible(true);
  102.     }
  103. }

这个程序中的决策者是PingPongGameEngine类，这个类实现了两个鼠标相关的接口。MouseListener中只有mousePressed()方法有实现代码。鼠标每点击一次，这个方法就会在球桌上绘制一个小白点，并展示它的坐标。实际上，这段代码对我们这个游戏是没有用的，但是它向你展示了获取鼠标坐标的简单方式：通过JVM提供的MouseEvent对象。

mousePressed()方法根据玩家点击鼠标时指针的位置来给point变量设置值。在坐标值设定后，该方法向JVM请求重新绘制球桌。

MouseMotionListener对玩家在球桌上移动鼠标做出响应。我们会用到它的mouseMoved()方法来操作小孩的球拍上下移动。

我们可以在mouseMoved()里面计算小孩球拍的下一个位置：如果鼠标指针的位置比球拍高(也就是鼠标的y坐标比球拍的y坐标小)，则让球拍的位置加上相应的移动距离，反之，要减去相应的移动距离，但是要保证球拍的坐标不能超过球桌的高度范围。

当我们在PingPongGreenTable的构造方法里面创建engine对象的时候，我们还向engine传入了这个table对象本身的引用(这里的this关键字表示对当前PingPongGreenTable对象的引用)。现在engine就可以和table“对话”了，比如设置乒乓球坐标或者重新绘制球桌。如果这一部分的内容你不太清楚，或许你需要回头看看第六章关于类之间参数传递的部分。

GameConstants接口中定义了球拍每次的移动增量（engine类实现了这个接口），球拍从一个位置垂直地移动到另一个位置移动距离是RACKET_INCREMENT[4]个像素。比如，下一行代码表示kidRacket_Y变量减去4：

  1. kidRacket_Y -= RACKET_INCREMENT;

举个例子，如果球拍的y坐标原本为100，在这行代码之后就变成了96，也就意味着球拍向上移动了。使用下面的语句你也能得到相同的结果：

  1. kidRacket_Y = kidRacket_Y - RACKET_INCREMENT;

如果你还记得，我们在第三章的时候讨论过修改变量值的不同方式。

PingPongGameEngine如下所示：

  1. public class PingPongGameEngine implements MouseListener, MouseMotionListener,
  2.         GameConstants {
  4.     PingPongGreenTable table;
  5.     public int kidRacket_Y = KID_RACKET_Y_START;
  7.     public PingPongGameEngine(PingPongGreenTable greenTable) {
  8.         table = greenTable;
  9.     }
  11.     /**
  12.      * 按下鼠标的是否JVM会回调这个方法
  13.      */
  14.     public void mousePressed(MouseEvent e) {
  15.         // 获取鼠标按下时的坐标，并设置到table对象中，对应的就是table中的白点。
  16.         table.point.x = e.getX();
  17.         table.point.y = e.getY();
  18.         // 调用这个方法会触发table的paintComponent()去刷新窗口
  19.         table.repaint();
  20.     }
  22.     public void mouseReleased(MouseEvent e) {
  23.     };
  25.     public void mouseEntered(MouseEvent e) {
  26.     };
  28.     public void mouseExited(MouseEvent e) {
  29.     };
  31.     public void mouseClicked(MouseEvent e) {
  32.     };
  34.     public void mouseDragged(MouseEvent e) {
  35.     }
  37.     public void mouseMoved(MouseEvent e) {
  38.         int mouse_Y = e.getY();
  39.         // 如果鼠标在小孩的球拍之上并且没有超过球桌的顶部，那就让球拍向上移动，反之向下
  40.         if (mouse_Y < kidRacket_Y && kidRacket_Y > TABLE_TOP) {
  41.             kidRacket_Y -= RACKET_INCREMENT;
  42.         } else if (kidRacket_Y < TABLE_BOTTOM) {
  43.             kidRacket_Y += RACKET_INCREMENT;
  44.         }
  46.         // 设置小孩球拍新的Y坐标
  47.         table.setKidRacket_Y(kidRacket_Y);
  48.         table.repaint();
  49.     }
  50. }

3. Java线程基础

到目前为止，我们的程序都是按顺序逐个执行的。如果一个程序调用两个方法，那么等到第一个方法执行完毕后第二个方法才开始运行。换句话说，我们的每个程序都只有一个执行线程。

然后在现实生活中，我们可以在同一时刻同时做好几件事情，比如边吃东西边讲电话、看电视或者做家庭作业。为了让这些行为同步进行，我们用到了好几个处理器：手，眼睛和嘴巴。

一些比较贵的电脑会有两个甚至更多的处理器[1]。但是大部分的电脑都只有一个处理器来执行计算，给监听器发命令，访问磁盘，访问远程计算机等等。

但是如果一个程序使用多线程，那么即使一个处理器也能并行执行好几个动作[2]。一个Java类可以开启多条执行线程来排队等待处理器的时间片。

Web浏览器是一个程序创建多条线程的典型例子。你可以在浏览网页的同时下载一些文件：那么这时候浏览器程序就是在执行两条线程。

我们乒乓球游戏的下一个版本将会有一条线程来展示球桌，另一条线程会计算球和球拍的坐标并发送给第一条线程使其重绘窗口。但是我先要展示两个简单的程序让你对“线程为什么有用?”有更好的理解。

每一个示例程序都会显示一个按钮以及一个文本框。

当你按下按钮Kill Time后，这个程序会开启循环将让一个变量自增30,000次，并且让每次循环都“休息”一小段时间。变量的当前值会展示在窗口的标题栏上。NoThreadsSample类只有一条执行线程，在循环执行的过程中，你无法在文本框中输入任何内容。这个循环占据了处理器的全部时间，这就是为什么程序窗口被锁住了。

编译和运行这个类，你可以看到窗口在有些时候会被锁住。请注意，这个类没有声明一个变量来保存对JTextField实例的引用，而是直接创建了一个JTextField的实例，并直接传递给内容面板作为参数。如果你不打算在程序中设置或者获取这个对象中的一些属性值，你不需要使用引用变量。

  1. public class NoThreadsSample extends JFrame implements ActionListener {
  4.     //构造方法
  5.     NoThreadsSample() {
  6.         // 创建一个有一个按钮和一个输入文本框的窗口
  7.         GridLayout gl = new GridLayout(2, 1);
  8.         this.getContentPane().setLayout(gl);
  9.         JButton myButton = new JButton("Kill Time");
  10.         myButton.addActionListener(this);
  11.         this.getContentPane().add(myButton);
  12.         this.getContentPane().add(new JTextField());
  13.     }
  15.     // 处理按钮点击
  16.     public void actionPerformed(ActionEvent e) {
  17.         // 消耗一些时间去阻塞窗口的控件
  18.         for (int i = 0; i < 30000; i++) {
  19.             try {
  20.                 Thread.sleep(100);
  21.             } catch (InterruptedException e1) {
  22.                 e1.printStackTrace();
  23.             }
  24.             this.setTitle("i=" + i);
  25.         }
  26.     }
  28.     public static void main(String[] args) {
  29.         NoThreadsSample myWindow = new NoThreadsSample();
  30.         myWindow.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  32.         myWindow.setBounds(0, 0, 150, 100);
  33.         myWindow.setVisible(true);
  34.     }
  35. }

这个小窗口程序的下一个版本将会创建并启动一条单独的线程来做循环操作，而窗口的主线程使你可以在循环运行时向文本框中输入内容。

你可以采用下面列举的任一方法创建Java线程：

1、创建Java类Thread的实例，并将实现了Runnable接口的对象实例作为this参数传入。如果你的类实现了Runnable接口，那么代码看起来会是这样的：

  1. Thread worker = new Thread(this);

这个接口要求你在run方法中写入需要独立线程运行的代码。但是为了启动这条线程，你需要调用方法start()，start()方法才能真正地调用你的run()方法。我知道这有点让你困惑，但这就是你启动这条线程的方式：

  1. worker.start();

2、创建一个Thread类的子类，并实现run方法。启动这条线程的方法是调用start()。

  1. public class MyThread extends Thread{
  2.     public static void main(String[] args) {
  3.         MyThread worker = new MyThread();
  4.         worker.start();
  5.     }
  6.     public void run(){
  7.         // 在这里写线程运行的代码
  8.     }
  9. }

在ThreadsSample中，我会采用第一种方式来实现多线程，因为ThreadsSample类已经继承了JFrame，而在Java中，一个类是不能有多个父类的。

  1. public class ThreadsSample extends JFrame implements ActionListener, Runnable {
  3.     ThreadsSample() {
  4.         GridLayout gl = new GridLayout(2, 1);
  5.         this.getContentPane().setLayout(gl);
  6.         JButton myButton = new JButton("Kill Time");
  7.         myButton.addActionListener(this);
  8.         this.getContentPane().add(myButton);
  9.         this.getContentPane().add(new JTextField());
  10.     }
  12.     public void actionPerformed(ActionEvent e) {
  13.         //创建一个消耗时间的线程，同时让窗口处于可活动状态
  14.         Thread worker = new Thread(this);
  15.         worker.start(); // 开启线程，它会执行run里面的代码
  16.     }
  18.     public void run() {
  19.         for (int i = 0; i < 30000; i++) {
  20.             try {
  21.                 Thread.sleep(100);
  22.             } catch (InterruptedException e1) {
  23.                 e1.printStackTrace();
  24.             }
  25.             this.setTitle("i=" + i);
  26.         }
  27.     }
  29.     public static void main(String[] args) {
  31.         ThreadsSample myWindow = new ThreadsSample();
  32.         myWindow.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  34.         myWindow.setBounds(0, 0, 150, 100);
  35.         myWindow.setVisible(true);
  36.     }
  37. }

当你点击Kill Time时，ThreadsSample启动了一条新的线程。在这之后，这条控制循环的线程和主线程轮流获取处理器的时间片。现在你可以在另一条线程运行循环的同时向文本框中输入内容（主线程）了。

多线程不仅仅只局限于这几页的学习，我建议你进行多线程相关的延伸阅读。

4. 完成乒乓球游戏

简单地介绍过多线程后，我们可以来修改乒乓球游戏的代码了。

让我们从PingPongGreenTable类开始。我们不需要在用户点击鼠标时展示一个小白点--这只是为了学习如何展示鼠标坐标的小练习。这也是为什么我们移除了PingPongGreenTable中point变量的声明和在paintComponent()方法里面绘制小白点的几行代码。同样，构造器也不需要添加MouseListener，因为它的作用仅仅是为了展示小白点。

在另一个方面，这个类需要对键盘按钮点击做出响应（N开始游戏，S发球，Q结束游戏）。addKeyListener()可以做到这些。

为了让我们的代码具备更好的封装性，我还要将repaint()方法从engine类移到PingPongGreenTable。通过这样修改之后，从现在开始，在有需要(比如球的位置发生了改变等)的时候，table就会自动重绘自己了。

我还添加了方法来改变球的位置，改变电脑球拍的位置，展示信息。

  1. /**
  2.  *
  3.  * 这个类负责绘制绿色的乒乓球桌，球拍和显示分数
  4.  *
  5.  */
  6. public class PingPongGreenTable extends JPanel implements GameConstants {
  7.     private JLabel label;
  9.     private int computerRacket_Y = COMPUTER_RACKET_Y_START;
  10.     private int kidRacket_Y = KID_RACKET_Y_START;
  11.     private int ballX = BALL_START_X;
  12.     private int ballY = BALL_START_Y;
  14.     Dimension preferredSize = new Dimension(TABLE_WIDTH, TABLE_HEIGHT);
  16.     //这个方法会被JVM调用来设置窗口框架的大小
  17.     @Override
  18.     public Dimension getPreferredSize() {
  19.         return preferredSize;
  20.     }
  22.     // 构造方法。创建并添加各种事件
  23.     PingPongGreenTable() {
  24.         PingPongGameEngine gameEngine = new PingPongGameEngine(this);
  25.         // 添加鼠标移动事件
  26.         addMouseMotionListener(gameEngine);
  27.         // 添加键盘事件
  28.         addKeyListener(gameEngine);
  29.     }
  31.     // 把当前的面板和一个提示标签添加到窗口框架中
  32.     void addPaneltoFrame(Container container) {
  33.         container.setLayout(new BoxLayout(container, BoxLayout.Y_AXIS));
  34.         container.add(this);
  35.         label = new JLabel("按下N键开始新游戏，S键开球，Q键退出。");
  36.         container.add(label);
  37.     }
  39.     // 重绘窗口。当刷新屏幕或者调用repaint()的时候会被JVM调用
  40.     @Override
  41.     public void paintComponent(Graphics g) {
  43.         super.paintComponent(g);
  44.         g.setColor(Color.GREEN);
  45.         // 绘制绿色的球桌
  46.         g.fillRect(0, 0, TABLE_WIDTH, TABLE_HEIGHT);
  48.         // 绘制右边小孩的黄色球拍
  49.         g.setColor(Color.yellow);
  50.         g.fillRect(KID_RACKET_X, kidRacket_Y, RACKET_WIDTH, RACKET_LENGTH);
  52.         // 绘制左边电脑的绿色球拍
  53.         g.setColor(Color.blue);
  54.         g.fillRect(COMPUTER_RACKET_X, computerRacket_Y, RACKET_WIDTH,RACKET_LENGTH);
  56.         // 绘制小球
  57.         g.setColor(Color.red);
  58.         g.fillOval(ballX, ballY, 10, 10);
  60.         // 绘制四周和中间的白线
  61.         g.setColor(Color.white);
  62.         g.drawRect(10, 10, 300, 200);
  63.         g.drawLine(160, 10, 160, 210);
  65.         // 设置面板的状态为focus, 这样键盘事件才会传递到这个面板上
  66.         requestFocus();
  67.     }
  69.     /**
  70.      * 设置小孩球拍的Y坐标
  71.      * @param yCoordinate 从球桌顶部开始向下算，单位是像素
  72.      */
  73.     public void setKidRacket_Y(int yCoordinate) {
  74.         this.kidRacket_Y = yCoordinate;
  75.         repaint();
  76.     }
  78.     /**
  79.      * 获取小孩球拍的Y坐标
  80.      * @return
  81.      */
  82.     public int getKidRacket_Y() {
  83.         return kidRacket_Y;
  84.     }
  86.     /**
  87.      * 设置电脑球拍的Y坐标
  88.      * @param yCoordinate 从球桌顶部开始向下算，单位是像素
  89.      */
  90.     public void setComputerRacket_Y(int yCoordinate) {
  91.         this.computerRacket_Y = yCoordinate;
  92.         repaint();
  93.     }
  95.     /**
  96.      * 设置在面板下面的游戏消息提示。
  97.      * @param text
  98.      */
  99.     public void setMessageText(String text) {
  100.         label.setText(text);
  101.         repaint();
  102.     }
  104.     /**
  105.      * 设置球在球桌上的坐标
  106.      * @param xPos 从球桌左边开始向右算，单位是像素
  107.      * @param yPos 从球桌顶部开始向下算，单位是像素
  108.      */
  109.     public void setBallPosition(int xPos, int yPos) {
  110.         ballX = xPos;
  111.         ballY = yPos;
  112.         repaint();
  113.     }
  115.     /**
  116.      * 程序入口
  117.      * @param args
  118.      */
  119.     public static void main(String[] args) {
  121.         // 创建窗口框架实例
  122.         JFrame f = new JFrame("乒乓球游戏");
  124.         PingPongGreenTable table = new PingPongGreenTable();
  125.         table.addPaneltoFrame(f.getContentPane());
  127.         // 设置窗口大小
  128.         f.setBounds(0, 0, TABLE_WIDTH + 20, TABLE_HEIGHT + 60);
  129.         f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  130.         f.setVisible(true);
  131.     }
  132. }

以下是我在PingPongGameEngine类中重点改变的部分：

  1. 我移除了MouseListener接口及其所有方法，因为我们不再需要处理鼠标点击事件。MouseMotionListener会处理所有的鼠标移动事件。
  2. 这个类实现了Runnable接口，你可以在run()方法中找到游戏策略的实现代码。看看构造器——我在里面创建并启动了一条新的线程。run()方法分步骤实现游戏策略的规则，这些规则写在if语句if(ballServed)中。if(ballServed)是if(ballServed==true)的简写。
  3. 请留意if条件语句刚开始给变量canBounce的赋值的地方，这里使用了条件表达式来给这个变量赋值，根据前面条件的成立与否来决定赋值为true或者false。
  4. 这个类实现了KeyListener接口，keyPressed()根据键盘输入的字母来决定是开始游戏还是结束游戏，或者是发球。这个方法的代码实现了允许用户随意输入大小写，比如N或者n。
  5. 我还添加了一些private的方法比如displayScore(), kidServe()还有 isBallOnTheTable()。这些方法被声明为private是因为他们只在这个类的内部用到，其他类完全不需要知道它们。这也是封装性的实际应用。
  6. 一些电脑的运行速度太快，使得球的移动很难控制。这也是为什么我调用了Thread.sleep()来放慢游戏。静态方法sleep()会把当前运行的线程暂停一段时间，它的参数单位是毫秒。
  7. 为了给这个游戏增添些乐趣，当小孩的球拍击中球后会向对角移动。这也是为什么代码不仅要改变x坐标还要改变y坐标。
  1. /**
  2.  * 
  3.  * 这个类是是鼠标和键盘的监听处理类。它负责计算球和拍的移动，改变它们的坐标。
  4.  *
  5.  */
  6. public class PingPongGameEngine implements Runnable, MouseMotionListener,
  7.         KeyListener, GameConstants {
  9.     private PingPongGreenTable table;// 球桌对象的引用
  10.     private int kidRacket_Y = KID_RACKET_Y_START;
  11.     private int computerRacket_Y = COMPUTER_RACKET_Y_START;
  12.     private int kidScore;
  13.     private int computerScore;
  14.     private int ballX;  // 小球的X坐标
  15.     private int ballY;  // 小球的Y坐标
  16.     private  boolean movingLeft = true; //true为向左移动，false为向右移动
  18.     private volatile boolean ballServed = false;  
  20.     // 球在垂直方向的移动分量
  21.     private int verticalSlide;
  23.     // 带参数的构造方法，参数为球桌对象
  24.     public PingPongGameEngine(PingPongGreenTable greenTable) {
  25.         table = greenTable;
  27.         //创建和开启小球和电脑球拍的移动线程
  28.         Thread worker = new Thread(this);
  29.         worker.start();
  30.     }
  32.     //MouseMotionListener接口中的方法(接口中的方法必须覆盖，即使是个空方法)
  33.     @Override
  34.     public void mouseDragged(MouseEvent e) {
  35.     }
  37.     //鼠标移动时会被JVM调用这个方法
  38.     @Override
  39.     public void mouseMoved(MouseEvent e) {
  41.         int mouse_Y = e.getY();
  43.         // 如果鼠标在小孩的球拍之上并且没有超过球桌的顶部，那就让球拍向上移动，反之向下
  44.         if (mouse_Y < kidRacket_Y && kidRacket_Y > TABLE_TOP) {
  45.             kidRacket_Y -= RACKET_INCREMENT;
  46.         } else if (kidRacket_Y < TABLE_BOTTOM) {
  47.             kidRacket_Y += RACKET_INCREMENT;
  48.         }
  50.         // 设置小孩球拍新的Y坐标
  51.         table.setKidRacket_Y(kidRacket_Y);
  52.     }
  54.      //键盘按下时会被JVM调用这个方法
  55.     @Override
  56.     public void keyPressed(KeyEvent e) {
  57.         char key = e.getKeyChar();
  58.         if ('n' == key || 'N' == key) {
  59.             startNewGame();
  60.         } else if ('q' == key || 'Q' == key) {
  61.             endGame();
  62.         } else if ('s' == key || 'S' == key) {
  63.             kidServe();
  64.         }
  65.     }
  67.     @Override
  68.     public void keyReleased(KeyEvent e) {
  69.     }
  71.     @Override
  72.     public void keyTyped(KeyEvent e) {
  73.     }
  75.     /**
  76.      * 重置分数，开始新游戏
  77.      */
  78.     public void startNewGame() {
  79.         computerScore = 0;
  80.         kidScore = 0;
  81.         table.setMessageText("Score Computer: 0  Kid: 0");
  82.         kidServe();
  83.     }
  86.     /**
  87.      * 退出程序
  88.      */
  89.     public void endGame() {
  90.         System.exit(0);
  91.     }
  93.     /**
  94.      * Runnable 接口的方法，会在线程开启之后被调用
  95.      */
  96.     @Override
  97.     public void run() {
  99.         boolean canBounce = false; //是否往回弹
  101.         while (true) {
  103.             if (ballServed) { //球是否在运动
  105.                 //第1步：球是否向左边移动
  106.                 if (movingLeft && ballX > BALL_MIN_X) {
  108.                     //是否能击中小球
  109.                     canBounce = computerRacket_Y <= ballY && ballY < (computerRacket_Y + RACKET_LENGTH) ? true: false;
  111.                     //加上水平移动分量
  112.                     ballX -= BALL_INCREMENT;
  114.                     // 加上垂直移动分量
  115.                     ballY -= verticalSlide;
  117.                     table.setBallPosition(ballX, ballY);
  119.                     //已经到了对面，能击中小球？
  120.                     if (ballX <= COMPUTER_RACKET_X && canBounce) {
  121.                         movingLeft = false;
  122.                     }
  123.                 }
  125.                 //第2步：球是否向右边移动
  126.                 if (!movingLeft && ballX <= BALL_MAX_X) {
  128.                     canBounce = ballY >= kidRacket_Y&& ballY < (kidRacket_Y + RACKET_LENGTH) ? true: false;
  130.                     ballX += BALL_INCREMENT;
  131.                     table.setBallPosition(ballX, ballY);
  132.                     if (ballX >= KID_RACKET_X && canBounce) {
  133.                         movingLeft = true;
  134.                     }
  135.                 }
  137.                 // 第3步：上或下移动电脑球拍
  138.                 if (computerRacket_Y < ballY && computerRacket_Y < TABLE_BOTTOM) {
  139.                     computerRacket_Y += RACKET_INCREMENT;
  140.                 } else if (computerRacket_Y > TABLE_TOP) {
  141.                     computerRacket_Y -= RACKET_INCREMENT;
  142.                 }
  143.                 table.setComputerRacket_Y(computerRacket_Y);
  145.                 // 第4步: 让线程睡一下，这样小球可以移动地慢些
  146.                 try {
  147.                     Thread.sleep(SLEEP_TIME);
  148.                 } catch (InterruptedException e) {
  149.                     e.printStackTrace();
  150.                 }
  152.                 // 第5步: 如果球还在球桌内，并且不再移动了，就显示分数
  153.                 if (isBallOnTheTable()) {
  154.                     if (ballX > BALL_MAX_X) {
  155.                         computerScore++;
  156.                         displayScore();
  157.                     } else if (ballX < BALL_MIN_X) {
  158.                         kidScore++;
  159.                         displayScore();
  160.                     }
  161.                 }
  162.             } 
  163.         } 
  164.     }
  166.     // 小孩发球
  167.     private void kidServe() {
  169.         ballServed = true;
  170.         ballX = KID_RACKET_X - 1;
  171.         ballY = kidRacket_Y;
  173.         if (ballY > TABLE_HEIGHT / 2) {
  174.             verticalSlide = -1;
  175.         } else {
  176.             verticalSlide = 1;
  177.         }
  179.         table.setBallPosition(ballX, ballY);
  180.         table.setKidRacket_Y(kidRacket_Y);
  181.     }
  183.     private void displayScore() {
  184.         ballServed = false;
  186.         if (computerScore == WINNING_SCORE) {
  187.             table.setMessageText("Computer won! " + computerScore + ":"+ kidScore);
  188.         } else if (kidScore == WINNING_SCORE) {
  189.             table.setMessageText("You won! " + kidScore + ":" + computerScore);
  190.         } else {
  191.             table.setMessageText("Computer: " + computerScore + " Kid: "+ kidScore);
  192.         }
  193.     }
  195.     /**
  196.      * 检查球是否还在球桌上
  197.      * @return 如果还在球桌范围，返回true; 否则返回false
  198.      */
  199.     private boolean isBallOnTheTable() {
  200.         if (ballY >= BALL_MIN_Y && ballY <= BALL_MAX_Y) {
  201.             return true;
  202.         } else {
  203.             return false;
  204.         }
  205.     }
  206. }

NOTE：细心的同学相信已经发现有个成员变量被添加了volatile关键字，这是译者在检查代码的时候发现程序运行不正常之后加上的，这可能是由于新版本的JDK的内存模型发生了变化，在这里我们的目的是为了让它在内存中值发生变化的时候立即对另外一个线程可见。实际上源代码还存在不少的多线程问题，当然这是比较高级的话题了，你可以先忽略这个关键字，它不会影响你对程序的整体理解的。

好吧，恭喜你！现在已经完成了你的第二个游戏。编译这个类开始玩乒乓球游戏吧。在你对代码更熟悉后，尝试着去修改它，我相信你会有更好的主意把这个游戏写得更好。

5. 关于游戏编程你还可以阅读的内容

  1. CodeRally是一个由IBM赞助的，基于Java的实时编程游戏,它基于Eclipse平台。它可以让不熟悉Java的用户更容易地完成Java语言学习。玩家开发一部赛车，再根据其他玩家或者检查站的位置，以及他们当前的油量等等其他因素来决定将汽车加速、转弯、减速。
    http://www.alphaworks.ibm.com/tech/codeRally

  2. Robocode是一个有趣的编程游戏，通过让你创建Java机器人来进行Java教学。
    http://www.alphaworks.ibm.com/tech/robocode

6. 扩展阅读

Java多线程指南：
http://java.sun.com/docs/books/tutorial/essential/threads/
Java多线程介绍：
http://www-106.ibm.com/developerworks/edu/j-dwjavathread-i.html
java.awt.Graphics类：
http://t.cn/RLmNSCg

7. 练习

  1. PingPongGameEngine使用下面代码来设置白点的坐标：
  1. table.point.x = e.getX();。

把PingPongGreenTable中的point变量变成private类型，并添加public权限的setPointCoordinates(int x, int y)来修改point的值。

使用这个方法修改engine类的代码。

2.我们的乒乓球游戏有个bug: 在已经决出胜负后，你仍然可以按下s键，游戏会继续进行。修复这个bug。

8. 进一步的练习

  1. 尝试修改RACKET_INCREMENT和BALL_INCREMENT的值。值越大球拍和球的速度越快。修改代码使玩家可以选择1-10关，将选择的值作为球和球拍的增量。

  2. 目前的规则是当小孩在球桌的顶部击中球时，球会按对角线向上移动再快速掉落在桌面。修改程序将球按对角线从顶部向下移动，或者按对角线从底部向上移动。

創用 CC 授權條款
本著作係採用創用 CC 姓名標示-非商業性-禁止改作 2.5 中國大陸 授權條款授權.

[1] 现在大部分的电脑都有多个处理器，而且价格也不贵。 ↩
[2] 一个处理器并行处理多个任务，就想当于你写一下作业，然后去看看电视，接着又回来写作业，是一种在时间上复用计算资源的方法，我们可以把它叫做时分复用。 ↩
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注