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

请问是否有Java8的中文文档

iodemojava.io.FileInputStreamjava.io.IOExceptionTest2 {
    (String[] args) {
        FileInputStream fis = {
            fis = FileInputStream()StringBuilder sb = StringBuilder()temp = ((temp = fis.read()) != -) {
                sb.append(() temp)}
            System..println(sb)} (Exception e) {
            e.printStackTrace()} {
            {
                (fis != ) {
                    fis.close()}
            } (IOException e) {
                e.printStackTrace()}

        }
    }
}

老师，这个API帮助文档可以发给我吗

上限限定符使用在数组引用中为什么子类无法进行获取

List<? extends Number> eList = new ArrayList<>();
Number numObject = eList.get(0);
Integer intObject = eList.get(0);

命令窗口下运行不闪退，批处理文件闪退是什么原因啊

调用private方法抱错

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{
    //与客户端对应的socket对象
    private Socket socket;
    public send(Socket socket){  //构造器，用于传递socket
        this.socket=socket;
    }

    @Override
    public void run() {
        this.sendMsg();
    }
    //定义发送消息的方法
    private void sendMsg(){
        //对于消息的发送需要创建两个对象，1.消息的来源：需要创建键盘输入对象  2.需要创建输出流对象
        try(Scanner scanner = new Scanner(System.in);
            PrintWriter pw =new PrintWriter(socket.getOutputStream());){
            while(true){
                String msg = scanner.nextLine();
                pw.println(msg);
                pw.flush();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

/**
 *接收消息的线程
 */
class receive extends Thread{
    //创建与客户端对应的socket对象
    private Socket socket;
    public receive(Socket socket){//构造器，用于传递socket
        this.socket=socket;
    }
    @Override
    public void run() {
        this.receiveMsg();
    }
    //定义接受消息的方法
    private void receiveMsg(){
        //创建输入对象流，字节转字符，字符处理流
        try(BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()))){
            while (true){
                String str =br.readLine();
                System.out.println("客户端说："+str);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
public class ChatSocketSever {
    public static void main(String[] args) {
        try(ServerSocket serverSocket = new ServerSocket(8888)){
            System.out.println("服务端启动中，等待链接.....");
            //创建与客户端链接时的socket对象
            Socket socket = new Socket();
            System.out.println("连接成功！");
            //将与客服端对应的socket对象传递给发送消息的线程，并启动该线程
            new send(socket).start();
            //将与客户端对应的socket对象传递给接受消息的线程，并启动该线程
            new receive(socket).start();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

老师，想问一个问题，在TelNoteRegex类是校验类，为啥不把方法定义成static类型的，如果定义成static类型的话，以后在Operate中调用不就可以用类名调用了吗，这样不更加方便吗

老师，这文件里面网址打不开能直接发我吗

如图，感谢蔚老师！

老师，直接在A的run方法里创建B的线程对象实现包装，在A类中联合，和课堂讲的区别在哪里呢

class A implements Runnable{
    @Override
    public void run() {
        Thread t3 =new Thread(new B());
        t3.start();
        for(int i=0;i<10;i++){
            if(i==5){
                try {
                    t3.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+":  A"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class B implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"  B"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class TestJoinThread {
    public static void main(String[] args) {
        Thread t1 = new Thread(new A());
        t1.start();

        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"      "+i);
            //当主线程迭代因子为2时，并入A线程
            if(i==2){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

老师那里有问题呀