【案例8-1】 龟兔赛跑

【案例8-1】  龟兔赛跑

【案例介绍】

  1.任务描述

众所周知的“龟兔赛跑”故事，兔子因为太过自信，比赛中途休息而导致乌龟赢得了比赛。本案例要求编写一个程序模拟龟兔赛跑，乌龟的速度为1米/1000毫秒，兔子的速度为1.2米/1000毫秒，等兔子跑到第600米时选择休息120000毫秒，结果乌龟赢得了比赛。

2.运行结果

运行结果如图8-1所示。

图8-1 运行结果

【案例目标】

l  学会分析“龟兔赛跑”任务实现的逻辑思路。

l  能够独立完成“龟兔赛跑”程序的源代码编写、编译以及运行。

l  能够在程序中使用多线程完成逻辑思路。

【案例思路】

(1)     查看运行结果分析后，首先创建一个Torist（）方法作为乌龟线程的内部类，在Torist（）方法中使用sleep模拟乌龟跑步。

(2)     查看运行结果分析后，创建一个Rabbit（）方法作为兔子线程的内部类，在Rabbit（）方法中使用sleep模拟乌龟跑步。

(3)     最后在main方法中调用Torist（）与Rabbit（）方法实现龟兔赛跑。

【案例代码】

龟兔赛跑小程序的代码如文件8-1所示。

文件8-1  Race.java

 1   package chapter0801;

 2   public class Race {

 3       private int toristDistance;//乌龟跑过的距离

 4       private int rabbitDistance;//兔子跑过的距离

 5        /**

 6        * 乌龟线程内部类

 7        */

 8       class Torist extends Thread {

 9           @Override

 10         public void run() {

 11             //分析编程代码

 12             for (int i = 1; i <= 800; i++) {

 13                 //判断兔子是否到达终点

 14                 if (rabbitDistance == 800) {

 15                     //当兔子先800的时候 兔子就已经赢了

 16                     System.out.println("兔子赢得了比赛，此时乌龟才跑了" +

 17                     toristDistance + "米");

 18                     break;

 19            } else {

 20                     //乌龟开始跑

 21                     toristDistance += 1;

 22                     //判断距离是否是100的倍数

 23                      if (toristDistance % 100 == 0) {

 24                          try {

 25                              if (rabbitDistance == 600) {

 26                                 System.out.println("乌龟跑了" + toristDistance +

 27                                 "米，此时兔子在睡觉");

 28                             } else {

 29                                 System.out.println("乌龟跑了" + toristDistance +

 30                        "米，此时兔子过的距离是" + rabbitDistance + "米");

 31                             }

 32                             Thread.sleep(1000);

 33                         } catch (InterruptedException e) {

 34                             e.printStackTrace();

 35                         }

 36                     }

 37                 }

 38             }

 39         }

 40      }

 41   /**

 42    * 兔子线程内部类

 43    */

 44     class Rabbit extends Thread {

 45         @Override

 46         public void run() {

 47             //分析编程代码

 48             for (int i = 1; i <= 800 / 1.2; i++) {

 49                 //判断兔子是否到达终点

 50                 if (toristDistance == 800) {

 51                     //当兔子先1000的时候 兔子就已经赢了

 52                     System.out.println("乌龟赢得了比赛，此时兔子跑了" +  

 53                     rabbitDistance + "米");

 54                     break;

 55            } else {

 56                     //乌龟开始跑

 57                     rabbitDistance += 5;

 58                     //判断距离是否是100的倍数

 59                     if (rabbitDistance % 100 == 0) {

 60                         try {

 61                             System.out.println("兔子跑了" + rabbitDistance + "

 62            米，乌龟跑过了" + toristDistance + "米");

 63                             if (rabbitDistance == 600) {

 64                                 System.out.println("兔子觉得自己怎么能可以赢得比赛，

 65            所以选择睡一会");

 66                                 Thread.sleep(120000);

 67                             }

 68                             Thread.sleep(1000);

 69                         } catch (InterruptedException e) {

 70                             e.printStackTrace();

 71                         }

 72                     }

 73                 }

 74             }

 75         }

 76     }

 77     //测试

 78     public static void main(String[] args) {

 79         //1 外部类实例构建

 80         Race outer = new Race();

 81          //2兔子 乌龟线程实例构建

 82          Rabbit rabbit = outer.new Rabbit();

 83          Torist torist = outer.new Torist();

 84          //3 依次启动

 85          //在现实中 也不可能两个同时跑 这样也是很公平的

 86          rabbit.start();

 87          torist.start();

 88      }

 89  }

第8~40行代码是乌龟线程的内部类，使用for循环嵌套Thread的sleep()方法模拟乌龟跑步，第44~76行代码是兔子线程的内部类，与乌龟线程的内部类类似，第78~88行代码是启动线程，模拟乌龟兔子赛跑。