Java 客户端-服务器不工作

出现问题，以下代码不起作用 代码：

服务器

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

    static ServerSocket serverSocket;
    static Socket socket;
    static DataOutputStream out;
    static DataInputStream in;
    static Users[] user = new Users[10];

    public static void main(String[] args) {
        try {
            System.out.println("Server Started...");
            serverSocket = new ServerSocket(7778);
            System.out.println("Server Start.");
            while (true) {
                socket = serverSocket.accept();
                for (int i = 0; i < 10; i++) {
                    if (user[i] == null) {
                        System.out.println("Conection from"
                                + socket.getInetAddress());
                        out = new DataOutputStream(socket.getOutputStream());
                        in = new DataInputStream(socket.getInputStream());

                        user[i] = new Users(out, in, user, i);
                        Thread thread = new Thread(user[i]);
                        thread.start();
                        break;
                    }
                }
            }

        } catch (IOException e) {

        }
    }
}

class Users implements Runnable {

    DataOutputStream out;
    DataInputStream in;
    Users[] user = new Users[10];
    String name;
    int playerid;
    int playeridln;
    int xin;
    int yin;

    public Users(DataOutputStream out, DataInputStream in, Users[] user, int pid) {
        this.out = out;
        this.in = in;
        this.user = user;
        this.playerid = pid;
    }

    public void run() {
        try {
            out.writeInt(playerid);
        } catch (IOException e1) {
            System.out.println("Failed to send PlayerID");
        }
        while (true) {
            try {
                playeridln = in.readInt();
                xin = in.readInt();
                yin = in.readInt();

                for (int i = 0; i < 10; i++) {
                    if (user[i] != null) {
                        user[i].out.writeInt(playeridln);
                        user[i].out.writeInt(xin);
                        user[i].out.writeInt(yin);
                    }
                }
            } catch (IOException e) {
                user[playerid] = null;
                break;
            }
        }

    }
}

import java.io.DataInputStream；
导入java.io.DataOutputStream；
导入java.io.IOException；
导入java.net.ServerSocket；
导入java.net.Socket；
公共类服务器{
静态服务器套接字服务器套接字；
静态插座；
静态数据输出流输出；
静态数据输入流；
静态用户[]用户=新用户[10]；
公共静态void main（字符串[]args）{
试一试{
System.out.println（“服务器已启动…”）；
serverSocket=新的serverSocket（7778）；
System.out.println（“服务器启动”）；
while（true）{
socket=serverSocket.accept（）；
对于（int i=0；i<10；i++）{
if（用户[i]==null）{
System.out.println（“连接自”
+socket.getInetAddress（））；
out=新的DataOutputStream（socket.getOutputStream（））；
in=新的DataInputStream（socket.getInputStream（））；
用户[i]=新用户（出、入、用户、i）；
线程线程=新线程（用户[i]）；
thread.start（）；
打破
}
}
}
}捕获（IOE异常）{
}
}
}
类用户实现可运行的{
数据输出流输出；
数据输入流输入；
用户[]用户=新用户[10]；
字符串名；
int playerid；
int playeridln；
林欣；
阴内；
公共用户（DataOutputStream-out、DataInputStream-in、Users[]用户、int pid）{
this.out=out；
this.in=in；
this.user=用户；
this.playerid=pid；
}
公开募捐{
试一试{
out.writeInt（playerid）；
}捕获（IOE1异常）{
System.out.println（“未能发送PlayerID”）；
}
while（true）{
试一试{
playeridln=in.readInt（）；
xin=in.readInt（）；
yin=in.readInt（）；
对于（int i=0；i<10；i++）{
if（用户[i]！=null）{
用户[i].out.writeInt（playeridln）；
用户[i].out.writeInt（xin）；
用户[i].out.writeInt（yin）；
}
}
}捕获（IOE异常）{
用户[playerid]=空；
打破
}
}
}
}

客户端

