在反射中实例化对象后，为什么不能直接使用对象.方法名的方式调用方法？这里和之前直接创建类的对象后调用方法有什么区别？

请问老师，key.hashCode()这里的意思就是取哈希值的低16位，那为什么视频里老师在对key.hashCode和h>>>16时做异或运算时，key.hashCode()不是把十六位之前的数字看做0？

class ManTou {
    private int id;

    public ManTou(int id) {
        this.id = id;
    }

    public int getId() {
        return this.id;
    }
}

/**
 * 定义缓冲区类
 */
class SyncStack {
    //定义存放馒头的盒子
    private ManTou[] manTous = new ManTou[10];
    //定义操作盒子的索引
    private int index;

    /**
     * 放馒头的方法
     */

    public synchronized void put(ManTou manTou) {
        //判断盒子是否已满
        while (this.index == this.manTous.length) {
            try {
                this.wait();    //wait()必须在synchronized块中调用  wait()执行后 线程会将持有的对象锁释放 并进入阻塞状态 其他需要该对象锁的线程就可以继续运行了
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //唤醒取馒头的线程
        this.notify();      //该方法必须在synchronized块中调用 会唤醒处于等待状态队列中的一个线程
        this.manTous[this.index] = manTou;
        this.index++;
    }

    /**
     * 取馒头的方法
     */
    public synchronized ManTou get() {
        //判断盒子是否已空
        while (this.index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        this.index--;
        return this.manTous[this.index];
    }
}

/**
 * 定义生产者线程类
 */
class ShengChan extends Thread {
    private SyncStack syncStack;

    public ShengChan(SyncStack syncStack) {
        this.syncStack = syncStack;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            ManTou manTou = new ManTou(i);
            syncStack.put(manTou);
            System.out.println("生产第"+(i+1)+"个馒头");
        }
    }
}

/**
 * 定义消费者线程类
 */
class Xiaofei extends Thread {
    private SyncStack syncStack;

    public Xiaofei(SyncStack syncStack) {
        this.syncStack = syncStack;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            ManTou manTou = this.syncStack.get();
            System.out.println("消费了" + (i+1) + "个馒头");

        }
    }
}

public class ProduceThread {
    public static void main(String[] args) {
        SyncStack syncStack = new SyncStack();
        new ShengChan(syncStack).start();
        new Xiaofei(syncStack).start();
    }
}

老师为什么我这里会出现先消费的现象啊？ 

这里使用的输入输出流，是否可以换成别的？在示例代码中使用BufferedReader和PrintWriter，是有什么优势吗？

SimpleDateFormat df3 = new SimpleDateFormat("今年第w周，第M月，第D天。M月的第W周，第d天，F，E");
System.out.println(df3.format(new Date()));

运行结果：

今年第27周，第6月，第179天。6月的第5周，第28天，4，周一

老师，F是指月份中的星期 这里返回4。是指今天是本月第4个周一的意思吗？

都是对同一个对象操作，为什么在转化回去之后结果不一样了呢？

/**
 * 删除指定纪录
 */
public void deleteOperation() {
    TelNoteRegex telNoteRegex = new TelNoteRegex();
    if (this.list.size() == 0) {
        System.out.println("没有任何记录");
    } else {
        System.out.println("请输入记录的序号");
        int itemNum = telNoteRegex.menuItemValidate(1, this.list.size());
        this.list.remove(itemNum - 1);
        //重新为记录设置新的序号
        for (int i = 0; i < this.list.size(); i++) {
            (this.list.get(i)).setId(i + 1);
        }
        System.out.println("删除成功！请继续操作！");
    }
}

老师我把记录删除完后，再次进入删除界面会无法操作，和正常退出，可不可以像上面这样加上一个判断语句判读list中是否有数据。

Operate {
    List<Person> TelNoteRegex = TelNoteRegex()() {
        .= ArrayList<>()}

() {
    Menu menu = Menu()() {
        menu.searchMenu()item = ..menuItemValidate()(item) {
            :
                .searchByName(item):
                .searchByAge(item):
                .searchBySex(item):
                .searchByTelNum(item):
                .searchByAdd(item):
                .showAll():
                }
    }
}

() {
    (..size() == ) {
        System..println()}
    (i = i < .size()i++) {
        System..println(.get(i))}
}

(itemString str) {
    flag = (Person i : .) {
        (item == ) {
            (str.equals(i.getName())) {
                System..println(i)flag = }
        }
        (item == ) {
            (str.equals(i.getAge())) {
                System..println(i)flag = }
        }
        (item == ) {
            (str.equalsIgnoreCase(i.getSex())) {
                System..println(i)flag = }
        }
        (item == ) {
            (str.equals(i.getTelNum())) {
                System..println(i)flag = }
        }
        (item == ) {
            (str.equals(i.getAddress())) {
                System..println(i)flag = }
        }
    }
    (flag) {
        System..println()}
}

(item) {
    String name = ..nameValidate().cx(itemname)}

(item) {
    String age = ..ageValidate().cx(itemage)}

(item) {
    String sex = ..sexValidate().cx(itemsex)}

(item) {
    String telNum = ..telNumValidate().cx(itemtelNum)}

(item) {
    String address = ..addressValidate().cx(itemaddress)}

}

