基于GUI的在线聊天

最新推荐文章于 2022-06-08 19:35:26 发布
最新推荐文章于 2022-06-08 19:35:26 发布
阅读量659 收藏 5
点赞数 1
文章标签： gui 聊天 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xayddxjsjxywuhui/article/details/53363538
版权

第一版本：

实现一个简单的聊天窗口：


import javax.swing.JFrame;
import javax.swing.JPanel;

public class ChatClient1 extends JFrame {

    public void launch() {
        this.setVisible(true);
        this.setLocation(500, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 500);
    }
    
    public static void main(String[] args) {
        new ChatClient1().launch();
    }

}

第二版本：

添加一个输入文字，以及显示文字的地方；


import java.awt.BorderLayout;
import java.awt.Color;

import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class ChatClient2 extends JFrame {

    private JTextField tf = new JTextField();
    private JTextArea ta = new JTextArea();
    
    public void launch() {
        this.setVisible(true);
        this.pack();
        ta.setBackground(Color.GRAY);
        this.setLocation(500, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 500);
        this.setLayout(new BorderLayout());
        this.add(tf, BorderLayout.SOUTH);
        this.add(ta, BorderLayout.CENTER);
    }
    
    public static void main(String[] args) {
        new ChatClient2().launch();
    }

}

第三版本：

从JTextField输入框输入文字，敲击回车键，让文字显示到JTextArea


import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class ChatClient2 extends JFrame {

    private JTextField tf = new JTextField();
    private JTextArea ta = new JTextArea();
    
    public void launch() {
        this.setVisible(true);
        this.pack();
        this.setLocation(500, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 500);
        this.setLayout(new BorderLayout());
        
        ta.setBackground(Color.GRAY);
        tf.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
            
                ta.append(tf.getText().trim() +"\n");
                tf.setText("");
            }
            
        });
        
        this.add(tf, BorderLayout.SOUTH);
        this.add(ta, BorderLayout.CENTER);
    }
    
    public static void main(String[] args) {
        new ChatClient2().launch();
    }

}

第四版本：

此版本实现客户端与服务器端的链接；

客户端：
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
import java.net.Socket;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import Chat3.ChatClient3;

public class ChatClient5 extends JFrame {

    private JTextField tf = new JTextField();
    private JTextArea ta = new JTextArea();
    private JScrollPane js = new JScrollPane(ta, 4, 4);
    
    public void launch() {
        this.setVisible(true);
        this.pack();
        this.setLocation(500, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 500);
        this.setLayout(new BorderLayout());
        
        ta.setBackground(Color.GRAY);
        tf.addActionListener(new MyTFMonitor());
        
        this.add(tf, BorderLayout.SOUTH);
        this.add(js, BorderLayout.CENTER);
    }
    
    private class MyTFMonitor implements ActionListener {
        public void actionPerformed(ActionEvent arg0) {
            
            ta.append(tf.getText().trim() +"\n");
            tf.setText("");
        }
    }
    
