栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java学习笔记(网络)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java学习笔记(网络)

Java学习笔记(网络)
    • 学习说明
    • 第三十章 网络
      • 客户端/服务端计算
      • InetAddress类
      • 服务多个客户
      • 发送和接收对象
      • 从Web服务器上读取文件
      • 实例学习--分布式井字游戏

学习说明
要点:
	讲解了基本的客户端和服务器端通信,包括单个用户和多个用户的
		(多个用户则为每个连接--监听,分配一个线程即可)
	以比较简单的分布式井字游戏为例,了解网络编程的基本点


学习资料为:《Java语言程序设计》梁勇
第三十章 网络 客户端/服务端计算
服务器套接字
客户端套接字

创建服务器套接字后,会一直等待,直到一个客户端连接到服务器端套接字
    Socket socket = new Socket(serverName, port);
    举例:Socket socket = new Socket("127.0.0.1", 8000);
    当然也可以使用域名:
    Socket socket = new Socket("baidu.com", 8000);
    	(当然,这个我没试过,不过要连上的话,肯定需要防火墙设置)

通过套接字进行数据传输:
    InputStream input = socket.getInputStream();
    OutputStream output = socket.getOutputStream();

也可以使用DataInputStream、DataOutputStream、BufferedReader、PrintWriter来
	包装InputStream、OutputStream,以读取int、double、String之类的数据

下面直接上示例讲解:
// 服务器端
public class Server extends JFrame {
	private static final long serialVersionUID = 1L;
	
	private JTextArea jta = new JTextArea();
	
	public static void main(String[] args) {
		new Server();
	}
	
