精华内容
下载资源
问答
  • 2021-06-18 15:23:12

    制作聊天室的主界面

    设置聊天框与滚动条像素透明,露出下方背景像素

    .setOpaque(false);
    .getViewport().setOpaque(false);

    需要设置两个,查阅JDK api后发现这跟JScrollPane的实现有关。JSCrollPane有两个面板层,一个是他本身,而另外一个则是他的viewport(视口)。假设我们现在在做一个根据条件过滤的查询页面,需要对表格不断的修改然后重新显示,如果只是单元格内容变化,行列数不变,我们可以用JTable中的TableModel来实现。但是如果行列数都变了,甚至显示方式也变了。这该如何?每次都把JScrollPane删掉再重新添加?这种方式更复杂不说,如果下层面板的Layout不合适还会引发其他一系列的问题。比如说顺序,甚至重新修改JScrollPane的大小等,太麻烦,而在使用viewport的时候则可以避免这些问题,直接setViewport一下,就更新了。
     

     

     

    用户登录数的显示行数(可以删掉)

    .setVisibleRowCount(int x);

    lstUser.setVisibleRowCount(20);/**可见的行数,最多几个人**/
            lstUser.setFixedCellWidth(180);/**固定的单元格宽**/
            lstUser.setFixedCellHeight(60);/**固定的单元格高**/

    用户登录数的滑动条

    水平、垂直滚动条自动出现
    .setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    .setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);

    总是出现
    .setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
    .setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

    总是隐藏
    .setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
    .setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_NEVER);

    更多相关内容
  • 这是本人基于java的Socket开发的简单聊天室源代码(服务器部分Eclipse工程),感兴趣的小伙伴欢迎下载并改进,交流。
  • 这个是一个简单的客户端与服务器的对话程序,可以同时的开启多个窗口进行对话交流。
  • 简易聊天室,顾名思义,就是简易到不能再简易,没有用到JFrame窗口化,直接在console调试。 其中用到的io流和API: 缓冲流:BufferedReader和BufferedWriter 作用:缓冲流是一对高级流,作用是提高读写的效率,...

    简易聊天室,顾名思义,就是简易到不能再简易,没有用到JFrame窗口化,直接在console调试。
    其中用到的io流和API有:
    缓冲流:BufferedReader和BufferedWriter
    作用:缓冲流是一对高级流,作用是提高读写的效率,缓冲流内部有一个缓冲区(byte数组,默认长度8K)
    无论是单字节读写还是缓冲流读写,都以块读写进行。
    字节流:InputStream和OutputSream
    java把 IO 定义了两个超类:InputStream输入流和OutputSream输出流
    转换流:InputStreamReader和OutputStreamWriter
    作用:实现字节流和字符流之间的转换,这两个流属于字符流
    打印流:PrintWriter
    只操作目的地,不操作数据源,可以操作任意类型的数据,如果启用了自动刷新,在调用println()方法的时候加true,能够自动换行并刷新
    socket网络编程
    在网络编程中,网络上的两个程序通过一个双向的通信连接实现数据的交换,这个连接的一端称为一个socket
    Scanner就不用说了

    package socket1;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.PrintWriter;
    import java.net.Socket;
    import java.util.Scanner;
    
    /**
     * 聊天室客户端
     * @author pc
     */
    public class Client {
    	/*
    	 * java.net.Socket 套接字
    	 * Socket封装了TCP协议的通讯细节,使用它可以与远端
    	 * 计算机建立连接,并使用两个流的读写完成与远端计算机
    	 * 的数据交换。
    	 */
    	private Socket socket;
    	public Client() {
    		try {
    			/*
    			 * Socket常用构造器:
    			 * Socket(String host,int port)
    			 * host:远端计算机的地址(IP)
    			 * port:远端计算机打开的端口
    			 * 调用该构造器实例化Socket的过程就是与远端
    			 * 计算机建立连接的过程。如果连接失败会抛出
    			 * 异常。
    			 * 通常与远端计算机进行连接时我们通过IP地址找
    			 * 到网络上要连接的计算机,通过端口与运行在该
    			 * 计算机上的服务端应用程序建立连接。
    			 */
    			System.out.println("正在连接服务端...");
    			/**
    			 * localhost表示本机地址
    			 * 
    			 * 查询本机的IP地址:
    			 * windows:
    			 * 点击桌面左下角的windows图标,然后输入
    			 * cmd回车。在弹出的控制台中输入:ipconfig
    			 * 
    			 * linux:
    			 * 在桌面鼠标右键,选择打开终端程序。
    			 * 然后输入:/sbin/ifconfig
    			 * 
    			 */
    			socket = new Socket("localhost",8088);
    			System.out.println("与服务端建立连接!");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public void start() {
    		try {
    			//首先读取服务端发送过来的消息的线程启动
    			ServerHandler handler = new ServerHandler();
    			Thread t = new Thread(handler);
    			t.start();
    			/*
    			 * Socket提供的方法:
    			 * OutputStream getOutputStream()
    			 * 返回一个字节输出流,通过这个流写出的字节会
    			 * 发送给远端计算机	 
    			 */
    			OutputStream out = socket.getOutputStream();//字节输出流
    			OutputStreamWriter osw = new OutputStreamWriter(out);//转换流,字符转换字节		
    			BufferedWriter bw = new BufferedWriter(osw);//块读写,加速流,可按行读写
    			PrintWriter pw = new PrintWriter(bw,true);//缓冲字符输出流
    			
    //			//通过socket获取输入流,读取服务端发送过来的消息
    //			InputStream in = socket.getInputStream();//字节输入流
    //			InputStreamReader isw = new InputStreamReader(in);//转换流,字节转换字符
    //			BufferedReader br = new BufferedReader(isw);//缓冲字符输入流,加速读写
    //			
    			Scanner scanner = new Scanner(System.in);
    			while(true) {
    				String line = scanner.nextLine();
    				pw.println(line);//写出
    				
    //				line = br.readLine();//读取
    //				System.out.println(line);
    			}
    			
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	public static void main(String[] args) {
    		Client client = new Client();
    		client.start();
    	}
    	private class ServerHandler implements Runnable{
    		@Override
    		public void run() {
    			/*
    			 * Socket提供的方法:
    			 * InputStream getInputStream()
    			 * 获取一个字节输入流,通过它可以读取远端计算机
    			 * 发送过来的字节
    			 */
    			try {
    				InputStream in = socket.getInputStream();//字节输入流
    				InputStreamReader isr = new InputStreamReader(in);//转换流,字节转换字符		
    				BufferedReader br = new BufferedReader(isr);//缓冲字符输入流,加速读写
    				
    				//循环读取服务端发送过来的每一行消息
    				String message;
    				while((message = br.readLine())!=null) {//读取
    					System.out.println(message);
    				}
    			} catch (IOException e) {
    				e.printStackTrace();
    			}finally {
    				try {
    					//当调用socket的close方法后,通过它获取的输入流与输出流就自动关闭了
    					socket.close();
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }
    
    package socket1;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.io.OutputStreamWriter;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Arrays;
    
    /**
     * 聊天室服务端
     * @author pc
     *
     */
    public class Server {
    	/*
    	 * java.net.ServerSocket
    	 * ServerSocket是运行在服务端的,它主要有两个作用:
    	 * 1:申请并打开服务端口,客户端就是通过这个端口与
    	 *   服务端建立连接的
    	 * 2:监听该端口,一旦一个客户端连接后会自动创建Socket
    	 *   实例,通过这个Socket便可以与刚连接上的客户端进行
    	 *   交互
    	 */
    	private ServerSocket server;
    	private PrintWriter[] allOut = {};
    	public Server() {
    		try {
    			System.out.println("正在启动服务端...");
    			/*
    			 * 如果申请的端口已经被其他程序占用时,这里
    			 * 的实例化会抛出异常:
    			 * java.net.BindException: address already in use
    			 */
    			server = new ServerSocket(8088);
    			System.out.println("启动服务端完毕!");
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	public void start() {
    		try {
    			/*
    			 * ServerSocket提供的方法:
    			 * Socket accept()
    			 * 该方法是一个阻塞方法,调用后程序"卡住",
    			 * 直到一个客户端建立连接,此时accept方法
    			 * 会立即返回一个Socket实例,通过这个Socket
    			 * 与客户端进行交互。
    			 */
    			while(true) {
    				System.out.println("等待客户端连接...");
    				Socket socket = server.accept();
    				System.out.println("一个客户端连接了!");
    				//启动一个线程处理该客户端交互
    				ClientHandler handler = new ClientHandler(socket);
    				Thread t = new Thread(handler);
    				t.start();
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    	public static void main(String[] args) {
    		Server server = new Server();
    		server.start();
    	}
    	/**
    	 * 该线程任务是负责与指定客户端交互的
    	 * @author pc
    	 */
    	private class ClientHandler implements Runnable{
    		private Socket socket;
    		private String host;
    		public ClientHandler(Socket socket) {
    			this.socket = socket;
    			host = socket.getInetAddress().getHostAddress();
    		} 
    		public void run() {
    			try {
    				/*
    				 * Socket提供的方法:
    				 * InputStream getInputStream()
    				 * 获取一个字节输入流,通过它可以读取远端计算机
    				 * 发送过来的字节
    				 */
    				InputStream in = socket.getInputStream();//字节输入流
    				InputStreamReader isr = new InputStreamReader(in);//转换流,字节转换字符		
    				BufferedReader br = new BufferedReader(isr);//缓冲字符输入流,加速读写
    				//通过socket获取输出流以便给当前客户端发送信息
    				OutputStream os = socket.getOutputStream();//字节输出流
    				OutputStreamWriter osw = new OutputStreamWriter(os);//转换流,字符转换字节	
    				BufferedWriter bw = new BufferedWriter(osw);//块读写,加速流,可按行读写
    				PrintWriter pw = new PrintWriter(bw,true);//缓冲字符输出流
    				//将当前客户端的输出流存入allOut中
    				//1:对allOut数组扩容
    				allOut = Arrays.copyOf(allOut, allOut.length+1);
    				//2:将输出流存入数组最后一个位置
    				allOut[allOut.length-1] = pw;
    				System.out.println(host+"上线了!当前在线人数:"+allOut.length);
    				
    				String message;
    				while((message = br.readLine())!=null) {//读取
    					System.out.println(host+"客户端说:"+message);
    					//将消息发送给所有客户端
    					for (int i = 0; i < allOut.length; i++) {
    						allOut[i].println(host+"说:"+message);
    					}
    				}
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }
    
    展开全文
  • Java写一个带界面聊天程序

    千次阅读 2020-06-22 20:20:18
    Java写一个带界面的网络聊天程序 基本实现思路: 首先得用Java Swing 编程写一个聊天界面,该界面需要包含以下元素 带滚轮的文本区域(显示聊天记录) 待输入的文本区域(输入聊天内容) 发送按钮 聊天界面主要...

    Java编程实践

    用Java写一个带界面的网络聊天程序

    基本实现思路: 首先得用Java Swing 编程写一个聊天界面,该界面需要包含以下元素

    1. 带滚轮的文本区域(显示聊天记录)
    2. 待输入的文本区域(输入聊天内容)
    3. 发送按钮

    聊天界面主要的就这三大组件

    实现步骤,用一个JScrollPane中间层容器来装一个文本框原子组件,该文本框设置为不可编辑,还要定义一个JPanel中间容器来装两个原子组件ButtonJTextField,就是我们的输入文本框和发送按钮,然后再给ButtonJTextField注册一个监听器,然后实现对应的响应函数,这里发生的是ActionListener,所以要实现的响应函数是actionPerformed

    super(ID);
    myID = ID;
    this.port = port;
    ta = new JTextArea();
    ta.setEditable(false);
    sp = new JScrollPane(ta);
    this.setSize(330,400);
    this.setResizable(false);
    try
    {
        UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    }
    catch(Exception e)
    {
        System.out.println("UI error");
    }
    this.getContentPane().add(sp,"Center");
    p = new JPanel();
    this.getContentPane().add(p,"South");
    send = new JButton("发送");
    tf = new JTextField(20);
    tf.requestFocus();
    p.add(tf);
    p.add(send);
    this.setDefaultCloseOperation(EXIT_ON_CLOSE);
    this.setVisible(true);
    send.addActionListener(this);
    tf.addActionListener(this);
    

    上面的代码就是实现图形界面的完整代码,看不懂的可以去看一下Java Swing编程

    实现网络聊天的另一个关键步骤就是建立网络连接

    网络连接中有客户端和服务器,我们需要分别实现这两个端

    客户端只要构建一个socket对象,然后向目标ip地址以及对应端口号发起连接就可以了

    try
    {
        mySocket=new Socket(IP,port); //目标IP地址和对应的端口号
        os = new PrintWriter(mySocket.getOutputStream()); 
        //获得输出流,以便将信息发送到目标地址
        is = new BufferedReader(new
                InputStreamReader(mySocket.getInputStream()));
        //输入流,将对方发送的信息读取出来
    }
    catch(Exception e)
    {
        System.out.println("Error:in Client Socket"+e);
    }
    

    服务器端就要定义一个ServerSocket对象,然后使用该对象的wait方法等待来自客户端的socket连接请求,得到对应的socket对象,后面就是跟客户端基本相同的操作

    if(isServer)
    {
        try
        {
            server=null;
            try
            {
                server=new ServerSocket(port); 
                //使用端口号port初始化一个ServerSocket对象
            }
            catch(Exception e)
            {
                System.out.println("can not listen to:"+e);
            }
            mySocket=null;
            try
            {
                mySocket=server.accept(); //等待来自客户端的socket连接请求
            }
            catch(Exception e)
            {
                System.out.println("Error:"+e);
            }
            is = new BufferedReader(new
                    InputStreamReader(mySocket.getInputStream()));
            os = new PrintWriter(mySocket.getOutputStream());
            //跟客户端一样,用来接收和发送信息
        }
        catch(Exception e)
        {
            System.out.println("Error:in server client socket"+e);
        }
    }
    

    现在我们要实现的就是将接收到的信息输出到聊天区域ta中去

    while(true)
    {
        try
        {
            line = is.readLine(); //获得输入流中的信息
            date = new Date(); //获得日期
            SimpleDateFormat formatter = new
                    SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //定义标准格式
            String currentTime = formatter.format(date); //将日期标准格式化
            s+=currentTime+""+remoteID+"说:\n"+line+"\n"; //将所有信息组合在一起
            ta.setText(s); //显示到ta文本框中
        }
        catch(Exception e)
        {
            System.out.println("Error:in receive remote information"+e);
        }
    }
    

    现在就是实现网络聊天程序的最后一步,也就是响应函数,当我们点击发送时,就要将我们输入到JTextField中的内容输出到socket对象去

    public void actionPerformed(ActionEvent e)
    {
    	date=new Date(); //获得日期
    	SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	String currentTime = formatter.format(date);
    	s+=currentTime+""+myID+"说:\n"+tf.getText()+"\n";
    	ta.setText(s); //将我们要发送的信息输出到ta文本框
    	os.println(tf.getText()); //将要发送的信息发送出去
    	os.flush(); //上面是发送到缓冲区,这一步确保信息被发送出去
    	tf.setText(""); //将我们的输入框置为空
    	tf.requestFocus();
    }
    

    完整代码:

    package net;
    
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    import javax.swing.*;
    
    public class ChatFrame extends JFrame implements ActionListener{
    
    	JTextField tf;
    	JTextArea ta;
    	JScrollPane sp;
    	JButton send;
    	JPanel p;
    	int port;
    	String s="";
    	String myID;
    	Date date;
    	ServerSocket server;
    	Socket mySocket;
    	BufferedReader is;
    	PrintWriter os;
    	String line;
    	
    	public ChatFrame(String ID, String remoteID, String IP, int port, boolean isServer)
    	{
    		super(ID);
    		myID = ID;
    		this.port = port;
    		ta = new JTextArea();
    		ta.setEditable(false);
    		sp = new JScrollPane(ta);
    		this.setSize(330,400);
    		this.setResizable(false);
    		try
    		{
    			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
    		}
    		catch(Exception e)
    		{
    			System.out.println("UI error");
    		}
    		this.getContentPane().add(sp,"Center");
    		p = new JPanel();
    		this.getContentPane().add(p,"South");
    		send = new JButton("发送");
    		tf = new JTextField(20);
    		tf.requestFocus();
    		p.add(tf);
    		p.add(send);
    		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
    		this.setVisible(true);
    		send.addActionListener(this);
    		tf.addActionListener(this);
    		if(isServer)
    		{
    			try
    			{
    				server=null;
    				try
    				{
    					server=new ServerSocket(port);
    				}
    				catch(Exception e)
    				{
    					System.out.println("can not listen to:"+e);
    				}
    				mySocket=null;
    				try
    				{
    					mySocket=server.accept();
    				}
    				catch(Exception e)
    				{
    					System.out.println("Error:"+e);
    				}
    				is = new BufferedReader(new
    						InputStreamReader(mySocket.getInputStream()));
    				os = new PrintWriter(mySocket.getOutputStream());
    			}
    			catch(Exception e)
    			{
    				System.out.println("Error:in server client socket"+e);
    			}
    		}
    		else
    		{
    			try
    			{
    				mySocket=new Socket(IP,port);
    				os = new PrintWriter(mySocket.getOutputStream());
    				is = new BufferedReader(new
    						InputStreamReader(mySocket.getInputStream()));
    			}
    			catch(Exception e)
    			{
    				System.out.println("Error:in Client Socket"+e);
    			}
    		}
    		while(true)
    		{
    			try
    			{
    				line = is.readLine();
    				date = new Date();
    				SimpleDateFormat formatter = new
    						SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    				String currentTime = formatter.format(date);
    				s+=currentTime+""+remoteID+"说:\n"+line+"\n";
    				ta.setText(s);
    			}
    			catch(Exception e)
    			{
    				System.out.println("Error:in receive remote information"+e);
    			}
    		}
    	}
    	public void actionPerformed(ActionEvent e)
    	{
    		date=new Date();
    		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    		String currentTime = formatter.format(date);
    		s+=currentTime+""+myID+"说:\n"+tf.getText()+"\n";
    		ta.setText(s);
    		os.println(tf.getText());
    		os.flush();
    		tf.setText("");
    		tf.requestFocus();
    	}
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		
    	}
    }
    

    我们可以定义两个对象来测试一下

    客户端

    package net;
    
    public class ChatClientFrame {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            ChatFrame client = new
                    ChatFrame("dog","cat","127.0.0.1",2009,false);
        }
    
    }
    

    服务器端

    package net;
    
    public class ChatServerFrame {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            ChatFrame cserver = new
                    ChatFrame("cat","dog","127.0.0.1",2009,true);
        }
    }
    

    补充一点:如果要在两个电脑上运行,需要给出服务器端的ip地址,可以使用ipconfig/all查看电脑的ip地址

    效果图

    在这里插入图片描述
    参考:

    清华大学Java教程

    展开全文
  • java的socket编写的聊天室,GUI的界面,可以私聊和群聊, 聊天信息保存为txt 源代码分享在后面!!! 下载链接: https://download.csdn.net/download/qq_52889967/20065491 教学视频: 运行结果: 保存结果:在D...

    登录界面的用户名和端口号不能重复!
    登录界面的用户名和端口号不能重复!
    登录界面的用户名和端口号不能重复!

    java的socket编写的聊天室,GUI的界面,可以私聊和群聊,
    聊天信息保存为txt

    有需要的可以自行下载,可以先观看教学视频再决定是否购买

    下载链接:
    https://download.csdn.net/download/qq_52889967/20065491

    教学视频:
    https://v.qq.com/x/page/u3258g37y8s.html

    java学生成绩管理系统(GUI界面):
    https://blog.csdn.net/qq_52889967/article/details/118581246

    运行结果:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    保存结果:在D盘
    “D:\私聊记录.txt”
    “D:\群聊记录.txt”

    部分源代码展示:
    在这里插入图片描述

    部分源代码如下:
    服务端:

    package myproject;
    
    import java.awt.Font;
    import java.awt.event.WindowEvent;
    import java.awt.event.WindowListener;
    import java.util.ArrayList;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JScrollPane;
    import javax.swing.JTextArea;
    
    public class UI {
    
    //	定义文本区
    	public static JTextArea text_area=new JTextArea();
    //	定义存储从客户端接受到的客户用户名、IP和端口号
    	public static ArrayList<String> all_userArrayList=new ArrayList<String>();
    	public static ArrayList<String> all_userArrayList_IP=new ArrayList<String>();
    	public static ArrayList<String> all_userArrayList_Port=new ArrayList<String>();
    	
    //	定义存储客户端IP的String
    	public static String IP =null;
    	
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		UI ui=new UI();
    		ui.init_1();
    	}
    	
    //	定义服务器界面
    	public void init_1() {
    //		定义窗口
    		JFrame jframe_1=new JFrame("服务器");
    		
    //		服务器关闭时,保存分割线(防止不同的txt保存混在一起)
    		jframe_1.addWindowListener(new WindowListener() {
                @Override
                public void windowOpened(WindowEvent e) {
     
                }
      
                @Override
                public void windowClosing(WindowEvent e) {
                    // 此处加入操作动作
    //            	保存群聊的分割线
                	Save.save_1("-----------分割线-----------", "-----------分割线-----------");
    //            	保存私聊的分割线
                	Save.save_2("-----------分割线-----------", "-----------分割线-----------",null);
                }
     
                @Override
                public void windowClosed(WindowEvent e) {
     
                }
     
                @Override
                public void windowIconified(WindowEvent e) {
                }
     
                @Override
                public void windowDeiconified(WindowEvent e) {
     
                }
     
                @Override
                public void windowActivated(WindowEvent e) {
     
                }
     
                @Override
                public void windowDeactivated(WindowEvent e) {
     
                }
            });
    		
    		
    //		设置窗口大小
    		jframe_1.setSize(400,400);
    //		窗口不能调整
    		jframe_1.setResizable(false);
    //		空布局
    		jframe_1.setLayout(null);
    //		退出则关闭程序
    		jframe_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    //		定义按钮
    		JButton jbutton_1=new JButton("开启服务器");
    //		设置按钮位置和大小
    		jbutton_1.setBounds(130,0,130,40);
    //		将按钮添加到窗口
    		jframe_1.add(jbutton_1);
    		
    //		设置文本区位置和大小
    		text_area.setBounds(0,50,385,310);
    //		设置文本区不可编辑
    		text_area.setEditable(false);
    //		定义滚动面板
    		JScrollPane sp_3=new JScrollPane(text_area);
    		sp_3.setLocation(0,50);
    		sp_3.setSize(385,310);
    //		定义字体
    		Font font=new Font("宋体",Font.BOLD,16);
    		sp_3.setFont(font);
    		jframe_1.add(sp_3);
    		
    //		注册开启服务器按钮的监听
    		EventListener e=new EventListener(jbutton_1);
    		jbutton_1.addActionListener(e);
    //		窗口居中
    		jframe_1.setLocationRelativeTo(null);
    //		显示窗口
    		jframe_1.setVisible(true);	
    		
    	}
    	
    }
    
    
    
    
    package myproject;
    
    import java.io.DataInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    import javax.swing.JOptionPane;
    
    // 开启服务器的server(多线程)
    // 每个客户端与服务器连接后,都会将自己的用户名和端口号发送过来(只接收客户端用户名、IP和端口号)
    public class Server_1 extends Thread {
    	
    	public static ServerSocket server_1=null;
    	public static Socket socket_1=null;
    //	定义输入流,用于接收客户端发送的消息
    	public static InputStream input_1=null;
    	public static DataInputStream dinput_1=null;
    //	定义字符串用于暂时存储信息
    	String s=null;
    	
    	//启动线程的方法
    	public void run() {
    //		死循环,当有客户端连接时,循环等待下一个客户端
    		while(true) {
    //			异常捕获
    			try {
    //				开放2021端口
    				server_1=new ServerSocket(2021);
    //				调用获取socket方法,等待连接
    				socket_1=server_1.accept();
    //				获取输入流
    				input_1=socket_1.getInputStream();
    				dinput_1=new DataInputStream(input_1);
    				
    //				读取用户名并添加
    				s =dinput_1.readUTF();
    				UI.all_userArrayList.add(s);
    				
    //				读取IP
    				UI.IP=dinput_1.readUTF();
    //				处理接收到的IP,接收的IP格式为主机名/ip,我们只需要后面的部分(通过正则表达式匹配数据)
    				String str[]=UI.IP.split("/");
    //				str[1]为我们需要的数据
    				UI.IP=str[1];
    				UI.all_userArrayList_IP.add(UI.IP);
    //				System.out.println("IP:"+UI.all_userArrayList_IP);
    				
    //				读取端口号并添加
    				UI.all_userArrayList_Port.add(dinput_1.readUTF());
    //				System.out.println("端口号:"+UI.all_userArrayList_Port);
    //				提示用户上线
    				UI.text_area.append("用户->"+s+" 上线了!\n");
    			}catch (Exception e) {
    				System.out.println(e);
    				JOptionPane.showMessageDialog(null, 
    						"Server_1服务器异常!!!","错误提示",JOptionPane.WARNING_MESSAGE);
    				break;
    			}finally {
    				if(dinput_1!=null) {
    					try {
    						dinput_1.close();
    					} catch (IOException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}if(input_1!=null) {
    					try {
    						input_1.close();
    					} catch (IOException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    				if(socket_1!=null) {
    					try {
    						socket_1.close();
    					} catch (IOException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}if(server_1!=null) {
    						try {
    							server_1.close();
    						} catch (IOException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						}
    					}
    				}
    			}
    			
    		}	
    	}
    }
    
    
    
    
    package myproject;
    
    import java.io.DataOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    import javax.swing.JOptionPane;
    
    //只用于将当前在线人数传递到客户端
    public class Server_3 extends Thread {
    	
    	public static ServerSocket server_1=null;
    	public static Socket socket_1=null;
    //	定义输出流
    	public static OutputStream output_1=null;
    	public static DataOutputStream doutput_1=null;
    	
    	//启动线程的方法
    	public void run() {
    //		死循环,当有客户端连接时,循环等待下一个客户端
    		while(true) {
    //			异常捕获
    			try {
    //				开放2023端口
    				server_1=new ServerSocket(2023);
    //				调用获取socket方法,等待连接
    				socket_1=server_1.accept();
    //				获取输出流
    				output_1=socket_1.getOutputStream();
    				doutput_1=new DataOutputStream(output_1);
    //				发送用户数量
    				doutput_1.writeUTF(""+UI.all_userArrayList.size());
    //				发送用户名
    				for(int i=0;i<UI.all_userArrayList.size();i++) {
    					doutput_1.writeUTF(UI.all_userArrayList.get(i));
    //					System.out.println(UI.all_userArrayList);
    				}
    //				System.out.println(UI.all_userArrayList.size());
    //				System.out.println("服务端:"+UI.all_userArrayList);
    			}catch (Exception e) {
    				System.out.println(e);
    				JOptionPane.showMessageDialog(null, 
    						"Server_3服务器异常!!!","错误提示",JOptionPane.WARNING_MESSAGE);
    				break;
    			}finally {
    				if(doutput_1!=null) {
    					try {
    						doutput_1.close();
    					} catch (IOException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}if(output_1!=null) {
    					try {
    						output_1.close();
    					} catch (IOException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}
    				}
    				if(socket_1!=null) {
    					try {
    						socket_1.close();
    					} catch (IOException e) {
    						// TODO Auto-generated catch block
    						e.printStackTrace();
    					}if(server_1!=null) {
    						try {
    							server_1.close();
    						} catch (IOException e) {
    							// TODO Auto-generated catch block
    							e.printStackTrace();
    						}
    					}
    				}
    			}
    			
    		}	
    	}
    }
    
    
    
    
    

    客户端:

    package myproject;
    
    import java.awt.Color;
    import java.awt.FlowLayout;
    import java.awt.Font;
    import java.util.ArrayList;
    
    import javax.swing.JButton;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JPanel;
    import javax.swing.JScrollPane;
    import javax.swing.JTextArea;
    import javax.swing.JTextField;
    
    public class UI {
    //	窗口
    	public static JFrame jframe_1 = new JFrame("聊天小程序");
    //	定义容器
    	public static JFrame jframe_2=new JFrame("登录");
    //	设置面板
    	public static JPanel p_1 = new JPanel(null);
    	public static JPanel p_2 = new JPanel(null);
    	public static JPanel p_3 = new JPanel(null);
    //	按钮
    	public static JButton jbutton_1 = new JButton("发送");
    //	文本框
    	public static JTextField text_1 = new JTextField();
    //	文本区
    	public static JTextArea text_area_1 = new JTextArea();
    	public static JTextArea text_area_2 = new JTextArea();
    //	注册用户名
    	public static String user;
    //	定义从客户端接受到的客户用户名,用于私聊展示
    	public static ArrayList<String> all_userArrayList=new ArrayList<String>();
    	
    	
    	public static void main(String[] args) {
    		UI ui = new UI();
    		ui.init();
    	}
    	
    //	登录界面
    	public void init() {
    //		流式布局
    		jframe_2.setLayout(new FlowLayout());
    //		设置窗口大小
    		jframe_2.setSize(250,150);
    //		居中显示
    		jframe_2.setLocationRelativeTo(null);
    //		退出后程序结束
    		jframe_2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    //		定义标签
    		JLabel l_1=new JLabel("用户名: ");
    		JLabel l_2=new JLabel("服务器IP: ");
    //		定义字体(宋体,加粗)
    		Font font_1=new Font("宋体",Font.BOLD,20);
    		l_1.setFont(font_1);
    		l_2.setFont(font_1);
    //		定义文本框
    		JTextField text_2=new JTextField(10);
    		JTextField text_3=new JTextField(10);
    		text_2.setText("192.168.1.3");
    //		定义按钮
    		JButton jbutton_2=new JButton("注册并登录");
    		jframe_2.add(l_2);
    		jframe_2.add(text_2);
    		jframe_2.add(l_1);
    		jframe_2.add(text_3);
    		jframe_2.add(jbutton_2);
    //		注册监听
    		EventListener_1 e_2=new EventListener_1(text_2,text_3);
    		jbutton_2.addActionListener(e_2);
    //		显示窗口
    		jframe_2.setVisible(true);
    	}
    	
    //	主界面
    	public static void init_1() {
    //		空布局
    		jframe_1.setLayout(null);;
    //		窗口大小
    		jframe_1.setSize(600,400);
    //		窗口居中
    		jframe_1.setLocationRelativeTo(null);
    //		窗口不能调整
    		jframe_1.setResizable(false);
    //		退出后程序结束
    		jframe_1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    //		设置面板
    		p_1.setLocation(0,0);
    		p_2.setLocation(320,0);
    		p_3.setLocation(0,300);
    		p_1.setSize(280,280);
    		p_2.setSize(280,400);
    		p_3.setSize(280,100);
    		p_2.setSize(280,400);
    		p_1.setBackground(Color.LIGHT_GRAY);
    		p_2.setBackground(Color.LIGHT_GRAY);
    		p_3.setBackground(Color.LIGHT_GRAY);
    		jframe_1.add(p_1);
    		jframe_1.add(p_2);
    		jframe_1.add(p_3);
    //		设置按钮和文本框
    		text_1.setBounds(0,0,180,30);
    		jbutton_1.setBounds(220,0,60,30);
    		p_3.add(text_1);
    		p_3.add(jbutton_1);
    //		定义服务器开启或关闭按钮
    		JButton jbutton_2= new JButton("连接服务器");
    		JButton jbutton_3= new JButton("查看在线人数");
    		jbutton_2.setBounds(0,0,100,40);
    		jbutton_3.setBounds(155,0,110,40);
    //		设置文本区
    		text_area_1.setBounds(0,0,280,280);
    		text_area_2.setBounds(0,50,280,280);
    //		设置文本区不可编辑
    		text_area_1.setEditable(false);
    		text_area_2.setEditable(false);
    //		定义字体(宋体,加粗)
    		Font font_1=new Font("宋体",Font.BOLD,16);
    		//将text_area_1作为可滚动面板sp的显示区域
    		JScrollPane sp_1=new JScrollPane(text_area_1);
    		JScrollPane sp_2=new JScrollPane(text_area_2);
    		sp_1.setLocation(0,0);
    		sp_2.setLocation(0,50);
    		sp_1.setSize(280,280);
    		sp_2.setSize(280,280);
    //		设置文本区字体
    		text_area_1.setFont(font_1);
    		text_area_2.setFont(font_1);
    		p_1.add(sp_1);
    		p_2.add(sp_2);
    //		将服务器开启和查看在线人数按钮添加到p_2
    		p_2.add(jbutton_2);
    		p_2.add(jbutton_3);
    		
    		jframe_1.setVisible(true);
    		
    //		注册 发送按钮 监听
    		EventListener e_1 = new EventListener(text_area_1,text_1);
    		jbutton_1.addActionListener(e_1);
    //		注册连接服务器按钮的监听
    		EventListener_2 e_2=new EventListener_2(jbutton_2);
    		jbutton_2.addActionListener(e_2);
    		
    	}
    	
    	
    }
    
    
    展开全文
  • //当县消息时刷新ListView中的显示 msgListView.setSelection(msgList.size());//将ListView定位到最后一行 inputText.setText(""); } } }); } private void initMsg() { Msg msg1=new Msg("Hi Peter", Msg.TYPE_...
  • 今天没什么事做,基于udp协议,写了一个非常简单的聊天程序。现在的工作,很少用到socket,也算是对java网络编程方面的一个简单回忆。先看一下效果:实现的效果可以说是非常非常简单,但还是可以简单的看到一个...
  • javaUI设计聊天程序

    2011-07-23 21:52:34
    java聊天程序UI界面 很好的用户体验性 模拟QQ
  • java简单聊天程序实验报告及代码 一、实验内容实验题目:1、使用URL访问用户指定网站,获取该网页的HTML代码显示给用户,并能保存至指定文件中。2、使用ServerSockt,Socket对象实现两个用户之间的端到端聊天。要求:...
  • 主要运用swing和serversocket、socket写的仿QQ聊天室,深入学习并运用了swing相关组件和socket通信
  • CS模式聊天程序代码,实现语言为Java,前端UI界面Java Swing框架实现,服务端与客户端通信采用Java NIO,自定义按分隔符\n读取消息的消息读取格式解决TCP粘包拆包问题。
  • 微信小程序 UI界面

    2020-03-19 19:41:06
    组件通用属性: id class style hidden data-:用法,,获取:e.currentTarget.dataset.test bind/catch* view,input,button input属性: value,password,placeholder, disabled,maxlength,bindchange ...
  • java 聊天室WeChat

    2021-03-14 12:09:44
    javafx UI界面更新 类似于android在UI界面只能在UI线程中进行更改,在javafx中也是如此。不过之前Android知道其异步方式的实现 在javafx中查阅资料后总结下其更改界面的方法 Platform.runLater(new Task() { @...
  • 首先,我们应当了解,像运行在两台电脑或者手机终端这样的程序一般是没有办法直接相互发送信息的,一般是需要第三方服务器提供服务,就像QQ或者微信那样,来为这两个终端程序提供转发服务, 因此,我们设计的程序包括...
  • Socket实现的C/S模式半UI多人聊天程序Java语言描述
  • JAVA 仿QQ聊天程序(附源码)

    万次阅读 多人点赞 2020-07-04 11:48:22
    第一次通过java编写完了一个模拟QQ的C/S软件【开心,但是还是感觉用C#写C/S要舒服的多【哭泣】】,项目是通过三层架构编写,由于对JavaJDBC不是很熟悉,所有数据交换写的是真的垃圾啊,软件还是存在一些问题的,比如...
  • 此代码通过Java编程实现了基于Socket的网络通信,通信时两个界面,分别是服务端、客户端,可发消息,界面显示,默认是本机的IP地址,代码可用JCreator直接打开,文件是.java形式。
  • 具有多选项卡UI(使用JavaFX构建)的聊天应用程序。 通过TCP / IP进行通信的服务器-客户端模型。 为JVM和Arduino微控制器编写的服务器/后端代码库(测试平台为ESP32s开发板)。 文件传输功能。
  • 为了实现简单的聊天程序,本文使用了JFrame界面框架,IO输入、输出流,以及相应的socket和监听事件。 首先编写一个具有通信功能的简单界面程序,具体如下: package chart; import javax.swing.*; import java....
  • 编写简单聊天窗口

    千次阅读 2021-03-12 22:07:37
    聊天窗口import java.awt.BorderLayout;import java.awt.EventQueue;import javax.swing.JFrame;import javax.swing.JPanel;import javax.swing.border.EmptyBorder;import javax.swing.text.JTextComponent;import ...
  • Java程序之客户端的UI实现以及客户端与服务器的UI交互(山寨QQ进行中......) 一、前言 通过前面的学习,我们已经能够自己创建客户端,不需要依赖系统自带的telnet客户端,但是,我们只能利用控制台和后台服务器...
  • 这是我们这学期期末网络编程的作业,老师要求我们做的课程作业。...UI界面背景图片是我用光影魔术手ps的,感觉还可以凑合着看。 压缩包里面个可运行的jar格式的文件,你可以运行试试。我编完后,没有发现BUG
  • Java基础聊天室基于Swing socket通信

    千次阅读 2019-03-19 23:51:24
    Java基础聊天室socket serve基于Swing使用java swing包进行ui设计,通过socket通信,实现服务器和客户端的连接互发消息并通过JTextArea显示出来。话不多说 直接贴代码 新人第一次发帖有点紧张,该项目为java课设,小...
  • JavaFX聊天界面

    2017-07-13 15:34:28
    oim是已经实现聊天功能的完整程序兴趣的朋友可以去开源中国的git库下载,地址:https://git.oschina.net/onlysoftware/oim-fx,而这里就仅仅只是界面的源码,有些朋友可能只对界面感兴趣,所有我把界面提取出来...
  • 参照附录 1,了解 Socket 通信的原理,在此基础上编写一个聊天程序。 原理:用NIO(非阻塞式IO)写的服务端客户端,外加jwt写的界面。 一共三个java文件.(先运行服务端代码、再运行客户端代码) GroupChat...
  • 为什么使用Java Swing来做UI界面呢?虽然我们大家都知道,Java Swing现在已经过时了,并且Java的优势不在于图形界面,但我的需求并不需要漂亮美观的界面,并且Java语言实现C端界面的首选就是Java Swing了,只不过我...
  • JAVA利用多线程和Socket制作GUI界面的在线聊天

    千次阅读 多人点赞 2020-06-11 17:57:17
    最近刚好是期末,碰上Java实训,借此将之前写的在线聊天室搬出来,加上GUI(Swing),当成实训作品,记录一下这次实训的结果。 本篇文章主要叙述的是 ① 在线聊天室的代码结构; ② 将java文件打包成jar,再打包成...
  • TCP聊天室实现了私聊、群聊和清屏的功能,简陋的UI界面,一个服务器端,支持多个客户端之间的通信。 项目代码:https://pan.baidu.com/s/17iegRam4KnWvcWHw3mvpxg 提取码:e8gx 服务器端: 可以开多个客户端...
  • 1、程序演示: 2、代码: package test07; import java.awt.Color; import java.awt.Dimension; import java.awt.FlowLayout; import java.awt.Window; import java.awt.event.ActionEvent; import java.awt....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,095
精华内容 3,638
关键字:

java聊天程序有ui界面

java 订阅