简易聊天程序代码JAVA java简单聊天程序代码

java的问题，一个简单的聊天程序

lz 简易聊天程序代码JAVA你好

具体代码如下:

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class Chat extends JFrame{

 private JLabel enter,start;

 private JTextField input;

 private JTextArea output;

    public Chat() {

     super("小程序查看器:Client.class");

     

     enter = new JLabel("html小程序brEnter Text/html");

     enter.setFont(new Font("宋体", Font.PLAIN, 12));

     start = new JLabel("小程序已启动。");

     start.setFont(new Font("宋体", Font.PLAIN, 12));

     input = new JTextField(30);

     output = new JTextArea(10,35);

     output.setEditable(false);

     

     input.addKeyListener(new KeyAdapter(){

      public void keyPressed(KeyEvent e){

       if(e.getKeyCode() == 10){

        output.append(input.getText() + "\n");

       }

      }

     });

     

     setLayout(new FlowLayout(FlowLayout.LEFT,1,1));

     getContentPane().add(enter);

     getContentPane().add(input);

     getContentPane().add(output);

     getContentPane().add(start);

     

     setLocation(300,200);

     setSize(450,270);

     setResizable(false);

     setVisible(true);

     setDefaultCloseOperation(3);

    }

    public static void main(String[] args) {

     new Chat();

    }

}

希望能帮助简易聊天程序代码JAVA你哈

相关问答

Q1: Java简单聊天程序

package com.kum.im.hrserver.test;

import java.net.*;

import java.nio.*;

import java.nio.channels.*;

import java.nio.charset.*;

import java.awt.*;

import java.awt.event.*;

public class ChatClient {

private SocketChannel sc = null;

private String name = null;

private Frame f;

private TextArea ta;

private TextField tf;

private boolean runnable = true;

public static void main(String[] args){

ChatClient cc = new ChatClient();

cc.createUI();

cc.inputName();

cc.connect();

new ReceiveThread(cc,cc.getTextArea()).start();

}

public SocketChannel getSc(){

return sc;

}

public void setName(String name){

this.name = name;

}

public TextArea getTextArea(){

return ta;

}

public TextField getTextField(){

return tf;

}

public boolean getRunnable(){

return runnable;

}

public void stop(){

runnable = false;

}

public void shutDown(){

try{

sc.write(ByteBuffer.wrap("bye".getBytes("UTF-8")));

ta.append("Exit in 5 seconds!");

this.stop();

Thread.sleep(5000);

sc.close();

}catch(Exception e){

e.printStackTrace();

}

System.exit(0);

}

public void createUI(){

f = new Frame("Client");

ta = new TextArea();

ta.setEditable(false);

tf = new TextField();

Button send = new Button("Send");

Panel p = new Panel();

p.setLayout(new BorderLayout());

p.add(tf,"Center");

p.add(send,"East");

f.add(ta,"Center");

f.add(p,"South");

MyClientListener listener = new MyClientListener(this);

send.addActionListener(listener);

tf.addActionListener(listener);

f.addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent e){

ChatClient.this.shutDown();

}

});

f.setSize(400,400);

f.setLocation(600,0);

f.setVisible(true);

tf.requestFocus();

}

public boolean connect(){

try{

sc = SocketChannel.open();

//"zlg"为目标计算机名

InetSocketAddress isa = new InetSocketAddress("192.168.1.43",8814);

sc.connect(isa);

sc.configureBlocking(false);

sc.write(ByteBuffer.wrap(name.getBytes("UTF-8")));

}catch(Exception e){

e.printStackTrace();

}

return true;

}

public void inputName(){

String name = javax.swing.JOptionPane.showInputDialog("Input Your Name:");

this.setName(name);

f.setTitle(name);

}

}

class MyClientListener implements ActionListener{

private ChatClient client;

public MyClientListener(ChatClient client){

this.client = client;

}

public void actionPerformed(ActionEvent e){

TextField tf = client.getTextField();

String info = tf.getText();

if(info.equals("bye")){

client.shutDown();

}else{

try{

client.getSc().write(ByteBuffer.wrap(info.getBytes("UTF-8")));

}catch (Exception e1) {

e1.printStackTrace();

}

}

tf.setText("");

tf.requestFocus();

}

}

