l老师，输出这个读取文档的方法read.read（），为什么要在System.out.println()里面加个“”呢，不加“”输出的就是数字，这是为什么呢？

package com.lxb;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Test02 {
    public static void main(String[] args) throws IOException {
        FileReader reader=null;
        try {
            reader = new FileReader("d:/a.txt");
            char c1 = (char) reader.read();
            char c2 = (char) reader.read();
            char c3 = (char) reader.read();

            System.out.println(""+ c1 + c2 + c3);
        }finally {
            System.out.println("Test.main");

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

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

-泛型的高级使用_容器中使用泛型-

23行没有报错，原因是？

为啥源码和视频代码不一样？有啥区别吗

源码：

视频：

老师，set(int index, E element)中，为什么是返回oldValue？

在5分35到5分45时间段之间。老师说定义数组类型时可以使用泛型，但是创建数组的时候需要指定类型。那么当我们使用这个类创建对象时，给予了指定的泛型类型。那么在类的加载中，按我们给予的指定的类型创建相应的数组为什么会有问题？

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReceiver extends Thread {
//接收客户端消息的线程
    private DatagramSocket datagramSocket;
    private int port;
    public UdpReceiver(DatagramSocket datagramSocket,int  port){
        this.datagramSocket = datagramSocket;
        this.port = port;
    }
    @Override
    public void run() {
        this.udpReceive();
    }
    //实现接收信息
    public void udpReceive(){
        //创建服务端接收数据的DatagramSocket 对象
        try {
            datagramSocket = new DatagramSocket(this.port);
            //创建数据缓存区
            byte [] bytes = new byte[1024];
            //创建数据报包对象
            UdpChatRoom.dp = new DatagramPacket(bytes,bytes.length);
            //等待接收客户端所发送的数据
            try {
                synchronized (UdpChatRoom.dp){
                    datagramSocket.receive(UdpChatRoom.dp);
                    //唤醒线程
                    UdpChatRoom.dp.notifyAll();
                    String str = new String(UdpChatRoom.dp.getData(),0,UdpChatRoom.dp.getLength());
                    System.out.println(str);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
}

public class UdpSend extends Thread {
    //向客户端发送消息的线程
    private DatagramPacket datagramPacket;
    private DatagramSocket datagramSocket;
    private String destIp;//目标IP地址
    private int desPort;//目标端口
    private Scanner scanner;

    public UdpSend(DatagramSocket datagramSocket, DatagramPacket datagramPacket, String destIp, int desPort, Scanner scanner) {
        this.datagramSocket = datagramSocket;
        this.datagramPacket = datagramPacket;
        this.destIp = destIp;
        this.desPort = desPort;
        this.scanner = scanner;
    }

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

    //向客户端发送消息
    public void sendMsg() {
        while (true) {
            //消息需要进行转换转换成字符数组
            scanner = new Scanner(System.in);
            String sendMsg = scanner.nextLine();
            byte[] bytes = sendMsg.getBytes();
            //创建数据报包装对象DatagramPacket
            this.datagramPacket = new DatagramPacket(bytes, bytes.length, new InetSocketAddress(this.destIp, this.desPort));
            //将数据包放入公共数据区
            UdpChatRoom.dp = datagramPacket;
            //创建数据发送对象DatagramSocket,需要指定消息的发送端口
            try {
                this.datagramSocket = new DatagramSocket(8888);
                synchronized (datagramPacket){
                     //让发送消息的线程处于等待状态
                    datagramPacket.wait();
                    //从公共数据区取出包发送给客户端
                    this.datagramSocket.send(UdpChatRoom.dp);
                }

            } catch (SocketException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (datagramSocket != null) {
                        datagramSocket.close();
                    }
                    if (datagramPacket != null) {
                        datagramSocket.close();
                    }
                    if (scanner != null) {
                        scanner.close();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.Scanner;

public class UdpChatRoom {
    //udp一对多聊天室
    //存放公共的信息
    public static DatagramPacket dp;

    public static void main(String[] args) {
        try {

            DatagramSocket datagramSocket = new DatagramSocket(8888);
            new UdpReceiver(datagramSocket,9999).start();
            new UdpSend(datagramSocket,UdpChatRoom.dp,"127.0.0.1",8888,new Scanner(System.in)).start();
        } catch (SocketException e) {
            e.printStackTrace();
        }

    }
}

老师这是我用udp写的哪个多人聊天，看看哪里有错误

老师，持久化的时候需要加序列化，为什么我看后面mybatis不给pojo加也可以持久化到数据库？

老师这个不用if退出循环就是说结束连接的主动权是在客户端手里是吧，只要客户端循环断了服务端也会断吗

如果我想让A也去联合B该怎么做

？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？？

老师，在定义这个非静态可变参数泛型方法时，一定要遍历吗？我可以先定义一定不遍历的非静态可变参数泛型方法，然后再使用的时候再遍历，这样行吗

老师，请问这里写的时候不用加flush语句吗?

老师，C语言的链表带头结点的，那个头节点是空的，但是这个好像head不是空的呀，创建时，那个element不就赋值进去了

那个flush()是什么意思啊？

刚刚开始的时候不是说把数据存进磁盘吗？

User 类：

public class User {

    private String userName;
    private int userAge;
    public String location;

    public User() {
    }

    public User(String userName, int userAge, String location) {
        this.userName = userName;
        this.userAge = userAge;
        this.location = location;
    }

    // private modifier
    private User(int userAge) {
        this.userAge = userAge;
    }

     /*only the name is different, can not constitute an overload,
     so it can not add the constructor that only have a location parameter.*/
    public  User(String userName) {
        this.userName = userName;
    }

    public User(String userName, String location) {
        this.userName = userName;
        this.location = location;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getUserAge() {
        return userAge;
    }

    public void setUserAge(int userAge) {
        this.userAge = userAge;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public void testMethod () {
        System.out.println("hello！");
    }

    private void testWay () {
        System.out.println("overload");
    }

    public void testWay (int id) {
        System.out.println(id);
    }

    @Override
    public String toString() {
        /* Considering code writing from the bottom level, in order to cope with different functional requirements */
        return "User{" +
                "userName='" + this.getUserName()+ '\'' +
                ", userAge=" + this.getUserAge()+
                ", location='" + this.getLocation() + '\'' +
                '}';
    }
}

通过反射调用方法测试类：

public class GetMethodTest02 {

    public static void main(String[] args) {
        User user01 = new User();
        Class classObject01 = user01.getClass();

        Class classObject02 = User.class;

        Class classObject03 = null;
        try {
            classObject03 = Class.forName("com.bjsxt.demo.User");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        /* call the public method */
        Method method01 = null;
        try {
            method01 = classObject03.getDeclaredMethod("testWay",int.class);   // get designed method object.
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        Object user02 = null;
        try {
            user02 = classObject03.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        try {
            method01.invoke(user02,3);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

        // how call the private method?

    }
}

老师，在调用方法的测试类中，如何调用自定义的用 private 修饰的 testWay() 方法？还是说通过反射只能调用类的 public 方法，不能调用 pirvate 的方法.

和老师的代码一样，不知道哪里出错了，找不出来，希望老师指点一下