老师，为啥运行了几次之后会出现先消费馒头啊/** * 消费者与生产者 */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）

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

老师，使用 new 关键字新建 Student 类的对象 student，和获取 Class 对象，然后调用 newInstance() 方法新建对象 students 有啥区别？应该都算是调用 Student 类的无参构造器新建对象吧。

public class ReflectionPerformanceTest01 {

    public static void main(String[] args) throws Exception {
        // Reflection
        // obtain Class object
        Student student = new Student();
        Class classObject01 = student.getClass();

        Class classObject02 = Student.class;

        Class classObject03 = Class.forName("com.bjsxt.demo.Student");

        // test students is equal student？是不是都是算是调用无参构造器创建对象？
        // 此外，使用这两种方式创建的对象调用方法，很明显一个使用了反射，一个没有使用反射，所以效率会有明显的差距。
        Student students =(Student) classObject03.newInstance();

        long reflectionStart = System.currentTimeMillis();
        Method method = classObject03.getMethod("setName", String.class);

        final int cycle = 10000000;
        for ( int i = 0; i < cycle; ++i) {
            // method.invoke(student,"John");   // new 关键字新建对象 student
            method.invoke(students,"John");   // Class 对象调用 newInstance() 方法获取对象
        }
        long reflectionEnd = System.currentTimeMillis();
        System.out.println(reflectionEnd - reflectionStart);
        System.out.println("----------------");

        // non reflection
        long start = System.currentTimeMillis();
        for (int i = 0; i < cycle; ++i) {
            student.setName("Marry");
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

User 类：

public class User {

    private String userName;
    private int userAge;
    public String location;

    public User() {
    }

    public User(String userName, int userAge, String location) {
        this.userName = userName;
        this.userAge = userAge;
        this.location = location;
    }

    // private modifier
    private User(int userAge) {
        this.userAge = userAge;
    }

     /*only the name is different, can not constitute an overload,
     so it can not add the constructor that only have a location parameter.*/
    public  User(String userName) {
        this.userName = userName;
    }

    public User(String userName, String location) {
        this.userName = userName;
        this.location = location;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getUserAge() {
        return userAge;
    }

    public void setUserAge(int userAge) {
        this.userAge = userAge;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public void testMethod () {
        System.out.println("hello！");
    }

    private void testWay () {
        System.out.println("overload");
    }

    public void testWay (int id) {
        System.out.println(id);
    }

    @Override
    public String toString() {
        /* Considering code writing from the bottom level, in order to cope with different functional requirements */
        return "User{" +
                "userName='" + this.getUserName()+ '\'' +
                ", userAge=" + this.getUserAge()+
                ", location='" + this.getLocation() + '\'' +
                '}';
    }
}

通过反射调用方法测试类：

public class GetMethodTest02 {

    public static void main(String[] args) {
        User user01 = new User();
        Class classObject01 = user01.getClass();

        Class classObject02 = User.class;

        Class classObject03 = null;
        try {
            classObject03 = Class.forName("com.bjsxt.demo.User");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        /* call the public method */
        Method method01 = null;
        try {
            method01 = classObject03.getDeclaredMethod("testWay",int.class);   // get designed method object.
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        Object user02 = null;
        try {
            user02 = classObject03.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        try {
            method01.invoke(user02,3);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        // how call the private method?

    }
}

老师，在调用方法的测试类中，如何调用自定义的用 private 修饰的 testWay() 方法？还是说通过反射只能调用类的 public 方法，不能调用 pirvate 的方法.