老师 我这个点对点聊天的代码，为啥服务端给客户端能发消息，但是客户端给服务端发送消息却接受不到呢？

像图片里的这些有参方法和无参方法，是怎么构造出来的？是快捷键还是什么

如果定义有参和无参的构造方法，有什么快捷键呢？

老师，这边如果链表中只有一个元素时，是不是会报空指针异常？

老师，为何代码中类 Working1 可以 this.p，然后再调用 computer 方法。这里的 this.p 还是调用本类中的成员变量嘛？

备注：computer() 是另一个类中的方法。两个类都在同一个.java 文件中。

MyDoublyLinkedList <>MyList<>{

    Node<>{
        Node<> Node<> (itemNode<> prevNode<> next) {
            .= item.= prev.= next}
    }
    Node Node (element) {
        .LinkLast(element)}
    (element){
        Node t = .Node<> node = Node<>(elementt).= node(t==){
            .= node}{
            t.= node}
        .++}
    (index) {
        .checkIndex(index)Node<> node = .getNode(index)node.}
    (index){
        (index<||index>.-){
            IndexOutOfBoundsException()}
    }
    Node (index){

        (index<(.>>)){
            Node<> a = .(i=i<=indexi++){
                a = a.}
            a}{
            Node<> a = .(i=.-i>=indexi--){
                a = a.}
            a}
    }
    () {
        .}
    (index) {
        .checkIndex(index)Node<> node = getNode(index)item = node.(index==){
            .= node.node..= }(index==.-){
            .= node.node..= }{
            Node<> node1 = getNode(index-)Node<> node2 = getNode(index+)node1.= node2node2.= node1}
        .--item}
    (element){
        .LinkFirst(element)}
    (element){
        Node<> a = .Node<> node = Node<>(elementa).= node(a==){
            .=node}{
            a.= node}
        .++}
    (element){
       .LinkLast(element)}

    (String[] args) {

        MyDoublyLinkedList<String> myList = MyDoublyLinkedList<>()myList.add()System..println(myList.get())System..println(myList.size())}
}

客户端：

package com.bjsxt;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

public class BasicSocketServer {
    public static void main(String[] args) {
        Socket socket = null;
        BufferedReader br = null;
        try {
            ServerSocket serverSocket = new ServerSocket(8888);
            System.out.println("服务器启动监听，等待链接。。。。");
            //开启端口的监听
            socket = serverSocket.accept();
            //读取客户端发送的消息
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            System.out.println(br.readLine());
        }catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

服务器：

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

public class BasicSocketClient {
    public static void main(String[] args) {
        Socket socket = null;
        PrintWriter pw = null;
        //创建socket对象：两个参数：1.服务端的ip地址 2.服务端监听的端口
        try {
            socket = new Socket("127.0.0.1",8888);
            pw = new PrintWriter(socket.getOutputStream());
            pw.println("服务端你好");
            pw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (pw!=null){
                pw.close();
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

为何无输出

老师，运行结果的最上面一行结果是什么意思？

之前的那个女老师讲的啥玩意，一个天上一个地下，浪费好多精力

不太明白为什么放馒头和去馒头要线程同步，之前说解决的忙闲不均的问题不就代表他俩互不干扰吗，还是说要保证缓冲区有东西什么的？

视频2：00 处，有点不懂，

按照老师的意思，这里的异常不能在run（）方法中抛出去的吗？

这是为什么呢？

还是说我理解错了，这里也科通通过throw在run方法处抛出异常？

com.bjsxt;

Programmer{
    String ;
    Programmer(String name){
        .=name;
    }
    Computer(){
        () {
            {
                System..println(.+ );
                Thread.();
                System..println(.+ );
                Thread.();
                System..println(.+ );
                Thread.();
                System..println(.+ );
                Thread.();
            } (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    Coding(){
        () {
            {
                System..println(.+ );
                Thread.();
                System..println(.+ );
                Thread.();
                System..println(.+ );
                Thread.();
            } (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    toilet(){
        () {
            {
                System..println(.+ );
                Thread.();
                System..println(.+ );
                Thread.();
                System..println(.+ );
                Thread.();
                System..println(.+ );
                Thread.();
            } (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Working1 Thread{
    Programmer ;
    Working1(Programmer p){
        .=p;
    }

    run() {
        ..Computer();
    }
}

Working2 Thread{
    Programmer ;
    Working2(Programmer p){
        .=p;
    }

    run() {
        ..Coding();
    }
}

Toilet Thread{
    Programmer ;
    Toilet(Programmer p){
        .=p;
    }

    run() {
        ..toilet();
    }

}
TestSyncThread {
    main(String[] args) {
        Programmer p = Programmer();
        Programmer p1 = Programmer();
        Programmer p2 = Programmer();
        Toilet(p).start();
        Toilet(p1).start();
        Toilet(p2).start();
    }
}

输出：

JY 打开卫生间门

JY 上厕所

JY 冲水

JY 离开卫生间

xj 打开卫生间门

xj 上厕所

xj 冲水

xj 离开卫生间

SJ 打开卫生间门

SJ 上厕所

SJ 冲水

SJ 离开卫生间

这里先输出xj是为什么，还是顺序就是随机的？

//为什么关闭流的时候是判断!=null，既然是等流执行完毕后关闭，那意思肯定是当流中没有数据时关闭流，应该是==null啊，难道是为了防止空指针

老师，这节中在关闭字节数组输入流为什么，不进行

if(bis!=null)

的判断操作，而是直接关闭

老师，为什么我这个代码好奇怪，为什么我都是先生产完再消费？