我们定义结点的时候声明了泛型E，为什么声明指向下一个结点的引用时不使用E呢。如下

Node<E> next;

像老师这样Node next；编译器怎么知道next到底是指向什么类型的呢？

package fang.stu.sxt;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * 服务端
 *
 * */

public class UdpTest01 {
    public static void main(String[] args) {
        DatagramSocket ds=null;

        try {
            //创建，服务的的监听对象；
            ds=new DatagramSocket(9999);
            //创建缓存区；
            byte[] bt=new byte[1024];
            //创建数据报包；
            DatagramPacket dap=new DatagramPacket(bt, bt.length);
            //接收数据
            System.out.println("服务端启动，准备接收数据");
            ds.receive(dap);
            //将字节数组转换为字符串接收；
            String str=new String(dap.getData(),0, dap.getLength());
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            //关闭这个监听的对象；
            if (ds!=null){
                ds.close();
            }
        }
    }
}


package fang.stu.sxt;

import java.io.IOException;
import java.net.*;
/***
 * 
 * 客户端
 */


public class UdpClient01 {
    public static void main(String[] args) {
        DatagramSocket ds=null;

        try {
            //将数据类型转换为字节数组
            byte[] b="王八蛋".getBytes();
            //创建数据报包
            DatagramPacket dp=new DatagramPacket(b,b.length, new InetSocketAddress("192.168.44.1",9999));
            //创建客户端的监听对象
            ds=new DatagramSocket(8088);
            //开始发送数据
            System.out.println("客户端准备发送数据");
            ds.send(dp);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (ds!=null){
                ds.close();
            }
        }
    }
}

这个和老师讲的基本一样，都能运行，就是没有实现数据的发送

老师什么时候创建对象用new 什么时候不用啊？

如果在initialValue()方法内部加上Thread.sleep(500)的话，运行结果显示三个线程还是在共享着同一个连接，那不还是线程不安全吗？

运行效果图如下所示：

代码如下所示：

package com.bjsxt;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

/**
 * <b style = "font-size:15px;">用于获得与数据库的连接以及关闭连接</b>
 * @author 郑锦宗
 * @version v1.0
 */
public class DBUtil {
	private static final String DRIVER="com.mysql.jdbc.Driver";
	private static final String	USER="root";
	private static final String PWD="root";
	private static final String URL="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8";
	
	private static Connection conn=null;
	//定义一个数据库连接
	private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>() {
		protected Connection initialValue() {
			try {
				Class.forName(DRIVER);
				
				if(conn==null){
					conn=DriverManager.getConnection(URL, USER, PWD);
				}
				
				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} catch (ClassNotFoundException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			return conn;
		}
	};
	
	//获取连接
	public static Connection getConnection(){
		return tl.get();
	}
	//关闭连接的方法
	public static void colseConnection(){
		if (conn!=null) {
			try {
				conn.close();
			
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}
	public static void main(String[] args) {
		System.out.println(getConnection());
	}
}

源码压缩包如下所示：

老师问一下，视频里的有参方法是怎么沟造出来的？是快捷键还是什么？

final int prime = 31;重写hashcode方法时，这个常量的值是可以为任意值吗？

老师如下代码：

public class RemoveIteratorDemo {
	public static void main(String[] args) {
		List arr = new ArrayList();
		arr.add("e");
		arr.add("f");
		arr.add("g");
		arr.add(2);

		System.out.println(arr);//删除前的集合元素
		System.out.println("---------");
		
		for(Iterator it = arr.iterator(); it.hasNext();) {
			if("f".equals(it.next())) {
				it.remove();//删除指定元素
			}
			System.out.println(it.next());//历遍集合元素。
		}
		
		System.out.println("---------");
		System.out.println(arr);//打印删除元素之后的集合
	}
}

运行运行完后结果是：

老师帮忙分析一下呗。。。。

看了这些解析方法，我们到底为什么要得到这些子节点、属性这些东西？我们为什么要解析xml文档？

Goods类：

package com.bjsxt.product2;

public class Goods {
	private String name;//产品名称
	private String bread;//品牌
	private boolean isFlag = true;//用于标识是否有商品，假使为true是代表有商品，false代表没商品
	public Goods(String name, String bread) {
		super();
		this.name = name;
		this.bread = bread;
	}
	public Goods() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getBread() {
		return bread;
	}
	public void setBread(String bread) {
		this.bread = bread;
	}
	//编写一个赋值方法 同步监视器为Goods类的对象
	public synchronized void set(String bread, String name){
		if(isFlag){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		this.setName(name);
		try {
			Thread.sleep(300);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.setBread(bread);
		System.out.println("生产者线程生产了"+this.getBread()+"-------"+this.getName());
		this.notify();
		isFlag=true;
	}
	//编写一个取值的方法
	public synchronized void get(){
		if(isFlag=false){
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("---消费者线程取走了"+this.getBread()+"----"+this.getName());
		this.notify();
		isFlag=false;
	}
	
}

测试类：

package com.bjsxt.product2;

public class Test {
	public static void main(String[] args) {
		//创建共享资源对象
		Goods g = new Goods();
		//创建生产者线程
		Producter p = new Producter(g);
		//创建消费者线程
		Customer c = new Customer(g);
		new Thread(c).start();
		new Thread(p).start();
	}
}

运行截图

我把线程通信加进去之后运行结果和老师的不一样

radom创建的int型随机数和（int）（Math.radom（）)是一样的把

老师想问一下定义一个数组的时候必须规定数组长度吗，那为什么在使用main方法时public static void main(String[]args){}; String 无需定义数组长度？还有想问一下以下两种定义方法有什么区别

比如说在服务端内，读和写两个操作在同一个线程，这里是串行的方式，导致无法同时操作，所以就需要将这两个操作变成并行，既可以读，又可以写；之前的线程冲突是将并行的两个操作改为串行，这块和线程冲突不一样，可以这样理解吗？

老师。这里的super（name）就是调用的父类构造方法对吧，那是不是说明Thread类中也有一个有参的构造方法

老师好，这里的this对象为什么不是threadlocalmap而是threadlocal。

这是啥问题eclipse里不能直接创建xmlschema呀

太乱了 不知道啥是啥  老师讲的太快了有的地方也不说一下原因