class ReceiveThread extends Thread{

private ChatClient client;

private TextArea ta;

public ReceiveThread(ChatClient client,TextArea ta){

this.client = client;

this.ta = ta;

}

public void run(){

SocketChannel sc = client.getSc();

ByteBuffer byteBuffer = ByteBuffer.allocate(2048);

CharBuffer charBuffer = null;

Charset charset = Charset.forName("UTF-8");

CharsetDecoder decoder = charset.newDecoder();

String msg = null;

int n = 0;

try{

while(client.getRunnable()){

n = sc.read(byteBuffer);

if(n0){

byteBuffer.flip();

charBuffer = decoder.decode(byteBuffer);

msg = charBuffer.toString();

ta.append(msg + "\n");

}

byteBuffer.clear();

Thread.sleep(500);

}

}catch(Exception e){

e.printStackTrace();

System.exit(0);

}

}

}

import java.io.*;

import java.nio.*;

import java.nio.channels.*;

import java.nio.charset.*;

import java.net.*;

import java.util.*;

public class ICQServer {

private Selector selector = null;

private ServerSocketChannel ssc = null;

//服务器端通信端口号

private int port = 8814;

//在线用户列表

private HashtableString, SocketChannel userList = null;

public ICQServer() {}

public ICQServer(int port) {

this.port = port;

}

//初始化服务器

public void init() {

try {

//创建选择器对象

selector = Selector.open();

//创建ServerSocketChannel

ssc = ServerSocketChannel.open();

//设置ServerSocketChannel为非阻塞模式

ssc.configureBlocking(false);

InetAddress ip = InetAddress.getLocalHost();

System.out.println("主机地址 -------- " + ip);

InetSocketAddress isa = new InetSocketAddress(ip, port);

//将与本通道相关的服务器套接字对象绑定到指定地址和端口

ssc.socket().bind(isa);

//创建在线用户列表

userList = new HashtableString, SocketChannel ();

}

catch (IOException e) {

System.out.println("初始化服务器时异常，原因 -------- " + e.getMessage());

}

}

//启动服务器

public void start() {

try {

//将ServerSocketChannel注册到Selector上，准备接收新连接请求

SelectionKey acceptKey = ssc.register(selector, SelectionKey.OP_ACCEPT);

SocketChannel sc;

int n;

String name; //用户名

String msg; //用户发言信息

while (true) {

//选择当前所有处于就绪状态的通道所对应的选择键,并将这些键组成已选择键集

n = selector.select(); //n为已选择键集中键的个数

if (n 0) {

//获取此选择器的已选择键集。

Set readyKeys = selector.selectedKeys();

Iterator it = readyKeys.iterator();

//遍历当前已选择键集

while (it.hasNext()) {

SelectionKey key = (SelectionKey) it.next();

//从当前已选择键集中移除当前键，避免重复处理

it.remove();

//如果当前键对应的通道已准备好接受新的套接字连接

if (key.isAcceptable()) {

//获取当前键对应的可选择通道（ServerSocketChannel）

ssc = (ServerSocketChannel) key.channel();

//接收新的套接字连接请求，返回新建的SocketChannel

sc = (SocketChannel) ssc.accept();

//如果有新用户接入

if (sc != null) {

//接收新上线用户姓名

name = readMessage(sc);

//设置新建的SocketChannel为非阻塞模式

sc.configureBlocking(false);

//将新建的SocketChannel注册到Selector上，准备进行数据"写"操作，

//并将当前用户名以附件的方式附带记录到新建的选择键上。

SelectionKey newKey = sc.register(selector,

SelectionKey.OP_WRITE, name);

//将新上线用户信息加入到在线用户列表

userList.put(name, sc);

//发送"新用户上线"通知

transmitMessage(name + " in!", "--Server Info--");

}

}

//否则，如果当前键对应的通道已准备好进行"写"操作

else if (key.isWritable()) {

//获取当前键对应的可选择通道（SocketChannel）

sc = (SocketChannel) key.channel();

//接收该通道相应用户的发言信息

msg = readMessage(sc);

//获取选择键上附带记录的当前用户名

name = key.attachment().toString();

//如果用户提出要下线

if (msg.equals("bye")) {

//从在线用户列表中移除当前用户

userList.remove(name);

//注销当前选择键对应的注册关系

key.cancel();

//关闭当前可选择通道

sc.close();

//发送"用户下线"通知

transmitMessage(name + " out!", "--Server Info--");

}

//否则，如果接收到的用户发言信息非空（""）

else if (msg.length() 0) {

//转发用户发言信息

transmitMessage(msg, name);

}

}

}

}

//延时循环，降低服务器端处理负荷

Thread.sleep(500);

}

}

catch (Exception e) {

System.out.println("启动服务器时异常，原因 -------- " + e.getMessage());

}

}

//转发用户发言信息

public void transmitMessage(String msg, String name) {

try {

ByteBuffer buffer = ByteBuffer.wrap( (name + ":" + msg).getBytes("UTF-8"));

//将字节数组包装到缓冲区中

Collection channels = userList.values();

SocketChannel sc;

for (Object o : channels) {

sc = (SocketChannel) o;

sc.write(buffer);

//将缓冲区数据写入聊天面板(TextArea)

buffer.flip();

//将缓冲区ByteBuffer的极限值设置为当前数据实际大小，将缓冲区的值设置为0

}

}

catch (Exception e) {

System.out.println("转发用户发言信息时异常，原因 -------- " + e.getMessage());

}

}

//接收用户发言信息

public String readMessage(SocketChannel sc) {

String result = null;

int n = 0;

ByteBuffer buf = ByteBuffer.allocate(1024);

try {

n = sc.read(buf);

buf.flip();

Charset charset = Charset.forName("UTF-8");

CharsetDecoder decoder = charset.newDecoder();

CharBuffer charBuffer = decoder.decode(buf);

result = charBuffer.toString();

}

catch (IOException e) {

System.out.println("接收用户发言信息时异常，原因 -------- " + e.getMessage());

}

return result;

}

public static void main(String args[]) {

ICQServer server = new ICQServer();

server.init();

server.start();

}

}

