老师你好，下面有一段是format.format(date2)，第一个是追溯到上面那个yyyy那边的格式，那后面的format的作用是什么，是因为语法原因来调用date2才加上去的吗？

老师，我不太明白，

finally{
    try{
        if(bis != null){
            bis.close();
        }
    }
}

当中，为什么bis  != null  时才可以关闭这个流？不等于空不应该是说明这个流里有东西，所以更不应该关闭才对吗

这个获取Class对象为什么用的getClass不应该直接用Class吗

public class TestShowMsg {

    public static void main(String[] args) {

        ShowMsg sm = new ShowMsg();
        Generic3<Integer> g = new Generic3<>();
        sm.showFlag(g); // null 这里null 是因为这时候Generic3的对象没有任何值为空
        g.setFlag(20); // 为Generic3中的flag赋值20
        sm.showFlag(g); // 20 将Generic3对象g传入
       /*
        Generic3<Number> g2 = new Generic3<>();
        sm.showFlag(g2);
        g.getFlag(50);
        sm.showFlag(g);
        这里都报错的原因是泛型只确定了你要使用的类型或者类型识别，不考虑继承关系，只看类型！！
*/

        System.out.println("=============================================");
        Generic3<Integer> g2 = new Generic3<>();
        sm.showFlag(g2); 
        g2.setFlag(30); 
        sm.showFlag(g2); 
        Generic3<Number> g3 = new Generic3<>();
        sm.showFlag2(g3); // 因为showFlag2(Generic3<?> generic3)的参数泛型是? 任意类型 所以这里不会报错
        g3.setFlag(50);
        sm.showFlag2(g3);


    }
}
class ShowMsg{
    public void showFlag(Generic3<Integer> generic3){  // 这里传入的参数是Generic3对象 泛型类型定义为Integer
        System.out.println(generic3.getFlag());
    }

    // ? 无界通配符
    public void showFlag2(Generic3<?> generic3){  // 不能确定传入的是什么类型时 泛型类型定义为? 任意类型都可以
        System.out.println(generic3.getFlag());
    }
}

class Generic3<T>{
    private T flag;

    public T getFlag() {
        return flag;
    }

    public void setFlag(T flag) {
        this.flag = flag;
    }
}

老师，我这样理解对吗？

然后还有两个问题：

1、为什么传入参数Generic3<T> generic会报错？  我创建的泛型类是Generic3<T>，T不是表示简单的JAVA类么，

为什么传参时不可以使用？

public void showFlag(Generic3<T> generic3){  
    System.out.println(generic3.getFlag());
}

2、T是简单JAVA类 ?是任意类型 那这里用?作为传入参数的泛型，会不会出现超出T表示的范围？

public void showFlag2(Generic3<?> generic3){  
        System.out.println(generic3.getFlag());
    }

老师 这是哪里报错了

老师完全看不懂，该怎么学习理解呢？

我的打印输出是乱码

请问如何解决，其中我用了GBK,和UTF-8的形式输出，都不行

老师这里的压栈和弹栈不是很理解，意思是每次执行inorder操作的时候都把这个方法压入栈中，当执行到最后的左节点时候再开始从栈中弹出吗，为什么会这样呢

 请问老师，当我使用

fos.write(buf)

如果被复制的文件中有中文时，在复制后的文件末尾会存在乱码，但是当我使用

fos.write(buf, 0, len)

向目标文件写入内容后，文件末尾没有乱码。

请问这是什么原因？

老师，（1）这个为啥在有参构造方法中不把br关闭了，只关闭dos和client？

（2）线程为啥会出错，出什么错，遇到什么情况要用flag标记

请问下老师为何这里先执行等待,而不是先输出,而且既然进行了wait为何还可以输出呢

fw.write("中国、俄罗斯、美国、欧洲、非洲\r");

问题：为啥直接\r 也能打出同样的效果

想问一下前面这个transient这个是什么意思