 老师，可以将TelNoteRegex在Operate类 直接实例化吗？

这样优化可以吗？

老师，这个代码直接return 的情况下，出现重名的时候，查询到第一个人的时候，就直接返回结果了，不会打印全部重名的记录吧？

关于linkBefore方法中，

Node<E> succ 为什么是33我不太懂，

根据Node<E> node(int index) 方法，返回了33我明白，但是这里的succ是怎么来的我不懂，这里不是应该用

void linkBefore(E e, Node<E> node(int index)) 才能调用上一个方法的返回值吗？

为什么用一个之前也没有声明的变量succ就可以储存上一个方法的返回值33？

Integer e1 = 4000; // e1 = Integer.valueOf(4000);
Integer e2 = 4000; // e2 = Integer.valueOf(4000);
int e3 = e2; // e3 = e2.intValueOf();
System.out.println(e1 == e2); // false  两个不同的对象 
System.out.println(e1 == e3); // true   

public int intValue() {
    return value;
}

老师这里的e1 == e3 为什么返回true？ 他们一个是对象，一个是基本数据类型呀，是因为他们都指向常量池里4000？

老师这个文件是在哪一步被创建了，我的理解是在对象里创建成功了，第二步就是个判断有没有这个文件的。

老师，我这里定义范围为一就会出现下标，提示

public class MyInteger {
    private int value;
    private static MyInteger[] cache = new MyInteger[256];

    public static final int LOW = -128;
    public static final int HIGH = 127;


    static {
        //[-128,127]
        for(int i=MyInteger.LOW;i<=HIGH;i++){
            //-128,0;-127,1;-126,2;
            cache[i+128] = new MyInteger(i);
        }
    }

    public static MyInteger valueOf(int i) {
        if(i>=LOW&&i<=HIGH) {
            return cache[i+128];
        }
        return new MyInteger(i);
    }

    @Override
    public String toString() {
        return this.value+"";
    }

    private MyInteger(int i) {
        this.value = i;
    }

    public static void main(String[] args) {
        MyInteger m = MyInteger.valueOf(30);
        System.out.println(m);

    }
}

主方法直接调用的valueof方法，之后返回一个cache[i+128]对应的值，但是这个cache数组也没有赋值，他的值是哪来的？static方法是怎么执行到的？主方法里也没有调用，整个程序执行流程是什么顺序？麻烦老师了

老师请问在mac的系统下如何生成对应的bat文件？我现在只能手动在terminal里面输入：

java -jar myjarfile.jar

来启动文件。有没有更容易的方法呢？