Q2: 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

Q3: 急需一个java编程实现的简单聊天窗口代码

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import java.net.*;

import java.io.*;

public class ClientDemo01 {

public static void main(String[] args){

JFrame f=new JFrame("AA");

JPanel p1=new JPanel();

JPanel p2=new JPanel();

JTextArea ta=new JTextArea(15,30);

ta.setEditable(false); //文本域只读

JScrollPane sp=new JScrollPane(ta); //滚动窗格

JTextField tf=new JTextField(20);

JButton b=new JButton("发送");

p1.add(sp);

p2.add(tf);

p2.add(b);

f.add(p1,"Center");

f.add(p2,"South");

f.setBounds(300,300,360,300);

f.setVisible(true);

f.setResizable(false);

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

Socket socket=null;

BufferedInputStream bis=null;

BufferedOutputStream bos=null;

try{

socket=new Socket("192.168.0.4",5000);

bis=new BufferedInputStream(socket.getInputStream());

bos=new BufferedOutputStream(socket.getOutputStream());

MyThread01 mt=new MyThread01(bis,ta);

mt.start();

}catch(Exception e){

e.printStackTrace();

}

b.addActionListener(new ButtonActionListener01(tf,ta,bos));

}

}

class ButtonActionListener01 implements ActionListener{

JTextField tf;

JTextArea ta;

BufferedOutputStream bos;

public ButtonActionListener01(JTextField tf,JTextArea ta,BufferedOutputStream bos){

this.tf=tf;

this.ta=ta;

this.bos=bos;

}

public void actionPerformed(ActionEvent e){

String message=tf.getText();

if(!message.equals("")){

tf.setText(""); //清空文本框

ta.append("AA:"+message+"\n"); //添加到文本域并换行

try{

bos.write(message.getBytes());

bos.flush();

}catch(Exception ex){

System.out.println("发送失败");

}

}

}

}

class MyThread01 extends Thread{

BufferedInputStream bis;

JTextArea ta;

public MyThread01(BufferedInputStream bis,JTextArea ta){

this.bis=bis;

this.ta=ta;

}

public void run(){

try{

while(true){

byte[] b=new byte[100];

int length=bis.read(b);

String message=new String(b,0,length);

ta.append("BB:"+message+"\n");

}

}catch(Exception e){

e.printStackTrace();

}

}

} import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import java.net.*;

import java.io.*;

