用java写一个点对点聊天，建立-条 TCP连接。 点对点聊天的2个窗口建立一条 TCP连接后开始聊天，输入- -行字符串，单击“发送”按钮，向对方发送内容;单击“离线”按钮，聊天结束，2个按钮无效，。窗口标题栏显示各自的主机名、IP 地址和端口

### 回答1：
好的，这个可以使用Java Socket编程实现。首先需要创建两个窗口，一个作为客户端，一个作为服务端，然后通过TCP连接进行通信。

以下是一个简单的实现：

服务端代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("Server started. Waiting for client...");

        Socket clientSocket = serverSocket.accept();
        System.out.println("Client connected.");

        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

        String inputLine;
        while ((inputLine = in.readLine()) != null) {
            System.out.println("Client: " + inputLine);
            out.println("Server received: " + inputLine);
        }

        out.close();
        in.close();
        clientSocket.close();
        serverSocket.close();
    }
}

客户端代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class Client {
    public static void main(String[] args) throws IOException {
        String hostName = "localhost";
        int portNumber = 8888;

        Socket clientSocket = new Socket(hostName, portNumber);
        System.out.println("Connected to server.");

        PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
        BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
        BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in));

        String userInput;
        while ((userInput = stdIn.readLine()) != null) {
            out.println(userInput);
            System.out.println("Server: " + in.readLine());
        }

        out.close();
        in.close();
        stdIn.close();
        clientSocket.close();
    }
}

在运行这两个程序之前，需要先运行服务端程序，然后再运行客户端程序。客户端程序会连接到服务端，然后通过标准输入向服务端发送消息，服务端会将消息返回给客户端，并打印到标准输出上。

这只是一个简单的点对点聊天程序，可以根据实际需求进行扩展和优化。

### 回答2：
使用Java编写点对点聊天程序可以通过以下步骤实现：

1. 导入必要的Java库和包，例如java.io和java.net。
2. 创建一个客户端窗口和一个服务器窗口，用来接收和发送消息。
3. 在客户端窗口中实现发送按钮的点击事件，获取输入框中的字符串内容，并通过TCP连接发送给服务器窗口。
4. 在服务器窗口中实现接收客户端消息的功能，通过TCP连接接收来自客户端窗口的消息。
5. 在客户端窗口和服务器窗口的标题栏中显示各自的主机名、IP地址和端口号。

具体的实现步骤如下：

1. 创建一个ServerSocket对象，并指定一个端口号，用于接收来自客户端窗口的连接请求。
2. 创建一个Socket对象，连接到服务器窗口指定的IP地址和端口号。
3. 在服务器窗口中使用ServerSocket的accept()方法接收来自客户端窗口的连接请求，并创建一个Socket对象来处理该连接。
4. 使用Socket对象的getInputStream()方法获取输入流，接收来自客户端窗口的消息。
5. 在客户端窗口中使用Socket对象的getOutputStream()方法获取输出流，将字符串消息发送给服务器窗口。
6. 在服务器窗口中使用Socket对象的getOutputStream()方法获取输出流，将字符串消息发送给客户端窗口。
7. 在客户端窗口和服务器窗口的标题栏中显示各自的主机名、IP地址和端口号。

以上是一个简单的点对点聊天程序的实现步骤，具体的代码实现需要根据具体要求和界面设计进行编写。

### 回答3：
使用Java编写一个点对点聊天应用程序可以通过建立一条TCP连接实现。以下是一个简单的实现示例：

首先，需要导入以下Java类：

import java.io.*;
import java.net.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

然后，创建一个窗口类来实现点对点聊天应用程序的界面和功能：

public class ChatWindow extends JFrame {
    private Socket socket;
    private BufferedReader reader;
    private BufferedWriter writer;
    private JTextArea chatArea;
    private JTextField inputField;
    private JButton sendButton;
    private JButton offlineButton;

    public ChatWindow(Socket socket) {
        this.socket = socket;
        
        try {
            reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        setTitle("Chat Window");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(400, 300);
        setLayout(new BorderLayout());

        // 显示主机名、IP地址和端口号
        JLabel infoLabel = new JLabel("Host: " + socket.getLocalAddress().getHostName() +
                " IP: " + socket.getLocalAddress().getHostAddress() +
                " Port: " + socket.getLocalPort());
        add(infoLabel, BorderLayout.NORTH);

        chatArea = new JTextArea();
        chatArea.setEditable(false);
        JScrollPane scrollPane = new JScrollPane(chatArea);
        add(scrollPane, BorderLayout.CENTER);

        JPanel inputPanel = new JPanel();
        inputPanel.setLayout(new BorderLayout());
        inputField = new JTextField();
        inputPanel.add(inputField, BorderLayout.CENTER);

        sendButton = new JButton("发送");
        sendButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                sendMessage();
            }
        });
        inputPanel.add(sendButton, BorderLayout.EAST);

        offlineButton = new JButton("离线");
        offlineButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                closeConnection();
            }
        });
        inputPanel.add(offlineButton, BorderLayout.WEST);

        add(inputPanel, BorderLayout.SOUTH);

        // 创建一个线程来接收对方的消息
        Thread receiveThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    String message;
                    while ((message = reader.readLine()) != null) {
                        chatArea.append("对方: " + message + "\n");
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
        receiveThread.start();
    }

    private void sendMessage() {
        String message = inputField.getText();
        try {
            writer.write(message);
            writer.newLine();
            writer.flush();
            chatArea.append("我: " + message + "\n");
            inputField.setText("");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void closeConnection() {
        try {
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        sendButton.setEnabled(false);
        offlineButton.setEnabled(false);
    }

    public static void main(String[] args) {
        try {
            // 创建服务器Socket并监听端口
            ServerSocket serverSocket = new ServerSocket(8888);
            System.out.println("Server listening on port 8888...");

            // 等待客户端连接
            Socket socket = serverSocket.accept();
            System.out.println("Client connected...");

            // 创建一个聊天窗口
            ChatWindow window = new ChatWindow(socket);
            window.setVisible(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码是一个简化的实现示例，提供了基本的界面和功能。你可以根据自己的需求进行扩展和改进。在上面的代码中，服务器端通过监听指定端口，等待客户端的连接请求。连接建立后，将创建一个聊天窗口来进行聊天。该窗口包含一个输入框、一个发送按钮和一个离线按钮，用于发送消息和关闭连接。聊天内容会显示在一个文本区域中。

请注意，该示例仅提供了一个服务器端与一个客户端之间的点对点聊天功能。如果你需要实现多个客户端之间的点对点聊天，可能需要用到多线程和更复杂的架构。