老师，对象的封装这个知识点我们学过吗？学过的我忘了，前面哪个知识点有，可以给下连接吗

package com.bjsxt.test3;

/**
 * 基于双向链表实现元素存取的容器
 * @param <E>
 */
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;//记录元素个数
    /**
     *向双向链表中添加元素
     * @param element
     */
    @Override
    public void add(E element) {

        this.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{
            this.tail=node;
        }
        this.size++;

    }

    /**
     * 根据指定位置获取元素
     * @param index
     * @return
     */
    @Override
    public E get(int index) {
        //对index做合法性校验
        this.checkIndex(index);
        //根据位置查找节点对象
        Node<E> node=this.getNode(index);
        //将该节点的元素返回
        return node.item;
    }

    //校验index的合法性
    private void checkIndex(int index){
        if(!(index>=0&&index<this.size)){
            throw new IndexOutOfBoundsException("index:"+index+"size:"+this.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=this.tail;
            for(int i=this.size-1;i>index;i--){
                node=node.prev;
            }
            return node;
        }

    }
    /**
     * 返回元素的个数
     * @return
     */
    @Override
    public int size() {
        return this.size;
    }

    /**
     * 根据指定位置删除元素
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        //对index进行合法性校验
        this.checkIndex(index);
        //根据指定位置获取节点对象
        Node<E> node=this.getNode(index);
        //获取节点对象中的元素
        E item=node.item;
        //判断当前节点是否为头节点
        if(node.prev==null){
            this.head=node.next;
        }else{
            //完成当前节点的直接前驱节点和当前节点的直接后继节点的挂接
            node.prev.next=node.next;
        }
        //判断当前节点是否为尾节点
        if(node.next==null){
            this.tail=node.prev;
        }else{
            //完成当前节点的直接后继节点和当前节点的直接前驱节点的挂接
            node.next.prev=node.prev;
        }
        //当前节点断掉与它直接前驱节点的连接
        node.prev=null;
        //当前节点断掉与它直接后继节点的连接
        node.next=null;
        node.item=null;
        //记录元素个数
        this.size--;
        return item;
    }

    public static void main(String[] args) {
        MyList<String> myList=new MyDoubleLinkedList<>();
        myList.add("a");
        myList.add("b");
        myList.add("c");
        myList.add("d");
        System.out.println(myList.remove(0));
        System.out.println(myList.size());
        for(int i=0;i<myList.size();i++){
            System.out.println(myList.get(i));
        }
    }
}

老师 我看了半天也没看出哪里错了 62行和144行都没有问题呀 为啥会报空指针异常

老师您好：

    List<String> a2 = new ArrayList<>(); 
    a2.add("a"); 
    a2.add("b"); 
    a2.add("c"); 
    List<String> b2 = new ArrayList<>();
     b2.add("b"); 
     b2.add("c"); 
     b2.add("d"); 
     boolean flag8 = a2.removeAll(b2); 
     System.out.println(flag8); 
     for(String str :a2){ 
         System.out.println(str); 
         }

运行结果为什么没有d啊？

老师 我输的为什么是这个呢

 //创建 对象
InetSocketAddress tse=new InetSocketAddress("localhost",9999);
 InetAddress  inetAddress=InetAddress.getByName("localhost");
 InetSocketAddress inetSocketAddress=new InetSocketAddress(inetAddress,9999);
System.out.println("主机名称"+inetAddress.getHostName());
System.out.println("获取主机IP地址："+inetAddress.getAddress());

定义MyInteger包装类的valueOf()方法,有参方法;
    public  static MyInteger valueOf(int i)

是这个意思不?

老师这里的   localhost     是必须用着名字吗？还 可以自己去取名字

InetSocketAddress tse=new InetSocketAddress("localhost",9999);

问题：

老师，为什么我DOM4J获取属性值获取不到？

源码：

import com.sun.xml.internal.bind.v2.runtime.output.NamespaceContextImpl;
import jdk.internal.org.objectweb.asm.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.Iterator;

public class TestDOM4J {
    public static void main(String[] args) throws DocumentException {
        //1、创建SAXreader对象
        SAXReader sr = new SAXReader();
        //2、调用read方法
        Document doc = sr.read(new File("D:\\UdpPrcoject2\\src\\book.xml"));
        //3、获取根节点
        Element root = doc.getRootElement();
        //4、通过迭代器遍历直接节点
        for (Iterator<Element> iteBook = root.elementIterator();iteBook.hasNext();){
            Element bookEle =  iteBook.next();
            for (Iterator<Attribute> iteAtt=bookEle.attributeIterator();iteAtt.hasNext();){
                Attribute att = iteAtt.next();
                System.out.println(att.getName()+"\t"+att.getText());
            }
        }
    }
}

问题截图：

端口号最多6.5w个，如果一个一个电脑上的应用程序太多，怎么办呀。是相同的应用程序比如qq，在不同的电脑上，端口号不同。还是只要是qq，在所有电脑上端口号都一样。

老师，Class对象也是跟一般对象一样存储在堆里吗？

用同一个类实例的多个对象，调用.class 来进行判断 == 的时候为什么能判断出true？

Class对象的内存分析也是跟普通的类的对象一样吗？

（如：课时65：程序执行过程内存分析详解）

这个老师讲的东西，理解起来真的费劲，没有概括，挺完一边还要重复听几遍才能理解。而且一直快捷键操作来操作区，她慢一点没事吧，这么着急干嘛？讲的真的垃圾，还一直有回声。

老师，这里  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());
        }
    }
}

老师：   这段代码是什么意思，完全听不懂。为什么要把类定义为 Goods的属性呢。

      这个 producter  方法又是做什么用呢。

public class producter implements Runnable{
   private Goods goods;
   public producter(Goods goods){
       this.goods=goods;
   }
    @Override
    public void run() {

    }
}

这两种前者调用方法，后者实例化。我看主线程一般都不需要实例化，可以直接调用currentThread（）这个方法，而普通线程都需要实例化。

但是两者都能都用getPriority（）。这是为什么。我看这个Demo中，没有在写run（）重写方法。

还有这个老师讲课能不能慢一点，声音听不清，像赶路一样，完全不注重讲课节奏。

package com.bjsxt.Method;

public class TestThreadMethod {
    //主方法，主线程
    public static void main(String[] args) {
        Thread t = Thread.currentThread();      //得到一个当前正在运行的线程对象 main
        //to.String()方法得到的内容为[线程名称，线程的优先级，线程组的名称]
        System.out.println(t);// t.toString()

        //线程类的对象
        MyRunnable my = new MyRunnable();
        Thread t1 = new Thread(my);
        Thread t2 = new Thread(my);
        Thread t3 = new Thread(my);

        //启动线程
        t1.start();
        t2.start();
        t3.start();
        /*在Thread类中一定有一个静态变量int，来统计线程的个数*/
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        Thread t = Thread.currentThread();
        System.out.println(t);
    }
}

老师，就是如下图while死循环中 server.accept()方法返回的Socket是建立一次后是一直保持连接状态吗？

假如一个客户端连接成功后发送多次消息的时候是直接通过之前获取的Socket对象的输入流来获取数据吗？不会再重新执行server.accept()重新获得Socket对象再获取输入流获取数据是吗？