老师，在此处是不是必须选择一个模板才行呀？假如我选择了一个web模板，但是在pom文件中将父工程设置位pom类型，这样搭建的父工程与一开始没有模板的工程有什么区别呢？

老师问下用伪对象方式为什么不能清除浮动

老师，请问我没有使用tomcat插件，使用的是本地的tomcat。这样是不是就没有jar包冲突呀。我只引入了jsp和servlet jar包，使用本地tomcat没有报错。

为什么这个结果不带下划线？

score = int(input("请输入分数"))

grade = ''

if(score<60):

    grade = "不及格"

if(60<=score<80):

    grade = "及格"

if(80<=score<90):

    grade = "良好"

if(90<=score<=100):

    grade = "优秀"

print("分数是{0},等级是{1}".format(score,grade))为什么要打印：("分数是{0},等级是{1}".format(score,grade))，print这里为什么要用中括号来括起1和0

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

老师 这注入的是security内部的吗

老师，不太懂为啥还得在通用模块那里写一下BrandService接口？然后再在商品模块那里实现？

 def __init__(self, master=None):

    super().__init__(master)

    self.master = master

    self.pack()

    self.createWidget()
 ...
  app = Application(master=root)

构造函数中传入的参数master的值是root，那self.mater=mater的mater的值是什么，调用父类构造函数时传入的master的值又是什么，没看太懂。

老师 我的ping mysql也报错

已解决，找不到追问的地方，在这里回答

老师为什么我两个模块不能一起运行，总是说另一个占据了端口

//测试生产者消费者模式，创建缓冲区
//创建生产者与消费者线程
//定义馒头类
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();
    }
}

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

最后的居中问题，是不是可以理解为让子元素脱离文档流，无视了border带来的影响，他眼里只有自己的父元素哈哈哈

类名.类方法

对象名.类方法都可以用来调用方法吗