public class ServerDemo01{

public static void main(String[] args){

JFrame f=new JFrame("BB");

JPanel p1=new JPanel();

JPanel p2=new JPanel();

JTextArea ta=new JTextArea(12,30); //文本域，第一个参数为行数，第二个参数为列数

ta.setEditable(false); //文本域只读

JScrollPane sp=new JScrollPane(ta); //滚动窗格

JTextField tf=new JTextField(20);

JButton b=new JButton("发送");

p1.add(sp);

p2.add(tf);

p2.add(b);

f.add(p1,"Center");

f.add(p2,"South");

f.setBounds(300,300,360,300);

f.setVisible(true);

f.setResizable(false);

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

ServerSocket server=null;

Socket socket=null;

BufferedInputStream bis=null;

BufferedOutputStream bos=null;

try{

server=new ServerSocket(5000);

//ta.append("等待AA连接...\n");

socket=server.accept();

//ta.append("AA已连接\n");

bis=new BufferedInputStream(socket.getInputStream());

bos=new BufferedOutputStream(socket.getOutputStream());

MyThread1 mt=new MyThread1(bis,ta);

mt.start();

}catch(Exception e){

e.printStackTrace();

}

b.addActionListener(new ButtonActionListener1(tf,ta,bos));

}

}

class ButtonActionListener1 implements ActionListener{

JTextField tf;

JTextArea ta;

BufferedOutputStream bos;

public ButtonActionListener1(JTextField tf,JTextArea ta,BufferedOutputStream bos){

this.tf=tf;

this.ta=ta;

this.bos=bos;

}

public void actionPerformed(ActionEvent e){

String message=tf.getText(); //获取文本框中简易聊天程序代码JAVA的内容

if(!message.equals("")){

tf.setText(""); //清空文本框

ta.append("BB:"+message+"\n"); //添加到文本域并换行

try{

bos.write(message.getBytes());

bos.flush();

}catch(Exception ex){

System.out.println("发送失败简易聊天程序代码JAVA！");

}

}

}

}

class MyThread1 extends Thread{

BufferedInputStream bis;

JTextArea ta;

public MyThread1(BufferedInputStream bis,JTextArea ta){

this.bis=bis;

this.ta=ta;

}

public void run(){

try{

while(true){

byte[] b=new byte[100];

int length=bis.read(b);

String message=new String(b,0,length);

ta.append("AA:"+message+"\n");

}

}catch(Exception e){

e.printStackTrace();

}

}

}

Q4: java多人聊天一般都是怎么搭建的？

Java多人聊天可以使用Java简易聊天程序代码JAVA的Socket编程实现，主要的思路是：使用服务器来维护所有客户端的连接，并将客户端之间的聊天信息进行转发。

具体的实现步骤如下：

创建服务器端：使用ServerSocket类创建一个服务器端，并监听指定的端口，等待客户端的连接。

创建客户端：使用Socket类创建一个客户端，并连接到服务器端。

实现聊天功能：客户端和服务器端之间可以通过输入和输出流进行通信，客户端将聊天信息发送给服务器，服务器再将其转发给其他客户端。

处理异常：在实现聊天功能时，需要注意处理可能出现的异常，例如连接异常、输入输出异常等等。

一个简单的Java多人聊天程序的代码框架如下：

服务器端：

import java.io.IOException;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.ArrayList;

public class ChatServer {

private ServerSocket serverSocket;

private ArrayListClientHandler clients;

public ChatServer(int port) throws IOException {

serverSocket = new ServerSocket(port);

clients = new ArrayListClientHandler();

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

}

public void start() throws IOException {

while (true) {

Socket socket = serverSocket.accept();

ClientHandler client = new ClientHandler(socket, this);

clients.add(client);

client.start();

}

}

public void broadcast(String message) {

for (ClientHandler client : clients) {

client.sendMessage(message);

}

}

public void removeClient(ClientHandler client) {

clients.remove(client);

}

public static void main(String[] args) throws IOException {

ChatServer server = new ChatServer(12345);

server.start();

}

}

客户端：

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

