public class StaticFieldTest {

    public static void main(String[] args) {

        Person person = new Person();
        // Class classObject01 = person.class;   // error

        Class classObject01 = Person.class;
        Class classObject02 = Person.class;

        System.out.println(classObject01);
        System.out.println(classObject02.getName());
        System.out.println(classObject01 == classObject02);
    }
}

老师，使用静态属性 class 获取 Class 对象，这个静态属性  class 到底属于哪个类下的成员变量？还有为什么使用实例化的对象调用该静态属性会报错？

环境：jdk1.8

服务端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
 
/**
 * 接受客户端消息的线程类
 */
class ChatReceive extends Thread{
    private Socket socket;
    public ChatReceive(Socket socket){
        this.socket=socket;
    }
    @Override
    public void run() {
        this.receiveMsg();
    }
    /**
     * 实现接收客户端发送的消息
     */
    private void receiveMsg(){
        BufferedReader br = null;
        try {
            br=new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            while (true){
                String msg=br.readLine();
                synchronized ("abc"){
                    //把读取到的数据写入公共数据区
                ChatRoom.buf="["+this.socket.getInetAddress()+"] "+msg;
                    //唤醒发送消息的线程对象
                    "abc".notifyAll();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (br != null) {
                try {
                    br.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
            if (this.socket != null) {
                try {
                    this.socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
/**
 * 向客户端发送消息的线程类
 */
class ChatSend extends Thread{
    private Socket socket;
    public ChatSend(Socket socket){
        this.socket=socket;
    }
 
    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 将公共数据区的消息发送给客户端
     */
    private void sendMsg(){
        PrintWriter pw = null;
        try {
            pw=new PrintWriter(this.socket.getOutputStream());
            while (true){
                synchronized ("abc"){
                    //让发送消息的线程处于等待状态
                    "abc".wait();
                    //将公共数据区中的消息发送给客户端
                    pw.println(ChatRoom.buf);
                    pw.flush();
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (pw != null) {
                pw.close();
            }
            if (this.socket != null) {
                try {
                    this.socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class ChatRoom {
    //定义公共数据区
    public static String buf;
    public static void main(String[] args) {
        System.out.println("Chat Server Version 1.0");
        System.out.println("Listen at 8888.....");
        ServerSocket serverSocket =null;
        try {
            serverSocket =new ServerSocket(8888);
            while (true){
                Socket socket=serverSocket.accept();
                System.out.println(socket.getInetAddress()+"加入聊天室");
                new ChatReceive(socket).start();
                new ChatSend(socket).start();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
 
/**
 * 用于发送消息的线程类
 */
class SendMsg extends  Thread {
    private Socket socket;
    private  Scanner scanner;
    public SendMsg(Socket socket,Scanner scanner) {
        this.socket = socket;
        this.scanner=scanner;
    }
 
    @Override
    public void run() {
        this.sendMsg();
    }
 
    /**
     *发送消息
     */
    private void sendMsg() {
        PrintWriter pr = null;
        try {
            //创建向对方输出消息的流对象
            pr = new PrintWriter(this.socket.getOutputStream());
            while (true) {
                String str = scanner.nextLine();
                pr.println(str);
                pr.flush();
 
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (pr != null) {
                pr.close();
            }
            if (scanner != null) {
                scanner.close();
            }
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
 
/**
 * 用于接收消息的线程类
 */
class ReceiveMsg extends  Thread{
    private Socket socket;
 
    public ReceiveMsg(Socket socket) {
        this.socket = socket;
 
    }
    /**
     * 用于接收对方消息的方法
     */
    private   void ReceiveMsg (){
        BufferedReader br = null;
        try {
            //创建用于接收对方发送消息的流对象
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while (true){
                String str = br.readLine();
                System.out.println("用户"+str);
 
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
 
            }try {
                if(socket!=null){
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
 
    @Override
    public void run() {
        this.ReceiveMsg();
    }
}
 
public class ChatClients {
    public static void main(String[] args) {
        System.out.println("请建立服务器或客户端");
        System.out.println("请输入：server,<port> 或者：<ip>,<port>");
        Scanner scanner = null;
        Socket socket = null;
        ServerSocket serverSocket = null;
        try{
 
            scanner = new Scanner(System.in);
            String scan = scanner.nextLine();
            String[] arr = scan.split(",");
            if("server".equals(arr[0])){
 
                serverSocket = new ServerSocket(Integer.parseInt(arr[1]));
                System.out.println("服务器监听中");
                socket = serverSocket.accept();
                System.out.println("接收成功");
 
            }else{
                socket = new Socket(arr[0],Integer.parseInt(arr[1]));
                System.out.println("连接成功");
            }
            new SendMsg(socket,scanner).start();
            new ReceiveMsg(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }
 
    }
}

客户端和服务器连接上以后，把客户端关闭就报这个错误，咋处理？

老师为什么我获取的百度服务器地址跟视频里的不同

老师，这里的

returnNoParam.method();
System..println();
System..println(returnNoParam.method());

我不是很懂你可以解释一下为什么运行结果是这个吗

老师为啥我d盘目录下的a.txt文件里有abc3个字母,实际用循环打印出来只有98和-1?

视频中由接口List的add方法切换到ArrayList中的add方法，那个快捷键是什么啊？是Ctrl+Alt吗？这个快捷键我试过了，没用！

package com.bjsxt.thread;

/**
 * 使用this作为对象锁
 * 使用字符串作为对象锁
 * 使用class对象作为对象锁
 */
/**
 * 定义销售员工类
 */
class Sale{
    private String name;
    public Sale(String name){
        this.name = name;
    }
    public void  money(){
        synchronized ("s") {
            try {
                System.out.println(this.name +
                        " 被领导表扬");
                Thread.sleep(500);
                System.out.println(this.name +
                        " 拿钱");
                Thread.sleep(500);
                System.out.println(this.name +
                        " 对公司表示感谢");
                Thread.sleep(500);
                System.out.println(this.name +
                        " 开开心心的拿钱走人");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Programmer{
    private String name;
    public Programmer(String name){
        this.name = name;
    }
    /**
     * 打开电脑
     */
    public void computer(){
        synchronized (this) {
            try {
                System.out.println(this.name + " 接通电源");
                Thread.sleep(500);
                System.out.println(this.name + " 按开机按键");
                Thread.sleep(500);
                System.out.println(this.name + " 系统启动中");
                Thread.sleep(500);
                System.out.println(this.name + " 系统启动成功");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 编码
     */
    public void  coding(){
        synchronized (this){
            try {
                System.out.println(this.name + " 双击 Idea");
                Thread.sleep(500);
                System.out.println(this.name + " Idea 启动完毕");
                Thread.sleep(500);
                System.out.println(this.name + " 开开心心的写代码");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 去卫生间
     */
    public void wc(){
        synchronized ("wc") {
            try {
                System.out.println(this.name + " 打开卫生间门");
                Thread.sleep(500);
                System.out.println(this.name + " 开始排泄");
                Thread.sleep(500);
                System.out.println(this.name + " 冲水");
                Thread.sleep(500);
                System.out.println(this.name + " 离开卫生间");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 领取奖金
     */
    public void money(){
        synchronized ("p") {
            try {
                System.out.println(this.name + " 被领导表扬");
                Thread.sleep(500);
                System.out.println(this.name + " 拿钱");
                Thread.sleep(500);
                System.out.println(this.name + " 对公司表示感谢");
                Thread.sleep(500);
                System.out.println(this.name + " 开开心心的拿钱走人");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * 打开电脑的工作线程
 */
class Working1 extends Thread{
    private Programmer p;
    public Working1(Programmer p){
        this.p = p;
    }
    @Override
    public void run() {
        this.p.computer();
    }
}

/**
 * 编写代码的工作线程
 */
class Working2 extends Thread{
    private Programmer p;
    public Working2(Programmer p){
        this.p = p;
    }
    @Override
    public void run() {
        this.p.coding();
    }
}

/**
 * 去厕所的线程
 */
class Wc extends Thread{
    private Programmer p;
    public Wc(Programmer p){
        this.p = p;
    }
    @Override
    public void run() {
        this.p.wc();
    }
}
/**
 * 销售部领取奖金的线程
 */
class SaleMoney extends Thread{
    private Sale s;
    public SaleMoney(Sale s){
        this.s = s;
    }
    @Override
    public void run() {
        this.s.money();
    }
}
/**
 * 程序员领取奖金的线程
 */
class ProgrammerMoney extends Thread{
    private Programmer p;
    public ProgrammerMoney(Programmer p){
        this.p = p;
    }
    @Override
    public void run() {
        this.p.money();
    }
}
public class ObjectLock {
    public static void main(String[] args) {
        /*Programmer zs = new Programmer("张三");
        new Working1(zs).start();
        new Working2(zs).start();*/
        /*Programmer zs = new Programmer("张三");
        Programmer ls = new Programmer("李四");
        Programmer wu = new Programmer("王五");
        new Wc(zs).start();
        new Wc(ls).start();
        new Wc(wu).start();*/
        Programmer ls = new Programmer("李四");
        Programmer wu = new Programmer("王五");
        Sale s1 = new Sale("王丽丽");
        Sale s2 = new Sale("王莉莉");
        //new ProgrammerMoney(ls).start();
        //new ProgrammerMoney(wu).start();
        new SaleMoney(s1).start();
        new SaleMoney(s2).start();
    }
}

老师，用字符串作为对象锁也可以实现各自部门的人去各自部门串行领取奖金，达到和使用class对象作为锁一样的效果。都是可以对多个线程操作多个对象进行同步。前面同学问的问题我看了，字符串可以是不同类，Class只能是同一个类。所以意思各有各的应用场景，但是有时候也能达到一样的效果。

老师，这是我总结的您看一下

this：多个线程操作同一个对象可以实现同步效果

字符串：所有线程操作到具有synchrunized(字符串)的就会实现同步效果

class对象：当多个线程操作到通过同一个类实例化的对象的时候会实现同步效果

(o1,o2) -> o1.compareTo(o2)

为什么就是升序，而不是降序？内部是怎么判断的，是根据字符对应数值的大小进行比较吗？

如果是多个字母

aabb abbb

这个的升序比较结果又是什么嗯？

关于system.out.println的讲解中，

说的System类下有一个成员变量out，下面有个方法println

这里我不懂成员变量为什么下面还可以有方法？方法不就应该咋类下面吗？

然后就是

System.out::out

对于静态方法，冒号的左边是静态方法所在的类，这里的类不应该是System吗？为什么这里是System.out作为静态方法所在的类，而不是System？

有两个问题

1）

在3.2中用declared方法获取了private成员变量，在3.3中也操作了public成员变量。

是不是就说，通过declared方法可以获取私有变量和私有方法，但是如果要操作私有变量（如修改值）和私有方法（如调用方法），则必须setAccessible？

2）对于构造方法，是不会设置为private的吗？

老师我想问一下，为什么我的这次练习找不到i呢？在打代码的时候报了一遍错。之后我就蒙了

老师，如果对方使用了Apache IO包，而我没有下载包，程序能在我的电脑上运行吗

为什么要写if（fr != null）判断后再执行fr.close，不写的话，也是会执行关闭，是会容易出现错误吗

有两个问题

1）

关于获取成员变量的值：

Object o = field.get(obj);

这里的成员变量userage是int类型的，这里是因为向上转型，所以可以使用Oject o来存储18这个int类型变量吗？

如果直接使用int类型变量来获取是否可以呢？即：

int t = field.get(obj);

2关于最后一行打印o，

因为o实际是int类型数据向上转型，我不懂这里如果要打印它，为什么不需要强制转型为int，才打印？

我理解的是，因为toString方法是Object类下的，所以可以直接打印出来，对于Object类型下的方法调用，不需要强制向下转型，也可以调用。

如果是int独有的方法，比如加减乘除，就必须强制转型成int。

不知道我理解的是否对？

看着看着，有点乱，不知道这两个方法有什么作用？请老师解答