老师，最后的p.work为什么不能运行，改成person.work()才可以呢？

package H_Socket.C_Tcp;

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

/**
 * 聊天室，一个客户端发送消息其他的客户端也可以接收到消息
 */
//创建一个消息接收线程
class ChatReceive extends Thread{
    BufferedReader bufferedReader;
    Socket socket;
    public ChatReceive(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
                synchronized ("a"){
                    //把从客户端接收到的信息给缓冲区
                    ChatServer.buf = bufferedReader.readLine();
                    //唤醒发送信息的线程对象
                    "a".notifyAll();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bufferedReader != null){
                    bufferedReader.close();
                }
                if (socket != null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
//创建一个消息发送线程
class ChatSend extends Thread{
    PrintWriter printWriter;
    Socket socket;
    public ChatSend(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            while (true){
                synchronized ("a"){
                    //让发送消息的线程处于等待状态
                    "a".wait();
                    //把接缓冲区的信息发送给其他的客户端
                    printWriter.println(ChatServer.buf);
                    printWriter.flush();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (socket != null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
public class ChatServer {
    //定义公共区域
    public static String buf;
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        try {
            System.out.println("监听83端口");
            serverSocket = new ServerSocket(83);
            while(true){
                Socket socket = serverSocket.accept();
                System.out.println("连接到" + socket.getInetAddress());
                new ChatSend(socket).start();
                new ChatReceive(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (serverSocket != null){
                    serverSocket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

package H_Socket.C_Tcp;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

/**
 * 在一个程序里既是客户端也可以是服务端，根据你输入的不同而不同
 */
//发送线程
class Send extends Thread{
    private Socket socket;
    private Scanner scanner;
    public Send(Socket socket){
        this.socket = socket;
    }
    PrintWriter printWriter = null;
    @Override
    public void run() {
        try {
            printWriter = new PrintWriter(this.socket.getOutputStream());
            scanner = new Scanner(System.in);
            while (true){
                String message = scanner.nextLine();
                printWriter.println(message);
                printWriter.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (scanner != null){
                    scanner.close();
                }
                if (printWriter != null){
                    printWriter.close();
                }
            }catch (Exception e){
                printWriter.println();
            }
        }
    }
}
//接收线程
class Receive extends Thread{
    private Socket socket;
    public Receive(Socket socket){
        this.socket = socket;
    }
    BufferedReader bufferedReader = null;
    @Override
    public void run() {
        try {
            bufferedReader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
               String string = bufferedReader.readLine();
               System.out.println("他说：" + string);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (bufferedReader != null){
                    bufferedReader.close();
                }
                if (socket != null){
                    socket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}
public class GoodTcp {
    public static void main(String[] args) throws Exception {
        Socket socket = null;
        ServerSocket serverSocket = null;
        Scanner scanner = null;
        try {
            scanner = new Scanner(System.in);
            System.out.println("请输入：server,<port> 或者：<ip>,<port>");
            String s = scanner.nextLine();
            String[] arrays = s.split(",");
            if ("server".equals(arrays[0])){
                //启动服务端
                System.out.println("TCP服务端监听" + arrays[1] + "端口，等待连接");
                serverSocket = new ServerSocket(Integer.parseInt(arrays[1]));
                socket = serverSocket.accept();
                System.out.println("连接成功");
            }else {
                //启动客户端
                socket = new Socket(arrays[0],Integer.parseInt(arrays[1]));
                System.out.println("连接成功");
            }
            //启动发送线程
            new Send(socket).start();
            //启动接收线程
            new Receive(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                if (serverSocket != null){
                    serverSocket.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

显示连接成功，但是不能进行相互之间的通信

老师，我在看API文档的时候看到  创建由此类对象表示的类的新实例

我想问下：对象和实例有啥区别，能不能给我举个例子

编码问题已经解决了，谢谢。是前端请求进来就成？乱码了

列表啊元组等序列问题都有个清空操作，我想问一下清空后原来的序列是作为空值存在还是内存里都清除了。

输出顺序不应该是：

1.开始创建一个ChildClass对象....

2.创建FatherClass //是因为 new 调用了ChildClass2()， 然后因为super()，调用了FatherClass()

3.(继续输出)创建FatherClass  //因为程序继续往下走不还是到 public FatherClass吗？

4.(还是)创建FatherClass  //到public ChildClass 第一句不还是super()

5.创建ChildClass

(还是说super()只调用一次？？？？)

麻烦老师解答一下  谢谢

select rownum rn from(select * from employees) where rn>10 and rn=<20;

这样行不行？好像也可以实现分页查询

老师好，关于递归调用，有如下算法代码：

class Solution {
    public void recoverTree(TreeNode root) {
        TreeNode pre = null;
        TreeNode first = null;
        TreeNode second = null;
        helper(root, pre, first, second);
        int temp = first.val;
        first.val = second.val;
        second.val = temp;
    }
    private void helper(TreeNode root, TreeNode pre, TreeNode first, TreeNode second){
        if(root ==  null) return;
        helper(root.left, pre, first, second);
        if(pre != null && pre.val > root.val){
            if(first == null){
                first = pre;
                second = root;
            }else{
                second = root;
            }
        }
        pre = root;
        helper(root.right, pre, first, second);
    }
}

我的问题是3-5行的三个变量，这里要通过一个私有方法helper去修改pre， first和second的变量值，但是运行后发现是空指针。

我的问题是，如果在helper方法中，没有返回三个变量的值，是否就无法改变recoverTree方法中的三个变量值？这里的修改方法，要么是在helper方法中，返回一个first和scond的数组，要么就把三个变量放到全局变量中？

既然float赋的值超出了其范围，只能保留其最大值，之后让f5和f6比较，得出两者相同。

但是float赋的值最后不是加“L”了吗？已经变成long的类型，不就能接纳之前赋的值了吗，

为什么还要“保留其最大值”呢，这不就矛盾了吗？

文档里的那两个chart仓库源好像不行了，我添加这个仓库源可以install和添加仓库（2021.08.03）
helm repo add apphub https://apphub.aliyuncs.com

float类型赋的值后面加了“L”，因为赋的值超出了其范围，和long与int的关系差不多。

所以可以理解为，浮点型和整数型之间没有明确的概念，两者是相互“包容”，可相互“串通”的吗？

老师，请你帮我看一下我的项目，始终都是出现错误，走的一直是error.jsp页面

对于多维数组转置有点不理解,我看资料上说多维数组转置就是将数据维度顺序反过来,比如:

a=np.arange(0,120).reshape(2,3,4,5)
print('数组维度:',a.shape) 
print('转置数组维度:',a.transpose().shape)

运行结果:

但是资料上示例:

aaa=np.arange(1,37).reshape(1,3,3,4)
print(aaa.shape)
print(np.transpose(aaa,[1,2,3,0]).shape)

运行结果:

这里不明白是什么意思?   参数[1,2,3,0]是指的什么?

老师，代码这样写是什么意思？对前端的账户和密码在数据库中查询，应该是获取结果集，在结果集中，进行遍历，看哪一个与账户和密码匹配。