导航:首页 > 编程语言 > java聊天系统

java聊天系统

 发布时间：2025-07-09 10:14:40

❶ 用java怎么开发聊天软件

做界面的话可以有b/s,c/s结构两种。b/s就是浏览器/服务器的方式，用web的方式进行聊天。c/s就是client/server的方式，桌面程序样子的，一般都是这个方式。

java做桌面界面的一般有awt/swing/swt三种类库。最流行的是swing,老一点的是awt，如果你想做的界面和操作系统的界面一直（感官一样），那就用swt,swt是eclipse基金会为了开发eclipse而开发的java利用操作系统原生窗口的一组api，更快速方便。

如果你只是完成任务，就看看swing吧，很好的java图形库。另外，java基础知识也要很好才行。要能够语音视频的话，还要学jmf，这个比较难一点。

针对局域网的，那就另加一些socket编程的知识了

❷ 急需一个用java 语言写的聊天程序

客户端:
package chatroom;
import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.io.*;
import javax.swing.*;
public class client extends JFrame implements ActionListener,Runnable{
JPanel conn,text,send;
JLabel name,sendto;
JComboBox list;
JButton con,snd,clear;
JTextArea talk;
JTextField who,say;
jscrollPane jsp;
Socket client;
InputStream is;
OutputStream os;
PrintStream ps;
BufferedReader br;
String receive,yousay;
Thread th;
DataInputStream dis;
Double tof;

client()
{
super("聊天室客户端");
this.setSize(800,600);
this.setResizable(false);
conn=new JPanel();
text=new JPanel();
send=new JPanel();
this.getContentPane().add(conn);
conn.setBounds(0, 0, this.getWidth(),50);
name=new JLabel("姓名:");
who=new JTextField();
con=new JButton("连接");
conn.setLayout(null);
conn.add(name);
name.setBounds(30, 10, 50, 25);
conn.add(who);
who.setBounds(80, 10, 150, 25);
conn.add(con);
con.setBounds(250,10, 60, 25);

this.getContentPane().add(text);
text.setBounds(0,50,this.getWidth(),450);
text.setLayout(new BorderLayout());
jsp=new JScrollPane();
talk=new JTextArea();
jsp.getViewport().setView(talk);
text.add(jsp,"Center");
talk.setLineWrap(true);

this.getContentPane().add(send);
send.setLayout(null);
send.setBounds(0, 480, this.getWidth(), 150);
sendto=new JLabel("发送到:");
snd=new JButton("发送");
list=new JComboBox();
say=new JTextField();
clear=new JButton("清空");
send.add(sendto);
sendto.setBounds(30, 525, 50, 25);
send.add(list);
list.setBounds(100, 525, 75, 25);
send.add(say);
say.setEditable(true);
say.setBounds(200, 525, 300, 25);
send.add(snd);
snd.setBounds(520, 525, 100, 25);
send.add(clear);
clear.setBounds(650, 525, 100, 25);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
con.addActionListener(this);
snd.addActionListener(this);
}

public void actionPerformed(ActionEvent ae) {
if (ae.getActionCommand().equals("连接"))
{
try
{
client=new Socket(InetAddress.getLocalHost(),55555);
talk.append("连接成功...\n");
con.setText("断开");
is=client.getInputStream();
os=client.getOutputStream();
th=new Thread(this);
String id=who.getText();
byte b[]=id.getBytes();
DataOutputStream dos=new DataOutputStream(os);
int len=b.length;
dos.writeInt(len);
dos.write(b);
th.start();

}catch(Exception e){talk.append("连接失败\n"+e.toString()+"0000");}
}
else if(ae.getSource()==snd)
{
if(list.getSelectedItem().toString()=="所有人")
{
yousay="@open"+say.getText();
byte b[]=yousay.getBytes();
DataOutputStream dos=new DataOutputStream(os);
try{
int len=b.length;
dos.writeInt(len);
dos.write(b);
}catch(Exception e)
{
System.out.print(e.toString()+"1111");
}
}
else
{
yousay="@whisper"+say.getText();
byte b[]=yousay.getBytes();
byte w[]=list.getSelectedItem().toString().getBytes();
DataOutputStream dos=new DataOutputStream(os);
try{
int len=b.length;
int wlen=w.length;
dos.writeInt(len); //内容
dos.write(b);
dos.writeInt(wlen); //发送对象
dos.write(w);
}catch(Exception e)
{
System.out.print(e.toString()+"AAAA");
}
}
}
else if(ae.getActionCommand().equals("断开"))
{
try
{
client.close();
talk.append("连接已断开\n");
con.setText("连接");
}catch(Exception e){System.out.println(e.toString()+"2222");}
}
}
public void run()
{

while(true)
{
try
{
dis=new DataInputStream(is);
tof=dis.readDouble();
if(tof==1.1)
{
dis=new DataInputStream(is);
int number;
list.removeAllItems();
list.addItem("所有人");
number=dis.readInt();
for(int i=0;i<number;i++)
{
int len=dis.readInt();
byte b[]=new byte[len];
dis.read(b);
String name=new String(b);
list.addItem(name);
}

}
else if(tof==2.2)
{
try
{
dis=new DataInputStream(is);
int len=dis.readInt();
byte b[]=new byte[len];
dis.read(b);
receive=new String(b);
talk.append(receive+"\n");
}catch(Exception e){JOptionPane.showMessageDialog(this, "连接已断开","消息",JOptionPane.INFORMATION_MESSAGE);break;}
}
}catch(Exception e){JOptionPane.showMessageDialog(this, "连接已断开","消息",JOptionPane.INFORMATION_MESSAGE);break;}
}
}

public static void main(String[] args) {
client cl=new client();

}

}
服务端:
package chatroom;
import java.awt.*;
import javax.swing.*;
import java.net.*;
import java.util.Vector;
import java.io.*;
public class server extends JFrame implements Runnable{
JPanel jp1;
JTextArea jta;
JScrollPane jsp;
Socket socket=null;
ServerSocket server;
InputStream is;
OutputStream os;
static int i=0,login;
int no;
static String s="";
Thread sr;
Thread th[]=new Thread[20];
static Vector ol=new Vector();
static public byte w[]=null;
static String from=""; //人名
static String to="";
static String fromtext=""; //内容
static String totext="";
server()
{
super("聊天室服务端");
this.getContentPane().setLayout(new GridLayout(1,1));
this.setSize(400,300);
jp1=new JPanel();
jta=new JTextArea();
jsp=new JScrollPane();
this.getContentPane().add(jp1);
jp1.setLayout(new GridLayout(1,1));
jsp.getViewport().setView(jta);
jp1.add(jsp);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);

}
public static void main(String[] args) {
server sr=new server();
sr.sr=new Thread(sr);
sr.sr.start();
sendtoall sta=new sendtoall();
returnfrom rf=new returnfrom(sr);
returnto rt=new returnto(sr);
sta.start();
rf.start();
rt.start();

}
public void run()
{
try
{
server=new ServerSocket(55555);
while(true)
{
socket=server.accept();
is=socket.getInputStream();
DataInputStream dis=new DataInputStream(is);
int len=dis.readInt();
byte b[]=new byte[len];
dis.read(b);
String id=new String(b);
record v=new record(id,socket);
ol.addElement(v);
for (int i=0;i<ol.size();i++)
{
if (ol.elementAt(i).equals(v))
{
no=i;
}
}
login=1;
s=id+"已来到聊天室!";
th[no]=new Thread(new receive(this,no));
th[no].start();
}
}catch(Exception e){System.out.println(e.toString()+"aaaa");}

}
}
class receive implements Runnable
{
InputStream is;
OutputStream os;
server sr;
Socket sk;
int i;
String name;
String ip;
receive(server sr,int i)
{
this.sr=sr;
this.i=i;
sk=((record)sr.ol.elementAt(i)).ip;
name=((record)sr.ol.elementAt(i)).name;
ip=((record)sr.ol.elementAt(i)).ip.getInetAddress().toString();
}
public void run()
{
while(true)
{
try
{
is=sk.getInputStream();
DataInputStream dis=new DataInputStream(is);
int len=dis.readInt();
byte b[]=new byte[len];
dis.read(b);
String abc=new String(b);
sr.jta.append(abc);
if(abc.substring(0,5).equals("@open"))
{

server.s=name+"["+ip.substring(1, ip.length())+"]"+"说:"+abc.substring(5,abc.length());
sr.jta.append(server.s+"\n");
}
else if(abc.substring(0,8).equals("@whisper"))
{
int wlen=dis.readInt();
sr.w=new byte[wlen];
dis.read(sr.w);
server.to=new String(sr.w);
server.from=((record)sr.ol.elementAt(i)).name;
String ip=((record)sr.ol.elementAt(i)).ip.getInetAddress().toString();
// server.s=server.from+"对"+server.to+"["+ip.substring(1, ip.length())+"]"+"悄悄地说:"+abc.substring(8,abc.length());
server.fromtext="你对"+server.to+"["+ip.substring(1, ip.length())+"]"+"悄悄地说:"+abc.substring(8,abc.length());
server.totext=server.from+"["+ip.substring(1, ip.length())+"]"+"对你悄悄地说:"+abc.substring(8,abc.length());
sr.jta.append(server.s+"\n");
}
}catch(Exception e)
{
try
{
DataOutputStream dos=new DataOutputStream(os);
server.ol.removeElementAt(i);
server.s=name+"已离开聊天室.";
server.login=1;
break;
}catch(Exception f){}
}
}
}
}
class sendtoall extends Thread
{
int len,number;
byte b[];
server sr;
Socket st;
OutputStream os;
DataOutputStream dos;
public void run()
{
while(true)
{
try
{
if(server.login==1)
{
number=0;
number=server.ol.size();
dos=new DataOutputStream(os);
for(int i=0;i<server.ol.size();i++)
{
st=((record)sr.ol.elementAt(i)).ip;
os=st.getOutputStream();
dos=new DataOutputStream(os);
dos.writeDouble(1.1);
dos.writeInt(number);
for (int j=0;j<number;j++)
{
String name=((record)sr.ol.elementAt(j)).name;
byte b[]=name.getBytes();
int len=b.length;
dos.writeInt(len);
dos.write(b);
}
}
server.login=0;

}
else if(!server.s.equals("")&&sr.ol.size()>0)
{
b=server.s.getBytes(); //String类型中 汉字占一个字节,但是byte类型中,汉字占两个字节
len=b.length;
//len=server.s.length();
//b=new byte[len];
//b=server.s.getBytes();
for(int i=0;i<server.ol.size();i++)
{
st=((record)sr.ol.elementAt(i)).ip;
os=st.getOutputStream();
DataOutputStream dos=new DataOutputStream(os);
dos.writeDouble(2.2);
dos.writeInt(len);
dos.write(b);
}
server.s="";

}

}catch(Exception e){System.out.println(e.toString()+"sdasd");}
}
}
}
class returnfrom extends Thread
{
int len,wlen;
byte b[];
byte w[];
server sr;
Socket st;
OutputStream os;
DataOutputStream dos;
//String from="",to="";
returnfrom(server sr)
{
this.sr=sr;
}
public void run()
{
while(true)
{
if(!server.fromtext.equals(""))
{
b=server.fromtext.getBytes();
len=b.length;
sr.jta.append(sr.fromtext);
try
{
for(int i=0;i<server.ol.size();i++)
{
if(((record)sr.ol.elementAt(i)).name.equals(server.from))
{
st=((record)sr.ol.elementAt(i)).ip;
os=st.getOutputStream();
DataOutputStream dos=new DataOutputStream(os);
dos.writeDouble(2.2);
dos.writeInt(len);
dos.write(b);
}
}
}catch(Exception e){System.out.println(e.toString()+"wwww");}
server.fromtext="";
server.from="";
}
}

}
}

