可变参数能讲下么    

<>里面应该是放泛型吧 Map.Entry<String,String>也是属于泛型的一种吗？

请问老师，红线圈出来这两个地方为什么要用value啊，是因为其不是数组吗

这里的level是什么意思啊，为什么要传进去0啊

我这里显示false，但是我在d盘里面找到了这三个目录

假如聊天结束，主线程里的 socket不需要关闭吗 

创建对象的时候用泛型确定了数据类型，是不是这个类里面的所有数据成员都变成了这个数据类型？

我for循环打出来的“-”会自动换行，前面试过加制表符但是没用好像

import java.io.IOException;

public class TestStopThread implements Runnable{
    //生死牌 true：生；false：死
    private boolean flag = true;
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        int i = 0;
        while(this.flag){
            System.out.println(Thread.currentThread().getName()+" "+i++);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程结束");
    }

    //控制生死牌内容的方法
    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        System.out.println("主线程开始");
        TestStopThread tst = new TestStopThread();
        Thread t = new Thread(tst);
        t.start();
        try{
            System.in.read();
        }catch (IOException e){
            e.printStackTrace();
        }
        tst.stop();
        System.out.println("主线程结束");
    }
}

为什么“主程序开始”和“主程序结束”都不打印？

为什么for增强循环可以直接访问Person的私有属性？

for(Person person:this.list){
    if(age.equals(person.getAge())){
        System.out.println(person.toString());
        flag = false;
    }

}

package actualPractice.Practices;

public class MyInteger01 {
    private final int value;

    public MyInteger01(int value){
        this.value=value;
    }

    public static MyInteger01 valueOf(int value){
        return new MyInteger01(value);
    }

    public int intValue(){
        return value;
    }

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

    public static void main(String[] args) {
        MyInteger01 m=MyInteger01.valueOf(100);
        int n=m.intValue();
        System.out.println(m+"\n"+n);
    }
}

老师，请问为什么重写toString就显示100，不重写toString就显示地址呀？这里面没有用到toString呀？

跟老师的代码一模一样，但是我运行之后我客户端向服务端发送消息，服务端没有显示。服务端向客户端发消息，客户端也没有显示。

//测试生产者消费者模式，创建缓冲区
//创建生产者与消费者线程
//定义馒头类
class ManTou{
    private int id;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

//定义缓冲区
class SyncStack{ //就是一个存放数据的地方，不需要实现Runnable接口也不需要继承Thread
    //定义存放馒头的盒子
    private ManTou[] mt = new ManTou[10];

    //定义操纵盒子的索引
    private int index;//默认为0

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

    //取馒头
    public  synchronized ManTou pop() {
        while (this.index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //该方法必须要在synchronized块中调用。会唤醒处于等待状态队列当中的一个线程
        this.notify();//唤醒生产馒头的线程
        this.index--;
        return this.mt[this.index];
    }
}

//定义生产者线程类
class Producer extends Thread{
    private SyncStack ss;
    public Producer(SyncStack ss){
        this.ss = ss;
    }

    @Override
    public void run() {
        for(int i=0;i<10;i++){
            ManTou mt = new ManTou();
            mt.setId(i);
            System.out.println("生产馒头："+mt.getId());
            this.ss.push(mt);//调用push方法把馒头放到定义好的缓冲区（数组）里
        }
    }
}

//定义消费者线程
class Consumer extends Thread{
    private SyncStack ss;//和生产者是同一个缓冲区
    public Consumer(SyncStack ss){
        this.ss = ss;
    }
    @Override
    public void run() {
        for(int i=0;i<10;i++){
            ManTou mt = this.ss.pop();
            System.out.println("消费馒头："+mt.getId());
        }
    }
}

public class TestProduceThread {
    public static void main(String[] args) {
        //创建缓冲区
        SyncStack ss = new SyncStack();
        //创建生产者线程
        new Producer(ss).start();
        //创建消费者线程
        new Consumer(ss).start();
    }
}

为什么我的结果每一次都是生产者生产完再是消费者消费？这难道不是一个并发的过程吗？应该我生产了就提醒消费者取了呀，但是消费者等生产完才取的

为什么this.index--一定要放在上面，放在下面或写成return 

this.mt[this.index--];就会空指针报错？

this.mt[this.index]

怎么用让步实现computer在coding前面？