为什么synchronized加到run方法上就没有用？

不知道哪里问题，显示我要转换成布尔表达式

package com.baizhan.test;

public class MyDoubleLinkedList <E>implements MyList<E> {
    class Node<E>{
        E item;
        Node<E> prev; //记录前一个节点对象
        Node<E> next; //记录下一个节点对象

        public Node(E item, Node<E> prev, Node<E> next) {
            this.item = item;
            this.prev = prev;
            this.next = next;
        }
    }
    private Node head;
    private Node tail;
    private int size;
    @Override
    public void add(E element) {
        linkLast(element);
    }
  private void linkLast(E element){
        Node t=this.tail;  //获取尾节点
        Node<E> node=new Node<>(element,t,null);   //创建节点
      //将新节点定义为尾节点
        this.tail=node;
        if(t==null){
            this.head=node;
        }else{
            t.next=node;
        }
        size++;
  }
    @Override
    public E get(int index) {
        chickIndex(index);
        Node<E> node =getNode(index);
        return node.item;
    }
private void chickIndex(int index){
    if (!(index>0 && index<size)) {
        throw new IndexOutOfBoundsException("Index:"+index+"size:"+size);
    }
}
private Node getNode(int index){
        if(index<(this.size >>1)){
            Node node=this.head;
            for(int i=0;i<index;i++){
                node=node.next;
            }
            return node;
        }else{
            Node node=tail;
            for(int i=size-1;i>index;i--){
                node=node.prev;
            }
            return  node;
        }
}
    @Override
    public int size() {
        return size;
    }

    @Override
    public E remove(int index) {
        chickIndex(index);
        Node<E> node =getNode(index);
        E item=node.item;
        if(node.prev==null){
            this.head=node.next;
        }else{
            node.prev.next=node.next;
        }
        if(node.next==null){
            tail=node.prev;
        }
        else {
            node.next.prev=node.prev;
        }
        node.prev=null;
        node.item=null;
        node.next=null;
        
        size--;
        return item;

    }

    public static void main(String[] args) {
        MyDoubleLinkedList<String > m=new MyDoubleLinkedList<>();
        m.add("74");
        m.add("11");
        m.add("215");
        m.add("237");
        m.add("lierqing");
        m.add("127");
        System.out.println(m.size);
        System.out.println(m.size());
        System.out.println(m.remove(0));
        System.out.println(m.size);
        for(int i=0;i<m.size;i++){
            System.out.println(m.get(i));
        }
    }


}

老师，最后为啥会出现异常啊，我找了半天没看明白

请求老师帮我解释一下，这个return  null是什么意思？ 和上面的return servlet比较，什么情况下执行return servlet, 什么情况下执行 return null

子类FlyCar调用父类SupeprCar的move方法失败，无法打印出“在陆地上行驶的汽车”

源码：

public class Test{
    public static void main(String[] args) {
        CarFunction newCar = new Car();
        //newCar.move();
        FlyCar flyCar = new FlyCar(newCar);
        flyCar.fly();
    }
}

//定义接口
interface CarFunction{
    void move();    //抽象方法：移动方式
}

//具体的构建角色Car类
class Car implements CarFunction{
    public void move(){
        System.out.println("在陆上行驶的汽车");
    }
}

//装饰器角色
class SuperCar implements CarFunction{
    private CarFunction newCar;
    SuperCar(CarFunction newCar){
        this.newCar = newCar;
    }

    @Override
    public void move() {
        newCar.move();      //调用真实角色的行驶的方法
    }
}

class FlyCar extends SuperCar{
    public FlyCar(CarFunction newCar){
        super(newCar);
    }

    @Override
    public void move() {
        super.move();        //调用父类的行驶方法
        this.fly();
    }

    public void fly(){
        System.out.println("拥有飞行功能的汽车");
    }
}

运行结果：

try {
    //创建字节输入流对象
    fis = new FileInputStream("d:/a.txt");
    int s1 = fis.read();    //打印输入字符a对应的ascii码值97
    int s2 = fis.read();    //打印输入字符b对应的ascii码值98
    int s3 = fis.read();    //打印输入字符c对应的ascii码值99
    int s4 = fis.read();    //由于文件内容已经读取完毕，则返回-1
    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s3);
    System.out.println(s4);
} catch (Exception e) {
        e.printStackTrace();

try{

}catch(){

}这个是什么意思？

 e.printStackTrace();

这个语句是什么意思？

这个阶段的课程啥时候能更新下，这个学习效果实在是不好。谢谢

老师 写代码：在什么情况下 选用字节  流什么情况下选用字符流呢。   

老师，这里  Thread.sleep(300);    这为什么要调用这个方法，起到什么作用呢。

package Thread11;

public class Customer implements Runnable {
    private Goods goods;
    public Customer(Goods goods){
        this.goods=goods;
    }

    @Override
    public void run() {
        for (int i=0;i<10;i++){
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("---消费者取走了"+goods.getBrand()+"----"+goods.getName());
        }
    }
}

我不是很理解啊，为啥在synchronize（）的括号里面加一个字符串就能让程序串行了？那两个对象是怎么就和这个字符串连在一起的啊

老师，为什么只用关闭DataOutputStream，而不用关闭BufferOutputStream和FileOutputStream？

老师，我输出的v，但是结果是这样，我不是很明白

视频里为xml引入schema的时候那个语句是复制哪里的，如果是通过复制book.xsd中的，为什么要加-instance，

xsi:noNamespaceSchemaLocation="{book.xsd}"又有什么用呢

老师，怎么我不能拷贝进来

老师这里创建迭代器对象不是很明白