package com;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
/*发送消息线程*/
/**
 * 发送消息线程
 */
class Send1 extends Thread{
    private Socket socket;
    private Scanner scanner;
    public Send1(Socket socket,Scanner scanner){
        this.socket = socket;
        this.scanner = scanner;
    }
    @Override
    public void run() {
        this.sendMsg();
    }
    /**
     * 发送消息
     */
    private void sendMsg(){

        //创建向对方输出消息的流对象
        try(PrintWriter pw = new PrintWriter(this.socket.getOutputStream())){

            while(true){
                String msg = scanner.nextLine();
                pw.println(msg);
                pw.flush();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

/**
 * 接收消息的线程
 */
class Receive1 extends Thread{
    private Socket socket;
    public Receive1(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        this.receiveMsg();
    }
    /**
     * 用于接收对方消息的方法
     */
    private void receiveMsg(){
        //创建用于接收对方发送消息的流对象
        try(BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()))){

            while(true){
                String msg = br.readLine();
                System.out.println("他说："+msg);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
public class GoodTCP {
    public static void main(String[] args) {
        Scanner scanner = null;
        ServerSocket serverSocket = null;
        Socket socket = null;
        try{
            scanner = new Scanner(System.in);
            System.out.println("请输入：server,<port> 或者：<ip>,<port>");
            String str = scanner.nextLine();
            String[] arr = str.split(",");
            if("server".equals(arr[0])){
                //启动服务端
                System.out.println("TCP Server Listen at "+arr[1]+" .....");
                serverSocket = new ServerSocket(Integer.parseInt(arr[1]));
                socket = serverSocket.accept();
                System.out.println("连接成功！");

            }else{
                //启动客户端
               socket = new Socket(arr[0],Integer.parseInt(arr[1]));
                System.out.println("连接成功！");
            }
            //启动发送消息的线程
            new Send(socket,scanner).start();
            //启动接收消息的线程
            new Receive(socket).start();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(serverSocket != null){
               try {
                   serverSocket.close();
               }catch (IOException e){
                   e.printStackTrace();
               }
            }
        }
    }
}

老师为什么在我第二次运行以后，在里面输入ip地址跟端口以为什么会报空指针异常啊，而且这个空指针异常不是这个程序里面的事这个程序里面的空指针异常

package com;

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

//创建点对点的聊天应用
//创建服务端

/**
 * 发送消息线程
 */
class Send extends Thread{
    private Socket socket;
    public Send(Socket socket){
        this.socket = socket;
    }

    public Send(Socket socket, Scanner scanner) {
    }

    @Override
    public void run() {
      /*  String str = null;
        if (str!=null){
            System.out.println(str.charAt(0));
        }*/
        this.sendMsg();
    }
    /**
     * 发送消息
     */
    private void sendMsg(){
        //创建Scanner对象
        try(Scanner scanner = new Scanner(System.in);
            //创建向对方输出消息的流对象
            PrintWriter pw = new PrintWriter(this.socket.getOutputStream());){

            while(true){
                String msg = scanner.nextLine();
                pw.println(msg);
                pw.flush();
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

/**
 * 接收消息的线程
 */
class Receive extends Thread{
    private Socket socket;
    public Receive(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        this.receiveMsg();
    }
    /**
     * 用于接收对方消息的方法
     */
    private void receiveMsg(){
        //创建用于接收对方发送消息的流对象
        try(BufferedReader br = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));){

            while(true){
                String msg = br.readLine();
                System.out.println("他说："+msg);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
public class ChatSocketServer {
    public static void main(String[] args) {

        try(ServerSocket serverSocket = new ServerSocket(8080);){
            System.out.println("服务端启动，等待连接。。。。。");
            Socket socket = serverSocket.accept();
            System.out.println("连接成功！");
            new Send(socket).start();
            new Receive(socket).start();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

这里获取Class对象为什么用getClass不应该直接用Class吗？