Java network programming-guessing game

猜数字游戏

游戏的规则如下：

当客户端第一次连接到服务器端时，服务器端生产一个【0，50】之间的随机数字，然后客户端输入数字来猜该数字，每次客户端输入数字以后，发送给服务器端，服务器端判断该客户端发送的数字和随机数字的关系，并反馈比较结果，客户端总共有5次猜的机会，猜中时提示猜中，当输入”quit”时结束程序。
为了实现这个游戏，我写了三个类，客户端，服务器端以及一个实现多客户端的线程类。

该程序是以前学习 Java 网络编程时所写（写于2013年5月），还有很多地方有待完善，可以参考牛人的文章。

客户端类

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.io.InputStreamReader;
  5. import java.io.OutputStream;
  6. import java.net.Socket;
  8. public class TCPGameClient
  9. {
  10.    static BufferedReader br = null;
  11.    static Socket socket = null;
  12.    static InputStream is = null;
  13.    static OutputStream os = null;
  15.    final static String HOST = "localhost";
  16.    final static int PORT = 10008;
  18.    public final static String EQUALS    = "E" ;
  19.    public final static String GREATER   = "G";
  20.    public final static String LESSER    = "L";
  21.    public final static String NEXT      = "NEXT";
  24.    public static void main(String[] args) throws Exception
  25.    {
  26.      //初始化socket，输入输出流
  27.      init();
  29.      System.out.println("The Game Begain!");
  31.      byte[] bufResult = new byte[10];
  33.      while(true)
  34.      {
  35.        //获取server产生的随机数
  36.        String strDate = new String(receive());
  38.        System.out.println("Please enter your guess:(If you want to end,input quit)");
  40.        //从控制板获取输入字符
  41.        String str = br.readLine();
  43.        if(isQuit(str))
  44.        {
  45.          System.out.println("Bye!");
  46.          break;
  47.        }
  49.        //client端控制猜谜次数
  50.        int count = 5;
  51.        while(count > 0)
  52.        {
  53.          //向 server端发送client 猜的数字
  54.          send(str.getBytes());
  56.          //接收来自server的对比后的反馈
  57.          bufResult = receive();
  58.          String result = new String(bufResult);
  60.          if(EQUALS.equalsIgnoreCase(result))
  61.          {
  62.            System.out.println("Congratulations! You are rgiht.");
  63.            send(NEXT.getBytes());
  64.            break;
  65.          } else if(GREATER.equalsIgnoreCase(result))
  66.          {
  67.            count --;
  68.            System.out.println("Greater!");
  69.            System.out.println("You have " + count + " chances left.");
  70.          } else if(LESSER.equalsIgnoreCase(result))
  71.          {
  72.            count --;
  73.            System.out.println("Lesser!");
  74.            System.out.println("You have " + count + " chances left.");
  75.          } else{;}
  77.          //猜谜次数未到？继续
  78.          if(count > 0)
  79.          {
  80.            System.out.println("Please enter your guess:");
  81.            str = br.readLine();
  82.          }
  84.          //猜谜次数已到，还没猜出？打印谜底，同时告诉server开始下一轮猜谜游戏
  85.          if(count == 0)
  86.          {
  87.            System.out.println("The right answer is: " + strDate);
  88.            send(NEXT.getBytes());
  89.          }
  90.        }
  92.      }
  94.      close();
  96.    }
  98.    private static void init() throws IOException
  99.    {
  100.      br = new BufferedReader(new InputStreamReader(System.in));
  101.      socket = new Socket(HOST, PORT);
  102.      is = socket.getInputStream();
  103.      os = socket.getOutputStream();
  104.    }
  107.    private static byte[] receive() throws IOException
  108.    {
  109.      byte[] buf = new byte[10];
  110.      int len = is.read(buf);
  111.      byte[] receiveData = new byte[len];
  113.      System.arraycopy(buf, 0, receiveData, 0, len);
  115.      return receiveData;
  116.    }
  118.    private static void send(byte[] b) throws IOException
  119.    {
  120.      os.write(b);
  121.    }
  123.    private static boolean isQuit(String str)
  124.    {
  125.      boolean flag = false;
  126.      if(null == str)
  127.        flag = false;
  128.      else
  129.        {
  130.          if("quit".equalsIgnoreCase(str))
  131.          {
  132.            flag = true;
  133.          }
  134.          else
  135.          {
  136.            flag = false;
  137.          }
  138.        }
  139.      return flag;
  140.    }
  142.    private static void close() throws Exception
  143.    {
  144.      socket.close();
  145.      is.close();
  146.      os.close();
  147.    }
  149. }