class returnto extends Thread
{
int len,wlen;
byte b[];
byte w[];
server sr;
Socket st;
OutputStream os;
DataOutputStream dos;
//String from="",to="";
returnto (server sr)
{
this.sr=sr;
}
public void run()
{
while(true)
{
if(!server.totext.equals(""))
{
w=server.totext.getBytes();
wlen=w.length;
try
{
for(int i=0;i<server.ol.size();i++)
{
if(((record)sr.ol.elementAt(i)).name.equals(server.to))
{
st=((record)sr.ol.elementAt(i)).ip;
os=st.getOutputStream();
DataOutputStream dos=new DataOutputStream(os);
dos.writeDouble(2.2);
dos.writeInt(wlen);
dos.write(w);
}
}
}catch(Exception e){System.out.println(e.toString()+"wwww");}
server.totext="";
server.to="";
}
}
}
}

class record
{
String name;
Socket ip;
record(String id,Socket socket)
{
name=id;
ip=socket;
}
}

以前学习java时写的,是个在线聊天室只有群聊,私聊,上下线提示,搞不好里面还有错误- -其他功能自己看着加吧,你要的功能实在是很好很强大.

❸ 怎么实现java一对一聊天室可以介绍一下吗

要实现 Java 的一对一聊天室，可以使用 Socket 编程实现基于 TCP 协议的通信。