	public Server() {
		setLayout(new BorderLayout());
		add(new JScrollPane(jta));
		
        // 这次的基本设置不能放在main函数里面,因为下面进入while循环,在那等,需要在这里先渲染出来
		setTitle("Socket Demo");
		setSize(500, 300);
		setLocationRelativeTo(null);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
		
		ServerSocket serverSocket = null;
		try {
            // 创建服务器端套接字
			serverSocket = new ServerSocket(8000);
			jta.append("Server started at " + new Date() + "n");
			
            // 进行监听
			Socket socket = serverSocket.accept();
			
            // 输入输出流
			DataInputStream inputFromClient = new DataInputStream(socket.getInputStream());
			DataOutputStream outputToClient = new DataOutputStream(socket.getOutputStream());
			
			while (true) {
                // 从客户端读取
				double radius = inputFromClient.readDouble();
				double area = radius * radius * Math.PI;
				
                // 发送(写)到客户端
				outputToClient.writeDouble(area);
				
				jta.append("Radius received from client: " + radius + "n");
				jta.append("Area found: " + area + "n");
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

// 客户端
public class Client extends JFrame {
	private static final long serialVersionUID = 1L;
	
	private JTextField jtf = new JTextField();
	private JTextArea jta = new JTextArea();
	
	private DataOutputStream toServer;
	private DataInputStream fromServer;
	
	public static void main(String[] args) {
		new Client();
	}
	
	public Client() {
		JPanel panel = new JPanel();
		panel.setLayout(new BorderLayout());
		panel.add(new JLabel("Enter radius"), BorderLayout.WEST);
		panel.add(jtf, BorderLayout.CENTER);
		jtf.setHorizontalAlignment(JTextField.RIGHT);
		
		setLayout(new BorderLayout());
		add(panel, BorderLayout.NORTH);
		add(new JScrollPane(jta), BorderLayout.CENTER);
		
		setTitle("Client Demo");
		setSize(500, 300);
		setLocationRelativeTo(null);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
		
        // 监听器
		jtf.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				try {
					double radius = Double.parseDouble(jtf.getText().trim());
					toServer.writeDouble(radius);
					toServer.flush();
					double area = fromServer.readDouble();
					
					jta.append("Radius is " + radius + "n");
					jta.append("Area received from the server is " + area + "n");
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
		});
        jta.append("wait to connectn");
		
        // 进行套接字的创建与输入输出流的设定
        // 这样只写一次的话,就是执行一次尝试连接,可以修改为循环,多次尝试,直到连接上
		Socket socket = null;
		try {
			socket = new Socket("127.0.0.1", 8000);
			fromServer = new DataInputStream(socket.getInputStream());
			toServer = new DataOutputStream(socket.getOutputStream());
		} catch (IOException e) {
			jta.append(e.getMessage());
		}
        if(socket != null) {
            jta.append("connect successfully, please input radiusn");
        }
	}
}


// 下面部分的代码修改为循环尝试连接
jta.append("wait to connectn");
Socket socket = null;
while (socket == null) {
    try {
        socket = new Socket("127.0.0.1", 8000);
        fromServer = new DataInputStream(socket.getInputStream());
        toServer = new DataOutputStream(socket.getOutputStream());
    } catch (IOException e) {
        if(socket != null)
            jta.append(e.getMessage());
    }
    if(socket != null) {
        jta.append("connect successfully, please input radiusn");
    }
}
InetAddress类
获取主机名和IP地址:
    通过socket创建对象
    通过域名创建对象

示例如下:
public class IdentifyHostNameIP {
	public static void main(String[] args) {
		System.out.println("Start listen");
		InetAddress inetAddress = null;
		Socket socket = null;
		
        // 这里要想连接上,必须先打开服务器端的监听
		while (socket == null) {
			try {
				socket = new Socket("127.0.0.1", 8000);
				inetAddress = socket.getInetAddress();
			} catch (IOException e) {
				
			}
		}

		System.out.println(inetAddress.getHostName());
		System.out.println(inetAddress.getHostAddress());

        // 下面是通过域名获取连接信息
		InetAddress inetAddress2 = null;
		try {
			inetAddress2 = InetAddress.getByName("baidu.com");
		} catch (UnknownHostException e) {
			e.printStackTrace();
		}

		System.out.println(inetAddress2.getHostName());
		System.out.println(inetAddress2.getHostAddress());
		
        // 这里加个循环是为了不让服务器端直接停掉,当然也可以修改一下服务器端的逻辑
        // 只要将服务器端的错误打印删掉就好了,这样就不会覆盖控制台的结果
        while (true) {
			
		}
	}
}
服务多个客户
很简单,只要为每个连接创建一个线程就好了
while (true) {
    socket = serverSocket.accept();
    Thread thread = new ThreadClass(socket);
    thread.start();
}
完整的服务器端示例如下:
public class MultiThreadServer extends JFrame {
	private static final long serialVersionUID = 1L;

	private JTextArea jta = new JTextArea();

	public static void main(String[] args) {
		new MultiThreadServer();
	}

	public MultiThreadServer() {
		setLayout(new BorderLayout());
		add(new JScrollPane(jta));

		setTitle("MultiThreadServer Demo");
		setSize(500, 300);
		setLocationRelativeTo(null);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);

		ServerSocket serverSocket = null;
		try {
			serverSocket = new ServerSocket(8000);
			jta.append("Server started at " + new Date() + "n");

			int clientNo = 1;
			while (true) {
				Socket socket = serverSocket.accept();
				
				jta.append("Starting thread for client " + clientNo + " at" + new Date() + "n");
				
                // 将连接信息打印出来
				InetAddress inetAddress = socket.getInetAddress();
				jta.append("Client " + clientNo + "'s host name is " + inetAddress.getHostName() + "n");
				jta.append("Client " + clientNo + "'s IP Address is " + inetAddress.getHostAddress() + "n");
				
                // 对每一个连接上了的都创建一个线程
				HandleClient task = new HandleClient(socket);
				new Thread(task).start();
				
				clientNo++;
			}
		} catch (IOException e) {
			// 这里就不打印了,不太好看
		}
	}

	class HandleClient implements Runnable {
		private Socket socket;

		public HandleClient(Socket socket) {
			this.socket = socket;
		}

		@Override
		public void run() {
			try {
				DataInputStream inputFromClient = new DataInputStream(socket.getInputStream());
				DataOutputStream outputToClient = new DataOutputStream(socket.getOutputStream());

				while (true) {
					double radius = inputFromClient.readDouble();
					double area = radius * radius * Math.PI;

					outputToClient.writeDouble(area);

					jta.append("Radius received from client: " + radius + "n");
					jta.append("Area found: " + area + "n");
				}

			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}
发送和接收对象
采用ObjectOutputStream、ObjectInputStream进行操作,但每个对象都要求是可序列化的(至于啥是可序列化,我们很抽象,不太理解)

下面以发送学生信息为例,进行讲解演示:
// 学生类(存储基本信息)
public class StudentAddress implements Serializable {
	private static final long serialVersionUID = 1L;
	
	private String name;
	private String street;
	private String city;
	private String state;
	private String zip;
	
	public StudentAddress(String name, String street, String city, String state, String zip) {
		super();
		this.name = name;
		this.street = street;
		this.city = city;
		this.state = state;
		this.zip = zip;
	}

	public static long getSerialversionuid() {
		return serialVersionUID;
	}

	public String getName() {
		return name;
	}

	public String getStreet() {
		return street;
	}

	public String getCity() {
		return city;
	}

	public String getState() {
		return state;
	}

	public String getZip() {
		return zip;
	}
}

// 客户端,发送填写的学生信息
public class StudentClient extends JFrame {
	private static final long serialVersionUID = 1L;
	
	private JTextField jtfName = new JTextField(32);
	private JTextField jtfStreet = new JTextField(32);
	private JTextField jtfCity = new JTextField(20);
	private JTextField jtfState = new JTextField(2);
	private JTextField jtfZip = new JTextField(5);
	private JButton jbtnRegister = new JButton("Register to the Server");
	
	String host = "127.0.0.1";
	
	public StudentClient() {
		JPanel panel = new JPanel();
		panel.setLayout(new GridLayout(3, 1));
		panel.add(new JLabel("Name"));
		panel.add(new JLabel("City"));
		panel.add(new JLabel("Street"));
		
		JPanel jpState = new JPanel();
		jpState.setLayout(new BorderLayout());
		jpState.add(new JLabel("State"), BorderLayout.WEST);
		jpState.add(jtfState, BorderLayout.CENTER);
		
		JPanel jpZip = new JPanel();
		jpZip.setLayout(new BorderLayout());
		jpZip.add(new JLabel("Zip"), BorderLayout.WEST);
		jpZip.add(jtfZip, BorderLayout.CENTER);
		
		JPanel panel2 = new JPanel();
		panel2.setLayout(new BorderLayout());
		panel2.add(jpState, BorderLayout.WEST);
		panel2.add(jpZip, BorderLayout.CENTER);
		
		JPanel panel3 = new JPanel();
		panel3.setLayout(new BorderLayout());
		panel3.add(jtfCity, BorderLayout.CENTER);
		panel3.add(panel2, BorderLayout.EAST);
		
		JPanel panel4 = new JPanel();
		panel4.setLayout(new GridLayout(3, 1));
		panel4.add(jtfName);
		panel4.add(jtfStreet);
		panel4.add(panel3);
		
		JPanel studentJPanel = new JPanel(new BorderLayout());
		// 这一句setBorder让上边框变得好看了一些
        studentJPanel.setBorder(new BevelBorder(BevelBorder.RAISED));
		studentJPanel.add(panel, BorderLayout.WEST);
		studentJPanel.add(panel4, BorderLayout.CENTER);
		
		add(studentJPanel, BorderLayout.CENTER);
		add(jbtnRegister, BorderLayout.SOUTH);
		
		jbtnRegister.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				Socket socket = null;
				try {
					socket = new Socket(host, 8000);
					ObjectOutputStream toServer = new ObjectOutputStream(socket.getOutputStream());
					
					String name = jtfName.getText().trim();
					String street = jtfStreet.getText().trim();
					String city = jtfCity.getText().trim();
					String state = jtfState.getText().trim();
					String zip = jtfZip.getText().trim();

					StudentAddress studentAddress = new StudentAddress(name, street, city, state, zip);
					toServer.writeObject(studentAddress);
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
		});
	}
	
	public static void main(String[] args) {
		JFrame frame = new StudentClient();
		frame.setTitle("Register Student Client");
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
}

// 服务器端,将接收到的对象写入文件
public class StudentServer {
	private ObjectOutputStream outputToFile;
	private ObjectInputStream inputFromClient;
	
	public static void main(String[] args) {
		new StudentServer();
	}
	
	public StudentServer() {
		ServerSocket serverSocket = null;
		try {
			serverSocket = new ServerSocket(8000);
			System.out.println("Server Started");
			outputToFile = new ObjectOutputStream(new FileOutputStream("student.txt", true));
			
			while (true) {
				Socket socket = serverSocket.accept();
				inputFromClient = new ObjectInputStream(socket.getInputStream());
				
				Object object = inputFromClient.readObject();
				outputToFile.writeObject(object);
				System.out.println("A new student object is stored");
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
从Web服务器上读取文件
从服务器上读取文件,示例如下:(需要先打开服务器端的连接)
public class ViewRemoteFile extends JFrame {
	private static final long serialVersionUID = 1L;
	
	private JButton jbtnView = new JButton("View");
	private JTextField jtfURL = new JTextField();
	private JTextArea jtaFile = new JTextArea();
	private JLabel jlblStatus = new JLabel();
	
	public ViewRemoteFile() {
		JPanel panel = new JPanel();
		panel.setLayout(new BorderLayout());
		panel.add(new JLabel("Filename"), BorderLayout.WEST);
		panel.add(jtfURL, BorderLayout.CENTER);
		panel.add(jbtnView, BorderLayout.EAST);
		
		setLayout(new BorderLayout());
		add(new JScrollPane(jtaFile), BorderLayout.CENTER);
		add(panel, BorderLayout.NORTH);
		add(jlblStatus, BorderLayout.SOUTH);
		
		jbtnView.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				showFile();
			}
		});
	}
	
	private void showFile() {
		URL url = null;
		Scanner scanner = null;
        // 这里进行读取,通过url,但需要先打开服务器端的连接,即端口号上的监听(可以通过VS Code进行演示,安装live插件即可,非常方便)
		try {
			url = new URL(jtfURL.getText().trim());
			scanner = new Scanner(url.openStream());
			while (scanner.hasNext()) {
				jtaFile.append(scanner.nextLine() + "n");
			}
			jlblStatus.setText("File loaded successfully");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		JFrame frame = new ViewRemoteFile();
		frame.setTitle("ViewRemoteFile");
		frame.setSize(500, 300);
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
}
实例学习–分布式井字游戏
// 服务器端
public class TicTacToeServer extends JFrame {
	private static final long serialVersionUID = 1L;
	
	public static void main(String[] args) {
		new TicTacToeServer();
	}
	
	public TicTacToeServer() {
		JTextArea jtafLog = new JTextArea();
		JScrollPane scrollPane = new JScrollPane(jtafLog);
		add(scrollPane, BorderLayout.CENTER);
		
		setTitle("TicTacToeServer");
		setSize(500, 300);
		setLocationRelativeTo(null);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
		
		ServerSocket serverSocket;
		try {
			serverSocket = new ServerSocket(8000);
			jtafLog.append(new Date() + ":Server started at socket 8000n");
			
			int sessionNo = 1;
			
			while (true) {
				jtafLog.append(new Date() + ":Wait for player to join session " + sessionNo + "n");
				
				Socket player1 = serverSocket.accept();
				
				jtafLog.append(new Date() + ":Player 1 joined session " + sessionNo + "n");
				jtafLog.append("Player 1's IP address " + player1.getInetAddress().getHostAddress() + "n");
				
				new DataOutputStream(player1.getOutputStream()).writeInt(TicTacToeConstants.PLAYER1);
				
				
				Socket player2 = serverSocket.accept();
				
				jtafLog.append(new Date() + ":Player 2 joined session " + sessionNo + "n");
				jtafLog.append("Player 2's IP address " + player2.getInetAddress().getHostAddress() + "n");
				
				new DataOutputStream(player2.getOutputStream()).writeInt(TicTacToeConstants.PLAYER2);
				
				jtafLog.append(new Date() + ":Start a thread for session " + sessionNo++ + "n");
				
				HandleASession task = new HandleASession(player1, player2);
				new Thread(task).start();
			}
		} catch (IOException e) {
			// 
		}
	}
	
	class HandleASession implements Runnable, TicTacToeConstants {
		private Socket player1;
		private Socket player2;
		
		private char[][] cell = new char[3][3];
		
		private DataInputStream fromPlayer1;
		private DataOutputStream toPlayer1;
		private DataInputStream fromPlayer2;
		private DataOutputStream toPlayer2;
		
//		private boolean continueToPlay = true;
		
		public HandleASession(Socket player1, Socket player2) {
			this.player1 = player1;
			this.player2 = player2;
			
			for (int i = 0; i < cell.length; i++) {
				for (int j = 0; j < cell.length; j++) {
					cell[i][j] = ' ';
				}
			}
		}

		@Override
		public void run() {
			try {
				fromPlayer1 = new DataInputStream(player1.getInputStream());
				toPlayer1 = new DataOutputStream(player1.getOutputStream());
				fromPlayer2 = new DataInputStream(player2.getInputStream());
				toPlayer2 = new DataOutputStream(player2.getOutputStream());
				
				toPlayer1.writeInt(1);
				
				while (true) {
					int row = fromPlayer1.readInt();
					int column = fromPlayer1.readInt();
					cell[row][column] = 'X';
					
					if(isWon('X')) {
						toPlayer1.writeInt(PLAYER1_WON);
						toPlayer2.writeInt(PLAYER1_WON);
						sendMove(toPlayer2, row, column);
						break;
					}
					else if(isFull()) {
						toPlayer1.writeInt(DRAW);
						toPlayer2.writeInt(DRAW);
						sendMove(toPlayer2, row, column);
						break;
					}
					else {
						toPlayer2.writeInt(CONTINUE);
						sendMove(toPlayer2, row, column);
					}

					row = fromPlayer2.readInt();
					column = fromPlayer2.readInt();
					cell[row][column] = 'O';
					
					if(isWon('O')) {
						toPlayer1.writeInt(PLAYER2_WON);
						toPlayer2.writeInt(PLAYER2_WON);
						sendMove(toPlayer1, row, column);
						break;
					}
					else {
						toPlayer1.writeInt(CONTINUE);
						sendMove(toPlayer1, row, column);
					}
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		private void sendMove(DataOutputStream out, int row, int column) throws IOException {
			out.writeInt(row);
			out.writeInt(column);
		}
		
		private boolean isFull() {
			for (int i = 0; i < cell.length; i++) {
				for (int j = 0; j < cell.length; j++) {
					if(cell[i][j] == ' ')
						return false;
				}
			}
			return true;
		}
		
		private boolean isWon(char token) {
			for (int i = 0; i < cell.length; i++) {
				if(cell[i][0] == token && cell[i][1] == token && cell[i][2] == token)
					return true;
			}
			
			for (int j = 0; j < cell.length; j++) {
				if(cell[0][j] == token && cell[1][j] == token && cell[2][j] == token)
					return true;
			}
			
			if ((cell[0][0] == token) && (cell[1][1] == token) && (cell[2][2] == token)) {
				return true;
			}
			
			if ((cell[0][2] == token) && (cell[1][1] == token) && (cell[2][0] == token)) {
				return true;
			}
			
			return false;
		}
	}
}
// 客户端,目前还没添加继续游戏(即重新开始)的功能
public class TicTacToeClient extends JFrame implements Runnable, TicTacToeConstants {
	private static final long serialVersionUID = 1L;
	
	private boolean myTurn = false;
	private char myToken = ' ';
	private char otherToken = ' ';
	private Cell[][] cell = new Cell[3][3];
	
	private JLabel jlblTitle = new JLabel();
	private JLabel jlblStatus = new JLabel();
	
	private int rowSelected;
	private int columnSelected;
	
	private DataInputStream fromServer;
	private DataOutputStream toServer;
	
	private boolean continueToPlay = true;
	private boolean waiting = true;
//	private boolean isStandAlone = false;
	private String host = "127.0.0.1";
	
	public static void main(String[] args) {
		new TicTacToeClient();
	}
	
	public TicTacToeClient() {
		JPanel panel = new JPanel();
		panel.setLayout(new GridLayout(3, 3, 0, 0));
		
		for (int i = 0; i < cell.length; i++) {
			for (int j = 0; j < cell.length; j++) {
				panel.add(cell[i][j] = new Cell(i, j));
			}
		}
		
		Border border = new LineBorder(Color.BLACK, 1);
		panel.setBorder(border);
		jlblTitle.setHorizontalAlignment(JLabel.CENTER);
		jlblTitle.setFont(new Font("Times New Roman", Font.BOLD, 16));
		jlblTitle.setBorder(border);
		jlblStatus.setBorder(border);
		
		add(jlblTitle, BorderLayout.NORTH);
		add(panel, BorderLayout.CENTER);
		add(jlblStatus, BorderLayout.SOUTH);
		
		setTitle("TicTacToeClient");
		setSize(500, 300);
		setLocationRelativeTo(null);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setVisible(true);
		
		connectToServer();
	}
	
	private void connectToServer() {
		Socket socket = null;
		while (socket == null) {
			try {
				socket = new Socket(host, 8000);
				
				fromServer = new DataInputStream(socket.getInputStream());
				toServer = new DataOutputStream(socket.getOutputStream());
			} catch (IOException e) {
				// 
			}
		}
		
		Thread thread = new Thread(this);
		thread.start();
	}
	
	public class Cell extends JPanel {
		private static final long serialVersionUID = 1L;
		private int row;
		private int column;
		
		private char token = ' ';

		public Cell(int rwo, int column) {
			this.row = rwo;
			this.column = column;
			setBorder(new LineBorder(Color.BLACK, 1));
			addMouseListener(new ClickListener());
		}
	
		public char getToken() {
			return token;
		}

		public void setToken(char token) {
			this.token = token;
			repaint();
		}

		protected void paintComponent(Graphics graphics) {
			super.paintComponent(graphics);
			
			if(token == 'X') {
				graphics.drawLine(10, 10, getWidth() - 10, getHeight() - 10);
				graphics.drawLine(getWidth() - 10, 10, 10, getHeight() - 10);
			}
			else if (token == 'O') {
				graphics.drawOval(10, 10, getWidth() - 20, getHeight() - 20);
			}
		}

		private class ClickListener extends MouseAdapter {
			public void mouseClicked(MouseEvent e) {
				if((token == ' ') && myTurn) {
					setToken(myToken);
					myTurn = false;
					rowSelected = row;
					columnSelected =column;
					jlblStatus.setText("Waiting for the other player to move");
					waiting = false;
				}
			}
		}
	}
	



	@Override
	public void run() {
		try {
			int player = fromServer.readInt();
			
			if(player == PLAYER1) {
				myToken = 'X';
				otherToken = 'O';
				jlblTitle.setText("Player 1 with token 'X'");
				jlblStatus.setText("Waiting for player 2 to join");
				
				fromServer.readInt();
				jlblStatus.setText("Player 2 has joined. I start first");
				myTurn = true;
			}
			else if(player == PLAYER2) {
				myToken = 'O';
				otherToken = 'X';
				jlblTitle.setText("Player 2 with token 'O'");
				jlblStatus.setText("Waiting for player 1 to move");
			}
			
			while (continueToPlay) {
				if (player == PLAYER1) {
					waitForPlayerAction();
					sendMove();
					receiveInfoFromServer();
				}
				else if (player == PLAYER2) {
					receiveInfoFromServer();
					waitForPlayerAction();
					sendMove();
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	private void waitForPlayerAction() throws InterruptedException {
		while (waiting) {
			Thread.sleep(100);
		}
		waiting = true;
	}
	
	private void sendMove() throws IOException {
		toServer.writeInt(rowSelected);
		toServer.writeInt(columnSelected);
	}
	
	private void receiveInfoFromServer() throws IOException {
		
		int status = fromServer.readInt();
		
		if(status == PLAYER1_WON) {
			continueToPlay = false;
			if(myToken == 'X') {
				jlblStatus.setText("I won! (X)");
			}
			else if (myToken == 'O') {
				jlblStatus.setText("Player 1 (X) has won!");
				receiveMove();
			}
		}
		else if(status == PLAYER2_WON) {
			continueToPlay = false;
			if(myToken == 'O') {
				jlblStatus.setText("I won! (O)");
			}
			else if (myToken == 'O') {
				jlblStatus.setText("Player 2 (O) has won!");
				receiveMove();
			}
		}
		else if(status == DRAW) {
			continueToPlay = false;
			jlblStatus.setText("Game is over, no winner!");
			if (myToken == 'O') {
				receiveMove();
			}
		}
		else {
			receiveMove();
			jlblStatus.setText("My turn");
			myTurn = true;
		}
	}
	
	private void receiveMove() throws IOException {
		int row = fromServer.readInt();
		int column = fromServer.readInt();
		cell[row][column].setToken(otherToken);
	}
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/936473.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号