老师我们怎么知道端口号是80呢？视频有说吗？

public class HelloWorld {
    public static void main(String[] args) {
		
		Integer a=100;
   		Integer b=100;

		Integer c=200;
   		Integer d=200;
		
		
		System.out.println(a == b);	//true	
		System.out.println(a == 100);    //true
		
		System.out.println(c == d);//false
		System.out.println(c == 200);//true

	}
}

为什么会出现这种结果？

System.out.println(c == d)

这个为什么a == b,c == d 的结果竟然不一样！？

关于书中3.7.9.1中的代码，

if(o1.getAge() >o2.getAge()){...}

我不懂这里为什么不能用

o1.age 和o2.age 进行比较，而必须写set和get方法？谢谢

public class TestShowMsg {

    public static void main(String[] args) {

        ShowMsg sm = new ShowMsg();
        Generic3<Integer> g = new Generic3<>();
        sm.showFlag(g); // null 这里null 是因为这时候Generic3的对象没有任何值为空
        g.setFlag(20); // 为Generic3中的flag赋值20
        sm.showFlag(g); // 20 将Generic3对象g传入
       /*
        Generic3<Number> g2 = new Generic3<>();
        sm.showFlag(g2);
        g.getFlag(50);
        sm.showFlag(g);
        这里都报错的原因是泛型只确定了你要使用的类型或者类型识别，不考虑继承关系，只看类型！！
*/

        System.out.println("=============================================");
        Generic3<Integer> g2 = new Generic3<>();
        sm.showFlag(g2); 
        g2.setFlag(30); 
        sm.showFlag(g2); 
        Generic3<Number> g3 = new Generic3<>();
        sm.showFlag2(g3); // 因为showFlag2(Generic3<?> generic3)的参数泛型是? 任意类型 所以这里不会报错
        g3.setFlag(50);
        sm.showFlag2(g3);


    }
}
class ShowMsg{
    public void showFlag(Generic3<Integer> generic3){  // 这里传入的参数是Generic3对象 泛型类型定义为Integer
        System.out.println(generic3.getFlag());
    }

    // ? 无界通配符
    public void showFlag2(Generic3<?> generic3){  // 不能确定传入的是什么类型时 泛型类型定义为? 任意类型都可以
        System.out.println(generic3.getFlag());
    }
}

class Generic3<T>{
    private T flag;

    public T getFlag() {
        return flag;
    }

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

老师，我这样理解对吗？

然后还有两个问题：

1、为什么传入参数Generic3<T> generic会报错？  我创建的泛型类是Generic3<T>，T不是表示简单的JAVA类么，

为什么传参时不可以使用？

public void showFlag(Generic3<T> generic3){  
    System.out.println(generic3.getFlag());
}

2、T是简单JAVA类 ?是任意类型 那这里用?作为传入参数的泛型，会不会出现超出T表示的范围？

public void showFlag2(Generic3<?> generic3){  
        System.out.println(generic3.getFlag());
    }

public class Test {
    public static void main(String[] args) {
        Generic2 g = new Generic2();
        g.setName("lili");
        g.setName(123);
        String name = g.getName("lili"); // 报错
        Object name1 = g.getName("lili"); // 没有报错

        Integer flag = Generic2.getFlag(222);
        Generic2.setFlag("dd");
    }
}

class Generic2<N>{

    // 非静态方法
    public<T> void setName(T name){
        System.out.println(name);
    }
    public<T> T getName(T name){
        return name;
    }

    // 静态方法
    public static <T> void setFlag(T flag){
        System.out.println(flag);
    }
    public static <T> T getFlag(T flag){
        return flag;
    }

}

报错：

java: 不兼容的类型: java.lang.Object无法转换为java.lang.String

老师，如果类和方法都定义了泛型，类是<N>，方法是<T> 

String name = g.getName("lili"); // 报错

1、为什么这句会报错，如果把String name改成Object name就不会报错。把类改成Generic2<T>，方法和类都是T，但还是报错，这是为什么？看报错的内容觉得能明白，但是想把原因写出来记笔记，又不知道该怎么写

2、静态方法的泛型和类的泛型没有关系是么？

关于实例化TreeSet

Set<String> set = new TreeSet< >

前面为什么使用Set，而不是用TreeSet,

我是否可以理解为：

因为Set接口下的TreeSet， HashSet没有自己独有的方法，所以这里用Set？

像List接口中，若使用ArrayList中独有的方法，则必须用

ArrayList<String>= New ArrayList< >?

另外，这里Set和TreeSet是否是一种继承关系，前面写TreeSet，即

TreeSet<String> set = new TreeSet<>

也不会报错？

谢谢

老师这种操作最早是在哪节课讲的，意思是把第一个实例出来的对象作为第二个的实参吗，我有点懵。能解释下流程吗

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

请问老师，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类 直接实例化吗？

这样优化可以吗？