服务器类

  1. import java.io.IOException;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  5. public class TCPGameServer
  6. {
  7.    static ServerSocket serverSocket = null;
  8.    final static int PORT = 10008;
  10.    public static void main(String[] args) throws IOException
  11.    {
  12.      try
  13.      {
  14.        //初始化ServerSocke，开始监听
  15.        serverSocket = new ServerSocket(PORT);
  16.        System.out.println("The Server started.");
  18.        while(true)
  19.        {
  20.          Socket socket = serverSocket.accept();
  21.          new TCPGameThread(socket).start();
  22.        }
  24.      }
  25.      catch (Exception e)
  26.      {
  27.        e.printStackTrace();
  28.      }
  30.      serverSocket.close();
  31.    }
  33. }

线程类

  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import java.io.OutputStream;
  4. import java.net.Socket;
  5. import java.util.Random;
  7. public class TCPGameThread extends Thread
  8. {
  9.    Socket socket = null;
  10.    InputStream is = null;
  11.    OutputStream os = null;
  13.    public final static String EQUALS = "E" ;
  14.    public final static String GREATER = "G";
  15.    public final static String LESSER = "L";
  16.    public final static String NEXT = "NEXT";
  18.    public TCPGameThread(Socket socket) throws IOException
  19.    {
  20.      this.socket = socket;
  21.      is = this.socket.getInputStream();
  22.      os = this.socket.getOutputStream();
  23.    }
  25.    @Override
  26.    public void run()
  27.    {
  28.      try
  29.      {
  30.        while(true)
  31.        {
  32.          //产生一个在[0,50]之间的随机数
  33.          int randomData = -1;
  34.          randomData = createRandom(0, 50);
  35.          String str = String.valueOf(randomData);
  36.          System.out.println("random data:  " + randomData);
  38.          try
  39.          {
  40.            //将该随机数发送给client端
  41.            send(str.getBytes());
  42.          }catch(Exception e){
  43.            break;
  44.          }
  46.          while(true)
  47.          {
  48.            try
  49.            {
  50.              //接收来自client端的猜数
  51.              byte[] b = receive();
  53.              String  strReceive = new String(b, 0, b.length);
  54.              System.out.println("strReceive: " + strReceive);
  56.              if(isNext(strReceive))break;
  57.              //比较谜底和猜数之间的关系并反馈比较结果
  58.              String checkResult = checkClientData(randomData, strReceive);
  59.              send(checkResult.getBytes());
  61.            }
  62.            catch (IOException e)
  63.            {
  64.              break;
  65.            }
  66.          }
  67.        }
  68.      }
  69.      catch (Exception e)
  70.      {
  71.        try
  72.        {
  73.          close();
  74.        }
  75.        catch (Exception e1)
  76.        {
  77.          // TODO Auto-generated catch block
  78.          e1.printStackTrace();
  79.        }
  80.      }
  83.      }
  85.    private  byte[] receive() throws IOException
  86.    {
  87.      byte[] buf = new byte[10];
  88.      int len = is.read(buf);
  89.      byte[] receiveData = new byte[len];
  91.      System.arraycopy(buf, 0, receiveData, 0, len);
  93.      return receiveData;
  94.    }
  96.    private  void send(byte[] b) throws IOException
  97.    {
  98.      os.write(b);
  99.    }
  101.    private  int createRandom(int start, int end)
  102.    {
  103.      Random r = new Random();
  104.      return r.nextInt(end - start + 1) + start;
  105.    }
  107.    private  String checkClientData(int randomData, String data)
  108.    {
  109.      String checkResult = null;
  110.      int buf = Integer.parseInt(data);
  112.      if(buf == randomData)
  113.        {checkResult =  EQUALS;}
  114.      else if(buf > randomData)
  115.        {checkResult =  GREATER;}
  116.      else if(buf < randomData)
  117.        {checkResult =  LESSER;}
  118.      else
  119.      {;}
  120.      return checkResult ;
  121.    }
  123.    private  void close() throws Exception
  124.    {
  125.      socket.close();
  126.      is.close();
  127.      os.close();
  128.    }
  131.    private static boolean isNext(String str)
  132.    {
  133.      boolean flag = false;
  135.      if(null == str)
  136.        flag = false;
  137.      else
  138.        {
  139.          if(NEXT.equalsIgnoreCase(str))
  140.          {
  141.            flag = true;
  142.          }
  143.          else
  144.          {
  145.            flag = false;
  146.          }
  147.        }
  148.      return flag;
  149.    }
  151. }




posted @ 2015-08-23 21:41  AndyBlog  阅读(327)  评论(0)    收藏  举报