    public static void main(String[] args) {
        new ChatClient3().launch();
        try {
            Socket s = new Socket("127.0.0.1", 8888);
            
        } catch(IOException e) {
            e.printStackTrace();
        }
    }

}
服务器端：
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class ChatServer1 {
    public static void main(String[] args) {
        ServerSocket ss;
        try {
            ss = new ServerSocket(8888);
            while(true) {
                Socket s = ss.accept();
System.out.println("a client connected!");
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
}

第五版本：

此版本实现了将一个客户端连接到服务器上然后发送消息给服务器知道输入bye是客户端Socket自动断开，
此时JFrame并没有消失，若此时想JTextField输入信息并按下回车键，则会发生java.net.SocketException；
此时的服务器端已接收不到来自刚刚客户端的消息，但是他仍然在等待着其他客户端的连接。

客户端：
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import Chat3.ChatClient3;

public class ChatClient6 extends JFrame {

    public Socket s;
    public DataOutputStream dos;
    public DataInputStream dis;
    public JTextField tf = new JTextField();
    private JTextArea ta = new JTextArea();
    
    public void launch() {
        this.setVisible(true);
        this.pack();
        this.setLocation(500, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 500);
        this.setLayout(new BorderLayout());
        
        ta.setBackground(Color.LIGHT_GRAY);
        tf.addActionListener(new MyTFMonitor());
        
        this.add(tf, BorderLayout.SOUTH);
        this.add(ta, BorderLayout.CENTER);
        connected();
    }
    
    private class MyTFMonitor implements ActionListener {
        public void actionPerformed(ActionEvent arg0) {
            
            try {
                String str = tf.getText();
                ta.append(str.trim() +"\n");
                
                dos.writeUTF(str);
                tf.setText("");
                if(str.equalsIgnoreCase("bye")) {
                    fclose();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
            
        }
    }
    
    public void connected() {
        try {
            s = new Socket("127.0.0.1", 8888);
            System.out.println("connected!");
            OutputStream os = s.getOutputStream();
            InputStream is = s.getInputStream();
            dos = new DataOutputStream(os);
            dis = new DataInputStream(is);
            
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    public void fclose() {
        try {
            dos.flush();
            dos.close();
            dis.close();
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        new ChatClient6().launch();
    }

}
服务器端：

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

public class ChatServer2 {
    public static void main(String[] args) {
        ServerSocket ss;
        try {
            ss = new ServerSocket(8888);
            while(true) {
                Socket s = ss.accept();
System.out.println("a client connected!");
                OutputStream os = s.getOutputStream();
                InputStream is = s.getInputStream();
                DataOutputStream dos = new DataOutputStream(os);
                DataInputStream dis = new DataInputStream(is);
                while(true) {
                    String str = dis.readUTF();
                    System.out.println(str);
                    if(str.equalsIgnoreCase("bye")) {
                        break;
                    }
                }
            }
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
}

第六版本：

经过修改之后只要输入bye之后，客户端的JFrame将会自动关闭，不再会产生java.net.SocketException；
如何修改，在关闭客户端与服务器端的输入输出通道时关闭JFrame，即setVisiable（false），
之后关闭程序，即System.exit(-1);

如果客户端因断电，断网等无法控制因素导致客户端关闭时，Server端会将于客户端建立的输入输出流以及Socket关闭掉，
但是ServerSocket仍然等待其他客户端的连接。

当已经有一个服务器程序在运行，但是又启动了一个，此时只能提示用户相关信息，
并使已经在运行的程序退出System.exit(-1);


服务器端：

package Chat7;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;

public class ChatServer3 {
    public static void main(String[] args) {
        ServerSocket ss = null;
        Socket s = null;
        DataOutputStream dos = null;
        DataInputStream dis = null;
        try {
            ss = new ServerSocket(8888);
        } catch(BindException e2) {
            System.out.println("端口已被使用！");
            System.out.println("请关闭相关程序并重新运行服务器！");
            System.exit(-1);
        } catch(IOException e3) {
            e3.printStackTrace();
        }
        while(true) {
            try {
                    s = ss.accept();
System.out.println("a client connected!");
                dos = new DataOutputStream(s.getOutputStream());
                dis = new DataInputStream(s.getInputStream());
                while(true) {
                    String str = dis.readUTF();
                    System.out.println(str);
                    if(str.equalsIgnoreCase("bye")) {
                        try {
                            s.close();
                            dos.close();
                            dis.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                        break;
                    }
                }
            } catch(EOFException e) {
                System.out.println("client closed!");
            } catch(IOException e1) {
                e1.printStackTrace();
            } finally {
                try {
                    if(s != null ||
                        dos != null ||
                        dis != null) {
                        s.close();
                        dos.close();
                        dis.close();
                    }
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
    }
}

客户端：

package Chat7;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import Chat3.ChatClient3;

public class ChatClient7 extends JFrame {

    public Socket s;
    public DataOutputStream dos;
    public DataInputStream dis;
    public JTextField tf = new JTextField();
    private JTextArea ta = new JTextArea();
    
    public void launch() {
        this.setVisible(true);
        this.pack();
        this.setLocation(500, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 500);
        this.setLayout(new BorderLayout());
        
        ta.setBackground(Color.LIGHT_GRAY);
        tf.addActionListener(new MyTFMonitor());
        
        this.add(tf, BorderLayout.SOUTH);
        this.add(ta, BorderLayout.CENTER);
        connected();
    }
    
    private class MyTFMonitor implements ActionListener {
        public void actionPerformed(ActionEvent arg0) {
            
            try {
                String str = tf.getText();
                ta.append(str.trim() +"\n");
                
                dos.writeUTF(str);
                tf.setText("");
                if(str.equalsIgnoreCase("bye")) {
                    fclose();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
            
        }
    }
    
    public void connected() {
        try {
            s = new Socket("127.0.0.1", 8888);
System.out.println("connected!");
            dos = new DataOutputStream(s.getOutputStream());
            dis = new DataInputStream(s.getInputStream());
            
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    public void fclose() {
        try {
            dos.flush();
            dos.close();
            if(dis == null) {
                dis.close();
            }
            this.setVisible(false);
            System.exit(-1);
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        new ChatClient7().launch();
    }

}

第七版本：

此版本是实现多个客户端往同一个服务器端连接，一开始的问题是：
    只能实现一个客户端的连接，下一个连接只能等这个客户端断开连接了才能练上来。
    解决这种问题的方法是有两种：
    一：
        异步
    二：
        线程
        1：如何选择内部类，外部类，匿名类
            匿名类一般不考虑，内部类是这样考虑的：你这个类是否需要外边的泪服务，如果要的话就用外部类，
            如果只是自己用的话内部类就可以了。
        2：主线程只干一件事，连接客户端，美连接一个客户端就启一个线程，去单独的处理它。


服务器端：

package Chat8;

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

public class ChatServer5 {
    
    ServerSocket ss = null;
    
    public ChatServer5() {
        try {
            ss = new ServerSocket(8888);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public void connectedStart() {
        Socket s = null;
        try {
            s = ss.accept();
System.out.println("A client connected!");
        } catch (IOException e) {
            e.printStackTrace();
        }
        new Thread(new Client(s)).start();
    }
    
    public static void main(String[] args) {
        ChatServer5 cs = new ChatServer5();
        while(true) {
            cs.connectedStart(); //静态的方法中不允许有非静态的对象出现
        }
    }
    
    class Client implements Runnable {
        
        Socket s = null;
        DataOutputStream dos = null;
        DataInputStream dis = null;
        
        public Client(Socket s) {
            this.s = s;
        }
        public void run() {
            try {
                dos = new DataOutputStream(s.getOutputStream());
                dis = new DataInputStream(s.getInputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
            
            while(true) {
                String str = null;
                try {
                        str = dis.readUTF();
                //下面的两个catch不能颠倒顺序，因为如果你把所有的IOException逮到，
                //那就连SocketExcdption也就逮到了,所以不能调换顺序
                } catch(SocketException se) {
                    System.out.println("Client is not cliented!");
                    //break是当客户端因某些原因被迫没有告知服务器端就结束时（断电等），
                    //则直接break让服务器端直接等待下一个客户端的连接
                    break;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                System.out.println(str);
                if(str.equalsIgnoreCase("bye".trim())) {
                    try {
                        s.close();
                        dos.close();
                        dis.close();
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                    break;
                }
            }
        }
    }
}

客户端：

package Chat8;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import Chat3.ChatClient3;

public class ChatClient8 extends JFrame {

    public Socket s;
    public DataOutputStream dos;
    public DataInputStream dis;
    public JTextField tf = new JTextField();
    private JTextArea ta = new JTextArea();
    
    public void launch() {
        this.setVisible(true);
        this.pack();
        this.setLocation(500, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 500);
        this.setLayout(new BorderLayout());
        
        ta.setBackground(Color.LIGHT_GRAY);
        tf.addActionListener(new MyTFMonitor());
        
        this.add(tf, BorderLayout.SOUTH);
        this.add(ta, BorderLayout.CENTER);
        connected();
    }
    
    private class MyTFMonitor implements ActionListener {
        public void actionPerformed(ActionEvent arg0) {
            
            try {
                String str = tf.getText();
                ta.append(str.trim() +"\n");
                
                dos.writeUTF(str);
                tf.setText("");
                if(str.equalsIgnoreCase("bye".trim())) {
                    fclose();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
            
        }
    }
    
    public void connected() {
        try {
            s = new Socket("127.0.0.1", 8888);
System.out.println("connected!");
            dos = new DataOutputStream(s.getOutputStream());
            dis = new DataInputStream(s.getInputStream());
            
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    public void fclose() {
        try {
            dos.flush();
            dos.close();
            if(dis == null) {
                dis.close();
            }
            this.setVisible(false);
            System.exit(-1);
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        new ChatClient8().launch();
    }

}

第八版本：

本版本实现的时服务器吧接受的消息给每个客户端发过去

服务器端：

package Chat9;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;

public class ChatServer6 {
    
    List<Client> l = new <Client>ArrayList();
    ServerSocket ss = null;
    
    public ChatServer6() {
        try {
            ss = new ServerSocket(8888);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public void connectedStart() {
        Socket s = null;
        try {
            s = ss.accept();
System.out.println("A client connected!");
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        Client c = new Client(s);
        l.add(c);
        new Thread(c).start();
    }
    
    class Client implements Runnable {
        
        Socket s = null;
        DataOutputStream dos = null;
        DataInputStream dis = null;
        
        public Client(Socket s) {
            this.s = s;
        }
        public void run() {
            try {
                dos = new DataOutputStream(s.getOutputStream());
                dis = new DataInputStream(s.getInputStream());
            
                while(true) {
                    String str = null;
                    try {
                            str = dis.readUTF();
                            for(int i=0; i<l.size(); i++) {
                                Client c = l.get(i);
                                c.send(str);
                            }
                    } catch(SocketException se) {
                        System.out.println("Client is not cliented!");
                        break;
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    System.out.println(str);
                    if(str.equalsIgnoreCase("bye".trim())) {
                        try {
                            s.close();
                            dos.close();
                            dis.close();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                        break;
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if(dos!=null) {
                        dos.close();
                        l.remove(this);
                    }
                    if(dis!=null) {
                        dis.close();
                    }
                    if(s!=null) {
                        s.close();
                    }
                } catch(IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        public void send(String str) {
            try {
                dos.writeUTF(str);
                
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
    
    public static void main(String[] args) {
        ChatServer6 cs = new ChatServer6();
        while(true) {
            cs.connectedStart(); //静态的方法中不允许有非静态的对象出现
        }
    }
    
}

客户端：

package Chat9;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.SocketException;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import Chat3.ChatClient3;

public class ChatClient9 extends JFrame {

    public Socket s;
    public boolean bConnected = false;
    public DataOutputStream dos;
    public DataInputStream dis;
    public JTextField tf = new JTextField();
    private JTextArea ta = new JTextArea();
    
    public void launch() {
        this.setVisible(true);
        this.pack();
        this.setLocation(500, 100);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 500);
        this.setLayout(new BorderLayout());
        
        ta.setBackground(Color.LIGHT_GRAY);
        tf.addActionListener(new MyTFMonitor());
        
        this.add(tf, BorderLayout.SOUTH);
        this.add(ta, BorderLayout.CENTER);
        connected();
        new Thread(new RecvThread()).start();
    }
    
    private class MyTFMonitor implements ActionListener {
        public void actionPerformed(ActionEvent arg0) {
            
            try {
                String str = tf.getText();
                
                dos.writeUTF(str);
                tf.setText("");
                if(str.equalsIgnoreCase("bye".trim())) {
                    fclose();
                }
            } catch(IOException e) {
                e.printStackTrace();
            }
            
        }
    }
    
    public void connected() {
        try {
            s = new Socket("127.0.0.1", 8888);
System.out.println("connected!");
            bConnected = true;
            dos = new DataOutputStream(s.getOutputStream());
            dis = new DataInputStream(s.getInputStream());
            
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    public void fclose() {
        try {
            dos.flush();
            dos.close();
            if(dis == null) {
                dis.close();
            }
            this.setVisible(false);
            System.exit(-1);
        } catch(IOException e) {
            e.printStackTrace();
        }
    }
    
    private class RecvThread implements Runnable {

        public void run() {
            try {
                while(bConnected) {
                    String s = dis.readUTF();
                    ta.setText(ta.getText() + '\n' + s);
                }
            } catch(SocketException e1) {
                System.out.println("Another client is closed!");
            } catch(IOException e) {
                e.printStackTrace();
            }
        }
        
    }
    
    public static void main(String[] args) {
        new ChatClient9().launch();
    }

}


上面的第八版本也就是最后的版本

MKWH
关注
GUI实现聊天程序
fujiaXDY的博客
04-09 1245
package mychat; import java.awt.BorderLayout; import java.awt.Button; import java.awt.Frame; import java.awt.Panel; import java.awt.TextArea; import java.awt.TextField; import java.awt.event.KeyAdapt...
简单聊天程序（GUI界面）
01-19
Java教材中网络章节中关于TCP聊天程序的例子，结合多线程的程序设计方法，使得服务器端可以同时与多个客户端聊天
GUI界面聊天室（简单版）
07-05
实现了多个客户端在线聊天！！服务器端能改变端口号！！是GUI界面版的聊天室！！
GUI 聊天界面
app10011的博客
08-15 396
import java.awt.BorderLayout; import java.awt.Button; import java.awt.Color; import java.awt.Event; import java.awt.Font; import java.awt.Frame; import java.awt.HeadlessException; import...
基于GUI的简单聊天室01
weixin_30545285的博客
04-24 294
运用了Socket编程，gui，流的读入和写出，线程控制等 思路： 1、首先是在客户端中先建立好聊天的GUI 2、建立服务器端，设置好端口号（用SocketServer），其中需要两个boolean变量来分别表示服务器是否已经开启和是否有客户端连接进来， 　　利用while循环来让服务器在开启的情况下不断接收客户端的信息。利用DataOutputStream来进行通讯 3、客户...
基于python的GUI聊天室设计.pdf
12-05
基于Python的GUI聊天室设计 本文主要介绍了基于Python的GUI聊天室设计，通过使用Socket编程实现网络通信连接，建立一个简单的聊天功能。下面是从该文档中提取的相关知识点： 一、Socket编程 * Socket是网络上的两...
基于python进行开发的聊天室（单聊、群聊、gui界面、自动回复）
01-27
利用Socket进行编程，应用多线程进行多方的持续通信；可以进行私人、多人聊天，在登录和聊天室使用图形界面；与智能机器人聊天，通过读取csv文件...聊天室一侧可显示聊天室在线人数。 备注：使用pycharm直接打开即可
基于Socket的聊天室Python实现（GUI版）
03-08
资源内容：基于Socket的聊天室Python实现（GUI版） 使用/学习目标：了解 Socket 核心原理 特点：简单、带GUI方便使用 适用人群：想阅读Python源码的初学者，想自己搭建远程聊天室的站长们 可以参考本资源来搭建属于...
基于Java（ GUI ）实现多人在线聊天软件【100010209】
12-30
(3)维护一个当前已连接的客户端的列表，记录当前在线用户数； (4)转发一个客户端的消息到所有已连接的客户端； 客户端要实现的主要功能有： (1)通过指定 IP 地址和端口号，连接到指定的服务器； (2)发送消息给其他...
Java GUI编程实现在线聊天室
08-27
主要为大家详细介绍了Java GUI编程实现在线聊天室，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
JAVA利用多线程和Socket制作GUI界面的在线聊天室.zip
06-11
JAVA利用多线程和Socket实现的在线聊天室，利用GUI制作用户界面，服务器端：可踢人，管理员私聊，发布系统消息，群聊，客户端：私聊，屏蔽，群聊。
JavaGUI聊天室.zip
07-18
刚接触Java中的GUI编程和网络编程时觉得很有意思，所以就结合了这两个方面并结合IO、多线程的知识，做了一个GUI版的聊天室。 这个聊天室是两端开发，服务器端和客户端 **服务器端功能：** 1. 开启和关闭服务器 2. 总览聊天室内的聊天内容 3. 监听连接对象 4. 转发给客户端聊天信息 **客户端功能：** 1. 输入基本信息，服务器IP地址和端口号即可连接服 务器。 2. 查看聊天室和接收聊天室的消息记录 3. 查看了聊天室在线成员 4. 给服务器发送聊天信息
java编写的GUI简单socket聊天源码小程序
02-27
是用java编写的简单的socket通讯小程序！有界面！
聊天程序服务器端可接收客户端发送过来的 java
05-24
一个简单的群聊程序，服务器端可接收客户端发送过来的消息并向所有客户端广播，客户端可向服务器端发送消息、接收和显示服务器端发来的消息
GUI界面的UDP聊天室
weixin_51345733的博客
06-08 496
简易的聊天室
基于GUI的网络通信程序设计（服务端与多个客户端聊天）
FreshHhand的博客
07-04 265
服务端代码： import java.awt.*; import java.awt.event.*; import java.awt.event.ActionListener; //可以把最后那个单词换成* import java.io.*; import java.net.ServerSocket; import java.net.Socket; import java.util.HashMap; public class MyServer implements ActionList
JAVA GUI聊天窗口
weixin_46016036的博客
07-03 840
利用JAVA GUI制作用户聊天界面 import java.awt.; import java.awt.event.; import javax.swing.*; public class Example18 extends JFrame{ JButton sendBt; JTextField inputFiled; JTextArea chatContent; private boolean flase; public Example18(){ this.setLayout(new BorderLay.
基于GUI的网络通信程序设计
weixin_43869657的博客
09-21 2142
实验目的 1．掌握Java中GUI程序的编写，包括事件监听机制。 2．掌握Java的网络通信编程，ServerSocket，Socket类的使用。 3．掌握Java中多线程的编程，Thread类，Runnable接口的使用。 4．掌握用面向对象的方法分析和解决复杂问题。 过程演示 实验内容 图1为Socket通信服务器端界面，点击该界面中的【Start】按钮，启动服务器...
python聊天室设计_基于python的GUI聊天室设计
最新发布
05-17
要设计一个基于 Python 的 GUI 聊天室，需要使用一些库和框架来实现。下面是一些可能用到的库和框架： - Tkinter：Python 自带的 GUI 库，可以用来创建窗口、按钮、文本框等界面元素。 - Socket：用于建立 TCP 或 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值