import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Client extends JPanel implements Runnable, KeyListener {

    private static final long serialVersionUID = 1L;
    static Socket socket;
    static DataInputStream in;
    static DataOutputStream out;

    int playerid;

    int[] x = new int[10];
    int[] y = new int[10];

    boolean left, up, right, down;

    int playerx;
    int playery;

    public Client() {
        init();
    }

    public void init() {
        try {
            System.out.println("Conecting to serever...");
            socket = new Socket("localhost", 7778);
            System.out.println("Connection successful");
            in = new DataInputStream(socket.getInputStream());
            playerid = in.readInt();
            out = new DataOutputStream(socket.getOutputStream());
            Input input = new Input(in, this);
            Thread thread = new Thread(input);
            thread.start();
            Thread thread2 = new Thread(this);
            thread2.start();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void updateCoordinates(int pid, int x2, int y2) {
        this.x[pid] = x2;
        this.y[pid] = y2;
    }

    public void paint(Graphics g) {
        repaint();
        for (int i = 0; i < 10; i++) {
            g.drawOval(x[i], y[i], 5, 5);
        }
    }

    public void run() {
        while (true) {
            if (right) {
                playerx += 10;
            }
            if (left) {
                playerx -= 10;
            }
            if (down) {
                playery += 10;
            }
            if (up) {
                playery -= 10;
            }
            if (right || left || up || down) {
                try {
                    out.writeInt(playerid);
                    out.writeInt(playerx);
                    out.writeInt(playery);
                } catch (Exception e) {
                    System.out.println("Erro Coordinates");
                }
            }
            repaint();
            try {
                Thread.sleep(400);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == 37) {
            left = true;
        }
        if (e.getKeyCode() == 38) {
            up = true;
        }
        if (e.getKeyCode() == 39) {
            right = true;
        }
        if (e.getKeyCode() == 40) {
            down = true;
        }
    }

    public void keyReleased(KeyEvent e) {
        if (e.getKeyCode() == 37) {
            left = false;
        }
        if (e.getKeyCode() == 38) {
            up = false;
        }
        if (e.getKeyCode() == 39) {
            right = false;
        }
        if (e.getKeyCode() == 40) {
            down = false;
        }
    }

    public void keyTyped(KeyEvent e) {
    }

    public static void main(String[] args) {
        JFrame f = new JFrame();
        f.setSize(300, 300);
        f.getContentPane().add(new Client());
        f.setVisible(true);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

class Input implements Runnable {

    DataInputStream in;
    Client client;

    public Input(DataInputStream in, Client c) {
        this.in = in;
        this.client = c;
    }

    public void run() {
        while (true) {
            try {
                int playerd = in.readInt();
                int x = in.readInt();
                int y = in.readInt();
                client.updateCoordinates(playerd, x, y);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

导入java.awt.Graphics；
导入java.awt.event.KeyEvent；
导入java.awt.event.KeyListener；
导入java.io.DataInputStream；
导入java.io.DataOutputStream；
导入java.io.IOException；
导入java.net.Socket；
导入java.net.UnknownHostException；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
公共类客户机扩展JPanel实现可运行的KeyListener{
私有静态最终长serialVersionUID=1L；
静态插座；
静态数据输入流；
静态数据输出流输出；
int playerid；
int[]x=新的int[10]；
int[]y=新的int[10]；
布尔左、上、右、下；
int-playerx；
智力游戏；
公共客户机（）{
init（）；
}
公共void init（）{
试一试{
System.out.println（“连接到serever…”）；
套接字=新套接字（“localhost”，7778）；
System.out.println（“连接成功”）；
in=新的DataInputStream（socket.getInputStream（））；
playerid=in.readInt（）；
out=新的DataOutputStream（socket.getOutputStream（））；
输入=新的输入（在本例中）；
线程=新线程（输入）；
thread.start（）；
螺纹2=新螺纹（此）；
thread2.start（）；
}捕获（未知后异常e）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
公共无效更新坐标（整数pid、整数x2、整数y2）{
这个.x[pid]=x2；
这个.y[pid]=y2；
}
公共空间涂料（图g）{
重新油漆（）；
对于（int i=0；i<10；i++）{
g、 drawOval（x[i]，y[i]，5,5）；
}
}
公开募捐{
while（true）{
如果（右）{
playerx+=10；
}
如果（左）{
playerx-=10；
}
如果（向下）{
玩耍次数+=10；
}
如果（向上）{
游戏性-=10；
}
如果（右|左|上|下）{
试一试{
out.writeInt（playerid）；
out.writeInt（playerx）；
外写（游戏）；
}捕获（例外e）{
System.out.println（“Erro坐标”）；
}
}
重新油漆（）；
试一试{
睡眠（400）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
按下公共无效键（按键事件e）{
如果（例如getKeyCode（）==37）{
左=真；
}
如果（例如getKeyCode（）==38）{
向上=真；
}
如果（例如getKeyCode（）==39）{
右=真；
}
如果（例如getKeyCode（）==40）{
向下=真；
}
}
公共无效密钥已释放（密钥事件e）{
如果（例如getKeyCode（）==37）{
左=假；
}
如果（例如getKeyCode（）==38）{
向上=错误；
}
如果（例如getKeyCode（）==39）{
右=假；
}
如果（例如getKeyCode（）==40）{
向下=假；
}
}
public void keyTyped（KeyEvent e）{
}
公共静态void main（字符串[]args）{
JFrame f=新的JFrame（）；
f、 设置大小（300300）；
f、 getContentPane（）