我的代码一直在跑，完全没有阻塞效果，跑了几千都还在跑

老师不好意思，我提问的乱码了，不会撤回，这种现象正常吗

老师，为啥运行了几次之后会出现先消费馒头啊/** * 消费者与生产者 */package com.company;/** * 定义一个馒头类 */class ManTou{ private int Id; public ManTou(int Id){ this.Id=Id; } public int getId() { return Id; }}/** * 定义缓冲区 */class SyncStack{ //定义存放盒子的馒头 private ManTou[] mt =new ManTou[10]; //定义操作盒子的索引 private int index; /** * 放馒头 */ public synchronized void push(ManTou manTou){ //判断盒子是否已满 while (this.index==this.mt.length) try { /** * 语法：wait();该方法必须要在synchronized块中调用。 * wait();执行后，会将持有的对象锁释放，并进入阻塞状态。 * 其他需要该对象锁的线程就可以继续运行了。 */ this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } //唤醒取馒头的线程 /** * 语法：必须要在synchronized块中调用。 * 该方法会唤醒等待状态队列中的一个线程。 */ this.notify(); this.mt[this.index]=manTou; this.index++; } /** * 取馒头 * @return */ public synchronized ManTou pop(){ while (this.index==0){ try { /** * 语法：wait();该方法必须要在synchronized块中调用。 * wait();执行后，会将持有的对象锁释放，并进入阻塞状态。 * 其他需要该对象锁的线程就可以继续运行了。 */ this.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } /** * 语法：必须要在synchronized块中调用。 * 该方法会唤醒等待状态队列中的一个线程。 */ this.notify(); this.index--; return this.mt[this.index]; }}/** * 生产者线程 */class Shengchan extends Thread{ private SyncStack ss; public Shengchan(SyncStack ss){ this.ss=ss; } @Override public void run() { for (int i=0;i<10;i++){ System.out.println("生产馒头:"+i); ManTou manTou=new ManTou(i); this.ss.push(manTou); } }}/** * 消费者线程 */class xiaofei extends Thread{ private SyncStack ss; public xiaofei(SyncStack ss){ this.ss=ss; } @Override public void run() { for (int i=0;i<10;i++){ System.out.println("消费馒头:"+i); } }}public class ProduceThread { public static void main(String[] args) { SyncStack ss=new SyncStack(); new Shengchan(ss).start(); new xiaofei(ss).start(); }}

老师 可以直接将”obj“这个对象理解为在反射机制下就是通过它作为桥梁为“userage”赋一个18的值吗？其实最后这个“Object”对象去实例化新的对象有点类似于泛型的意思

String[] stringArray = list.toArray(new String[list.size()]);for (String sb : stringArray) { System.out.println(sb);}老师，为何 new String 后面是跟中括号？

老师，类 showFlag 方法中的形参，第一个Generic 指类名，那第二个形参 generic 是什么含义？要求调用该方法需要传进来一个 Generic 类型的对象嘛？

public class Generic<T> {

    private T flag;

    public T getFlag() {
        return this.flag;
    }

    public void setFlag(T flag) {
        this.flag = flag;
    }

    public static void main(String[] args) {

        showMsg showMsg = new showMsg();
        Generic<Integer> generic01 = new Generic<Integer>();
        generic01.setFlag(20);
        showMsg.showFlag(generic01);

        Generic<Number> generic02 = new Generic<>();
        generic02.setFlag(90);
        showMsg.showFlag(generic02);

        Generic<String> generic03 = new Generic<String>();
        generic03.setFlag("admin");
        showMsg.showFlag(generic03);
    }
}

class showMsg {

    public void showFlag (Generic<?> generic) {
        System.out.println(generic.getFlag());
    }
}

老师，下面两个 new 语句中，第一行右边的 GenericClass<String>()，第二行右边仅是 GenericClass<>()。这两种写法有啥区别嘛？

public class GenericClass<T> {

    private T flag;

    public T getFlag() {
        return flag;
    }

    public void setFlag(T flag) {
        this.flag = flag;
    }

    public static void main(String[] args) {

        GenericClass<String> generic01 = new GenericClass<String>();
        GenericClass<String> generic02 = new GenericClass<>();   // 这两种写法有啥区别？

        generic01.setFlag("admin");
        String flag = generic01.getFlag();
        System.out.println(flag);


        GenericClass<Integer> generic03 = new GenericClass<>();
        generic03.setFlag(100);
        Integer num = generic03.getFlag();
        System.out.println(num);
    }
}

这块我还是不太明白，比如说左子树不为空时，执行这行代码进行递归

this.left.inorderTraverasl();

当左子树为空时，是不是应该执行这行代码进行输出

System.out.println(this.item);

后续判断右子树不为空时，继续执行这行代码继续进行递归

this.right.inorderTraverasl();

但是为什么右子树后面就不用添加这行代码进行输出了呢，而是直接在左子树的输出代码进行打印

System.out.println(this.item);

代码正常运行，就是服务端没有实现long类型数据的传递

定义了一个Message泛型类，默认泛型类型为Object，但不等同于Message<Object>。

是如果定义为Message<String>,两者就不是相同类型的对象，可以这样理解吗？

老师，你说的这个模是不是固定数值呢，我随机产生1-100的随机数，但是输出结果还是按照1-100的顺序排列，安妮您说的模是16的话。超过16的随机数按道理应该不会按顺序排列才对，这里我有点搞不懂。

一，老师 打印出来的结果为啥有点不一样啊？？？？？、

package com.bjsxt;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class HashMapTest {
    public static void main(String[] args) {
        //实例化HashMap
        Map<String,String> map=new HashMap<>();
        //添加元素
         map.put("a", "A");
        String str = map.put("a", "B");
        System.out.println(str);
        System.out.println("---------------------");
        String value = map.get("a");
        System.out.println(value);

        //添加元素
        System.out.println("-------------------");
        map.put("b","B");
        map.put("c","C");
        map.put("d","D");
        map.put("e","E");
        Set<String> keys = map.keySet();
        for (String key1:keys){
            String str1 = map.get(key1);
            System.out.println(keys+"------"+str1);
        }
    }
}

老师点对点的聊天设计里面可不可以添加输入exit退出的功能，我好像在视频里没看见有这个功能

然后我自己添加一个判断exit字符的跳出循环，每次都报错。

老师你好

请问：Methods methods =getMethods(setusername,int.class);

getMethods()的第二的参数是返回指定方法所需的参数，我的理解是int，String或是Object等，请问这个int.class是啥意思

package com.bjsxt.socket;

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

/**
 * 发送信息线程
 */
class ClientSend extends Thread{
    private Socket socket;
    ClientSend(Socket socket){
        this.socket = socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 发送消息
     */
    private void sendMsg(){
        Scanner scanner = null;
        PrintWriter pw = null;
        try {
            scanner  = new Scanner(System.in);
            pw = new PrintWriter(this.socket.getOutputStream());
            String str = scanner.nextLine();
            while (true){
                if ("exit".equals(str)){
                    break;
                }
                pw.println(str);
                pw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (pw!=null){
                pw.close();
            }
            if (scanner!=null){
                scanner.close();
            }
        }

    }
}
/**
 * 接受消息线程
 */
class ClientReceive extends Thread{
    private Socket socket;
    ClientReceive(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 clientStr = br.readLine();
                if ("exit".equals(clientStr)){
                    break;
                }
                System.out.println("客户端说："+clientStr);
            }


        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (br!=null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public class ChatSocketClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1",8888);
            System.out.println("连接成功！");
            new ClientReceive(socket).start();
            new ClientSend(socket).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

老师，为啥我这里死循环了，大家都用的where（true）了呀，而且我前面的双向通信和单向都用的了where（true）

和老师写的差不多，到点对点练习就死循环了