这里的时间为什么是从8:00:00开始的·  不是零点零时零分吗

老师，我不太明白静态方法和非静态方法

咋通俗的理解啊

老师，我想问一下为什么我用不了getChildren()方法和getAttribute方法了，jdom包和dom4j我都导了，而且在另一个程序里面能用，这个里面就不能用了，这是为什么？

这里的33和38行用了这两个方法却能用：

这种直接new的FilrReader是自动关闭了吗

说不存在？

for（File temp:files）怎么个遍历法？File是啥意思？temp是变量？files又指的啥啊？？？【小小的眼睛里充满了大大的疑问】

老师有第二阶段课程的讲义文档吗？有的话可以像第一阶段一样方便笔记

为啥我这个泛型下限 show方法，输出ArrayList自定义对象 是按照数组输出呢 还每个输出三遍呢

import java.util.Stack;

public class StackTest {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        // 将元素添加到栈
        stack.push("a");
        stack.push("b");
        stack.push("c");
        // 获取并删除栈顶元素
//        String a = stack.pop();
//        System.out.println(a);
//        String b = stack.pop();
//        System.out.println(b);
//        String c = stack.pop();
//        System.out.println(c);
        System.out.println(stack.size());
        for (int i=0;i<=stack.size();i++){
            System.out.println(stack.pop());
        }
    }
}

运行结果：

3

c

b

提问：老师这个地方为什么用for循环就只能取出2个栈顶元素啊

比较规则里return 1和return -1有什么用啊

老师，一对多聊天服务中，我的客户端不是每次都能返回消息。

下面的是服务端的代码

package com.bjsxt.ls.网络编程.TCP.一对多聊天服务器;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;


//创建服务端接收消息的线程
class ChatReceive extends Thread{
    private Socket ss;
    public ChatReceive(Socket n){
        this.ss=n;
    }

    @Override
    public void run() {
        this.receive1();
    }

    //创建接收消息的线程
    public void receive1(){
        BufferedReader br =null;
        try {
            br = new BufferedReader(new InputStreamReader(this.ss.getInputStream()));
            while (true){
                String jieshou = br.readLine();
                synchronized ("同步锁") {       //要让发送消息和接收消息的线程处于同步状态，需要在两个线程上加上同一个名字的对象锁
                    ChatServer.BUF = jieshou; //将接收到的消息保存到缓存区
                    "同步锁".notify();        //当消息存到缓存区之后，唤醒发送消息线程，可以发送消息了
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (this.ss != null){
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//创建服务端发送消息的线程类
class ChatSend extends Thread{
    private Socket ss;
    public  ChatSend(Socket n){
        this.ss=n;
    }

    @Override
    public void run() {
        this.send1();
    }

    //创建发送消息的方法
    public void send1(){
        PrintWriter pw = null ;
        try {
            pw = new PrintWriter(this.ss.getOutputStream());
            while (true) {
                synchronized ("同步锁") { //要让发送消息和接收消息的线程处于同步状态，需要在两个线程上加上同一个名字的对象锁
                    "同步锁".wait();  //发送消息的线程应先处于等待状态
                    pw.println(ChatServer.BUF); //将消息从缓存区取出，因为BUF是static的，直接用类名就能调用
                    pw.flush();
                }
            }
        }  catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (pw != null){
                pw.close();
            }
            if (this.ss != null){
                try {
                    this.ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//主线程用于启动服务端，客户端可以使用之前的“点对点优化”中的GoodP2P
public class ChatServer {
    //定义一个字符串类型的缓存区
    public static String BUF;
    public static void main(String[] args) {
        System.out.println("正在启动服务器.....");
        System.out.println("<HappyDay>聊天室启动");
        ServerSocket serverSocket = null;
        try {
            serverSocket =new ServerSocket(332);
            while (true){
                Socket sk =serverSocket.accept(); //将启动服务端放在循环中，因为每次发送或接收消息都需要启动服务端
                System.out.println("已经连接到IP地址为["+ InetAddress.getLocalHost() +"]的主机。");
                new ChatReceive(sk).start(); //启动线程
                new ChatSend(sk).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(serverSocket!=null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

这个是用的优化的点对点聊天作为客户端的代码

package com.bjsxt.ls.网络编程.TCP.点对点优化;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;

//创建发送消息线程
class send1 extends Thread{
    private Socket socket =null;
    private Scanner scanner =null;
    public send1(Socket s1,Scanner s2){
        this.socket =s1;
        this.scanner=s2;
    }

    //创建发送消息的方法
    public void sengmessage(){
        PrintWriter pw =null;
        try{
            pw =new PrintWriter(socket.getOutputStream());
            scanner = new Scanner(System.in);
            while (true){
                String say =scanner.nextLine();
                pw.println(say);
                pw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if (pw != null){
                pw.close();
            }
            if (scanner != null){
                scanner.close();
            }
            if (socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Override
    public void run() {
        this.sengmessage();
    }
}

//创建接收消息的线程
class receive extends Thread{
    private Socket socket =null;
    public receive(Socket x){
        this.socket = x;
    }
    public void receivemessage(){
        BufferedReader br= null;
        try {
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while (true){
                String rs = br.readLine();
                System.out.println("收到的消息是："+rs);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (socket!= null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Override
    public void run() {
        this.receivemessage();
    }
}
public class GoodP2P {
    public static void main(String[] args) {
        Scanner scanner = null;
        ServerSocket serverSocket = null;
        Socket socket = null;
        scanner =new Scanner(System.in);
        System.out.println("请输入:server,<port> 或者：" + "<ip>,<port>");
        String str = scanner.nextLine();
        String arr[] =str.split(",");//以逗号为分割点存入数组

        //判断当输入的server时，启动服务端
        if ("server".equals(arr[0])){
            System.out.println("TCP点对点通信，正在启动服务端，连接端口号["+arr[1]+"]");
            try {
                serverSocket =new ServerSocket(Integer.parseInt(arr[1]));//将字符串强转为整型
                socket = serverSocket.accept();
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("连接成功！");
        }
        //当输入的不是server时，即进入客户端
        else {
            try {
                socket = new Socket(arr[0],Integer.parseInt(arr[1]));
                System.out.println("连接成功！");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //启动发送消息的线程
        new send1(socket,scanner).start();
        new receive(socket).start();
        if (serverSocket != null){
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

下面的运行的截图：

服务端测试

客户端1

客户端2

客户端3

老师，我现在才发现为什么我的idea全是英文的呀

老师那里有问题呀

想问下一定要调用FileOutputStream的flush()方法吗，没有写这个方法的时候程序也正常运行了。

老师，为什么在放馒头的同步方法里，用notify()唤醒的是取馒头的线程呢？