public class ChatClient {

private Socket socket;

private BufferedReader reader;

private PrintWriter writer;

private String name;

public ChatClient(String serverAddress, int port, String name) throws IOException {

socket = new Socket(serverAddress, port);

reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

writer = new PrintWriter(socket.getOutputStream(), true);

this.name = name;

}

public void start() throws IOException {

System.out.println("欢迎来到聊天室！");

new Thread(new IncomingMessageHandler()).start();

new Thread(new OutgoingMessageHandler()).start();

}

private class IncomingMessageHandler implements Runnable {

@Override

public void run() {

try {

while (true) {

String message = reader.readLine();

if (message == null) {

break;

}

System.out.println(message);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

close();

}

}

}

private class OutgoingMessageHandler implements Runnable {

@Override

public void run() {

BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

try {

while (true) {

String message = reader.readLine();

if (message.equals("quit")) {

break;

}

writer.println(name + ": " + message);

}

} catch (IOException e) {

e.printStackTrace简易聊天程序代码JAVA；

} finally {

close();

}

}

}

Q5: 要JAVA聊天程序代码，急用

import java.io.InputStream;

import java.io.DataInputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.DataOutputStream;

import java.io.BufferedReader;

import java.net.ServerSocket;

import java.net.Socket;

import java.io.IOException;

import java.util.Date;

class Server

{

public Server()

{

try

{

ServerSocket s=new ServerSocket(8888);

Socket ss=s.accept();

OutputStream out=ss.getOutputStream();

DataOutputStream dout=new DataOutputStream(out);

InputStream in=ss.getInputStream();

DataInputStream din=new DataInputStream(in);

System.out.print(din.readUTF()+"!");

dout.writeUTF("你已经连接到服务器"+"\t"+"你的地址："+ss.getInetAddress()+"\t"

+"你的链接端口："+ss.getLocalPort()+"\n");

new ReadMessage(din).start();

new SendMessage(dout).start();

}

catch (IOException e)

{

e.printStackTrace();

}

}

public static void main(String[] args)

{

new Server();

}

}

//接受客户端信息

class ReadMessage extends Thread

{

private DataInputStream din;

public ReadMessage(DataInputStream din)

{

this.din=din;

}

public void run()

{

String str;

try

{

while (true)

{

str=din.readUTF();

System.out.println(new Date().toLocaleString()+"客户端说："+str);

if (str.equals("bye"))

{

System.out.println("客户端下线！");

break;

}

}

}

catch (IOException e)

{

e.printStackTrace();

}

}

}

// 发出服务器信息

class SendMessage extends Thread

{

private DataOutputStream dout;

public SendMessage(DataOutputStream dout)

{

this.dout=dout;

}

public void run()

{

InputStreamReader inr=new InputStreamReader(System.in);

BufferedReader buf=new BufferedReader(inr);

String str;

try

{

while(true)

{

str=buf.readLine();

dout.writeUTF(str);

if (str.equals("bye"))

{

System.out.println("服务器退出！");

System.exit(1);

}

}

}

catch (IOException e)

{

e.printStackTrace();

}

}

}

import java.io.InputStream;

import java.io.DataInputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.DataOutputStream;

import java.io.BufferedReader;

import java.net.Socket;

import java.io.IOException;

import java.util.Date;

class Client

{

public Client()

{

try

{

Socket s=new Socket("192.168.1.2",8888);

InputStream in=s.getInputStream();

DataInputStream din=new DataInputStream(in);

OutputStream out=s.getOutputStream();

DataOutputStream dout=new DataOutputStream(out);

dout.writeUTF("服务器你好！我是客户端");

System.out.println(din.readUTF());

new Thread(new SenderMessage(dout)).start();

new Thread(new ReaderMessage(din)).start();

}

catch (IOException e)

{

e.printStackTrace();

}

}

public static void main(String[] args)

{

new Client();

}

}

class ReaderMessage implements Runnable

{

private DataInputStream din;

public ReaderMessage(DataInputStream din)

{

this.din=din;

}

public void run()

{

String str;

try

{

while(true)

{

str=din.readUTF();

System.out.println(new Date().toLocaleString()+"服务器说："+str);

if (str.equals("bye"))

{

System.out.println("服务器已经关闭，此程序自动退出！");

break;

}

}

}

catch (IOException e)

{

e.printStackTrace();

}

}

}

class SenderMessage implements Runnable

{

private DataOutputStream dout;

public SenderMessage(DataOutputStream dout)

{

this.dout=dout;

}

public void run()

{

String str;

InputStreamReader inf=new InputStreamReader(System.in);

BufferedReader buf=new BufferedReader(inf);

try

{

while (true)

{

str=buf.readLine();

dout.writeUTF(str);

if (str.equals("bye"))

{

System.out.println("客户端自己退出！");

System.exit(1);

}

}

}

catch (IOException e)

{

e.printStackTrace();

}

}

}

关于简易聊天程序代码JAVA和java简单聊天程序代码的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。