以下是一些大致的步骤：

❹ java实现聊天室是怎么做到的

Java 实现聊天室可以分为以下几个步骤：
建立服务器端
首先需要建立一个服务器端，负责接收客户端的连接请求并处理客户端发送过来的消息。
建立客户端
然后需要建立册陆客户端，客户端通过正姿毕网络连接到服务器端，并向服务器端发送消息。
实现通信协议
为了实现聊天室功能，需要定义一个通信协议，规定客户端和服务器端之间的通信格式，例如消息的头部和内容等。
实现多线程处理
聊天室通常会有多个用户同时在线，因此需要使用多线程举芹来处理多个客户端的连接请求和消息传递。
实现GUI界面（可选）
为了方便用户使用，可以实现一个GUI界面，让用户可以方便地发送和接收消息。
以下是一个简单的 Java 聊天室的代码示例：
java
Copy code
// 服务器端代码
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8888);
while (true) {
Socket socket = serverSocket.accept();
new Thread(new ServerThread(socket)).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ServerThread implements Runnable {
private Socket socket;
private BufferedReader reader;
private PrintWriter writer;
public ServerThread(Socket socket) {
this.socket = socket;
try {
reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
writer = new PrintWriter(socket.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
public void run() {
try {
String msg;
while ((msg = reader.readLine()) != null) {
// 处理客户端发送过来的消息
System.out.println("接收到消息：" + msg);
// 将消息发送给所有客户端
for (Socket s : ServerThreadList.getList()) {
if (s != socket) {
PrintWriter w = new PrintWriter(s.getOutputStream());
w.println(msg);
w.flush();
}
}
}
// 关闭连接
socket.close();
ServerThreadList.removeThread(this);
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ServerThreadList {
private static List
list = new ArrayList<>();
public static void addThread(ServerThread thread) {
list.add(thread);
}
public static void removeThread(ServerThread thread) {
list.remove(thread);
}
public static List
getList() {
return list;
}
}
// 客户端代码
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 8888);
new Thread(new ClientThread(socket)).start();
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
PrintWriter writer = new PrintWriter(socket.getOutputStream());
while (true) {
String msg = reader.readLine();
writer.println(msg);
writer.flush();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ClientThread implements Runnable {
private Socket socket;
private BufferedReader reader;
public ClientThread(Socket socket) {
this.socket = socket;
try {
reader

❺ 求教编程做出一个两人多人之间简单的聊天程序

制作人: CK.y ，汇成建筑企业管理Q：610089144
仅供参考，大家要学会自己制作，很有成就感的啊！！ 用 Java 作后台，开发一个 C / S 架构的多人聊天程序。首先，设计用户界面。

一、界面设计

界面的元件全部使用 Flash CS3 自带的组件：
首先，放入 TextInput 组件（实例名 input_txt），作为用户输入；
再放入 Button 组件（实例名 submit_btn），用于提交输入的信息；
最后放入 TextArea 组件（实例名 output_txt），显示聊天信息。

二、组件参数初始化
由于客户端代码不是很多，我们这次就写在动作帧上：
// ************ 组件参数初始化 ************
submit_btn.label = "发送消息";
output_txt.editable = false;

// 设置各组件中字体的大小
input_txt.setStyle("textFormat", new TextFormat(null, 15));
output_txt.setStyle("textFormat", new TextFormat(null, 15));
submit_btn.setStyle("textFormat", new TextFormat(null, 15, null, true));

// 当按下回车或点击 submit_btn 按钮后调用事件处理函数
submit_btn.addEventListener(MouseEvent.CLICK, sendMessage);
addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);

// 事件处理函数
function onKeyDown(evt:KeyboardEvent):void {
if (evt.keyCode == Keyboard.ENTER) {
sendMessage(null);
}
}

function sendMessage(evt:Event):void {
// 测试：将 input_txt 的内容输出到 output_txt 中
output_txt.appendText(input_txt.text + "\n");

// 清空 input_txt，并设置焦点到 input_txt
input_txt.text = "";
stage.focus = input_txt;
}

三、编写客户端 Socket
1. 首先，Socket 连接非常简单：
var socket:Socket = new Socket();
socket.connect("127.0.0.1", 8888);
其中 connect() 方法中的两个参数分别为是主机名和端口号（端口号尽量用 1024 以上）。好了，这样就连接上了。接下来是读写的问题。

2. 向服务器端写入字符串：我们在 sendMessage() 方法中进行写入操作，注意写出的字串必需以回车（\n）结束：
function sendMessage(evt:Event):void {
var bytes:ByteArray = new ByteArray();
bytes.writeUTFBytes(input_txt.text + "\n");
socket.writeBytes(bytes);
socket.flush();

// 清空 input_txt，并设置焦点到 input_txt
input_txt.text = "";
stage.focus = input_txt;
}

3. 读取服务器端写回的字符串：最后将服务器发回的字符串输出到 output_txt 文本域中：
// 当客户端 socket 收到数据后会调用 readMessage() 函数
socket.addEventListener(ProgressEvent.SOCKET_DATA, readMessage);

function readMessage(evt:ProgressEvent):void {
output_txt.appendText(socket.readUTF() + "\n");
}

四、Flash 客户端全部脚本
// ************ 组件参数初始化 ************
submit_btn.label = "发送消息";
output_txt.editable = false;

input_txt.setStyle("textFormat", new TextFormat(null, 15));
output_txt.setStyle("textFormat", new TextFormat(null, 15));
submit_btn.setStyle("textFormat", new TextFormat(null, 15, null, true));

submit_btn.addEventListener(MouseEvent.CLICK, sendMessage);
addEventListener(KeyboardEvent.KEY_DOWN, onKeyDown);

function onKeyDown(evt:KeyboardEvent):void {
if (evt.keyCode == Keyboard.ENTER) {
sendMessage(null);
}
}

function sendMessage(evt:Event):void {
var bytes:ByteArray = new ByteArray();
bytes.writeUTFBytes(input_txt.text + "\n");
socket.writeBytes(bytes);
socket.flush();

input_txt.text = "";
stage.focus = input_txt;
}

// ************ 客户端 Socket ************
var socket:Socket = new Socket();
socket.connect("127.0.0.1", 8888);
socket.addEventListener(ProgressEvent.SOCKET_DATA, readMessage);

function readMessage(evt:ProgressEvent):void {
output_txt.appendText(socket.readUTF() + "\n");
}

五、编写 Java 服务器端 Socket
最后，我们需要编写 Java 后台服务器端的代码。
首先，创建一个 ServerSocket 作为Socket 服务器。当有客户端连接后通过 accept() 方法即可得到客户端的 Socket：

ServerSocket socketServer = new ServerSocket(8888);
System.out.println("服务器已启动，等待客户端连接");

// accept() 方法是阻塞式的，当有客户端连接成功后才继续执行
Socket socket = socketServer.accept();
System.out.println("客户端连接成功");

然后得到与客户端的输入流和输出流（输入流是客户端连接到服务器的管道，输出流则是服务器到客户端的管道）：
// 获得输入流和输出流，输入流为 BufferedReader 类型，输出流为 DataOutputStream 类型
BufferedReader reader =
new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
DataOutputStream writer = new DataOutputStream(socket.getOutputStream());

拿到输入输出流以后，就可以通过输入流（InputStream）读取 Flash 客户端发来的字符串，通过输出流（OutputStream）向 Flash 客户端写字符串：
while (true) {
// readLine() 方法也是阻塞式的，当客户端有消息发来就读取，否则就一直等待
String msg = reader.readLine();

// 当客户端发送的字符串为 null 时，说明客户端已经关闭，此时退出循环
if (msg == null) {
System.out.println("客户端已离开");
break;
}

// 将读入的信息加工后再写回客户端
writer.writeUTF("写回客户端的" + msg);
}

以上是ServerSocket 与 AS 3 Socket 通信的基本原理。在实际应用中，会有多个客户端连接这个ServerSocket，因此要创建一个多线程的 Socket 服务器。
下面简述一下多线程 Socket 服务器原理：当socketServer.accept() 之后就需要实例化一个线程对象，在该对象中持有socketServer.accept() 返回的 Socket 对象，然后让线程跑起来执行读写操作。如果再来一个客户端就再跑一个线程，同样执行读写操作。同时，用一个 List 容器来管理这些对象。
最终服务器端的代码如下：
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class FlashScoket {
private List<Client> clientList = new ArrayList<Client>();

public static void main(String[] args) {
new FlashScoket().runSocket();
}

private void runSocket() {
try {
ServerSocket socketServer = new ServerSocket(8888);
System.out.println("服务器已启动，等待客户端连接");

while (true) {
// accept() 方法是阻塞式的，当有客户端连接成功后才继续执行
Socket socket = socketServer.accept();
System.out.println("客户端连接成功");

// 实例化一个 Client 对象，并启动该线程
Client client = new Client(socket);
clientList.add(client);
client.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}

class Client extends Thread {
private Socket socket;

private BufferedReader reader;
private DataOutputStream writer;

private Client(Socket socket) {
this.socket = socket;
try {
// 获得输入流和输出流，输入流为 BufferedReader 类型，输出流为 DataOutputStream 类型
reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
writer = new DataOutputStream(socket.getOutputStream());
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}

@Override
public void run() {
try {
while (true) {
// readLine() 方法也是阻塞式的，当客户端有消息发来就读取，否则就一直等待
String msg = reader.readLine();

// 当客户端发送的字符串为 null 时，说明客户端已经关闭，此时退出循环
if (msg == null) {
clientList.remove(this);
System.out.println("客户端已离开");
break;
}

// 将读入的内容写给每个客户端
for (Iterator<Client> it = clientList.iterator(); it.hasNext();) {
Client client = it.next();
client.getWriter().writeUTF(msg);
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭 socket 及相关资源
try {
if (reader != null) {
reader.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (writer != null) {
writer.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (socket != null) {
socket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}

public DataOutputStream getWriter() {
return writer;
}
}
}

六、补充技术
1. 如何测试？
* 首先要编译FlashScoket —— javac FlashScoket
* 然后启动FlashScoket —— java FlashScoket
* 最后将 Flash 发布为 exe 文件格式，同时开启多个即可。

2. 自动跟踪到最后一行：当收到新的消息时自动滚动到最后一行，在 readMessage() 方法中加入：
output_txt.verticalScrollBar.scrollPosition = output_txt.verticalScrollBar.maxScrollPosition;

3. 当出现输入/输出错误并导致发送或加载操作失败时提示用户，加入对IO_ERROR 的侦听：
socket.addEventListener(IOErrorEvent.IO_ERROR, socketIOError);
function socketIOError(evt:IOErrorEvent):void {
output_txt.appendText("服务器端尚未开启，请稍后再试\n");
}

4. 在sendMessage() 中加入对空字符串的验证，如果为空则 return：
if (input_txt.text == "") {
return;
}

5. 在消息前面显示用户名：大家可以制作一个登录页面，输入用户名，假设已将输入的用户名存放在 userName 变量中，在写入时加进去：
var userName:String = "FL 车在臣";
在 sendMessage() 中相应改为：
bytes.writeUTFBytes(userName + " : " + input_txt.text + "\n");

6. 使用output_txt .htmlText 输出文字，那么相应的写入格式可以调整为：
bytes.writeUTFBytes("<font color='#0000FF'>" + userName + " : </font>" + input_txt.text + "\n");

❻ Java即时通讯IM聊天软件仿微信APP源码解析

Java即时通讯IM聊天软件仿微信APP源码解析：

阅读全文

与java聊天系统相关的资料

热点内容
微信网名带念字 浏览：161
提取一个文件夹里的所有图片 浏览：198
三星s5自带文件管理器 浏览：356
如何将文档数据按规定排序 浏览：660
word中的文件如何重命名 浏览：272
新基建中的数据中心是指什么 浏览：728
pdf扫描文件插入图片大小 浏览：362
java500错误原因 浏览：905
sx1278代码 浏览：729
调试配置文件 浏览：780
企业培训app如何选 浏览：38
adonet读取数据库 浏览：717
蓝色代码 浏览：500
怎么进入网站后台管理系统 浏览：988
win7如何传文件 浏览：649
微信赠送u盘文件 浏览：216
office2016激活文件名 浏览：841
打印要输入文件名 浏览：59
虚拟串口用什么编程 浏览：314
word2010怎么设置不同的页码 浏览：61

友情链接