@Inherited 请问老师这个元注解是什么意思，以及它的用法是什么？

1、双向通信必须建立两个工程文件向视频中那样吗？单向通信的时候是可以的，双向通信我是在一个包下，报错

public class Test_Client {

	public static void main(String[] args) throws UnknownHostException, IOException {
		Socket soc = new Socket("localhost", 9999);
		ObjectOutputStream oos = new ObjectOutputStream(soc.getOutputStream());
		User u=getUser();
		oos.writeObject(u);
		
		DataInputStream dis = new DataInputStream(soc.getInputStream());
		System.out.println(dis.readUTF());
		
		if(dis!=null){
			dis.close();
		}
		if(oos!=null){
			oos.close();
		}
		if(soc!=null){
			soc.close();
		}
	}
	public static User getUser() {
		Scanner s = new Scanner(System.in);
		System.out.println("username");
		String name = s.next();
		System.out.println("password");
		String pwd = s.next();
		return new User(name, pwd);
	}
	

}

错误信息

username
bj
password
bj
Exception in thread "main" java.io.EOFException
	at java.io.DataInputStream.readUnsignedShort(Unknown Source)
	at java.io.DataInputStream.readUTF(Unknown Source)
	at java.io.DataInputStream.readUTF(Unknown Source)
	at com.athom.Login.Test_Client.main(Test_Client.java:20)

；老师为什么我把按照视频重写的  equals和hashcode方法注释掉 这个结果变成这样了呢

private Account account;老师，这里我不太懂为什么可以直接用Account类型的啊？还有，那个讲super（name）的时候说把name存到super里面是什么意思啊？

这个值可以我随便定义吗

package com.bjsxt.IO;

import java.io.Serializable;

public class Stu implements Serializable {
    private static final long serialVersionUID = 9040001675273134854L;  //具备可序列化和反序列化的能力
    private String name;
    private int age;
    public static String schoolName;   //static 不会被序列化
    transient String pwd;    //transient 不会被序列化



    public Stu() {
    }

    public Stu(String name, int age, String pwd) {
        this.name = name;
        this.age = age;
        this.pwd = pwd;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", pwd=" + pwd +", schoolName="+schoolName+
                '}';
    }
}

Classes类

package com.bjsxt.IO;

import com.bjsxt.collection.Student;

import java.io.Serializable;
import java.util.ArrayList;

public class Classes implements Serializable {
    private static final long serialVersionUID = -7097903749347750461L;
    private String className;
    private ArrayList<com.bjsxt.IO.Stu> al;  //要将classes写入磁盘 那Student也得是可序列化和可反序列化的

    public Classes(String className, ArrayList<Stu> al) {
        this.className = className;
        this.al = al;
    }

    public Classes() {
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public ArrayList<Stu> getAl() {
        return al;
    }

    public void setAl(ArrayList<Stu> al) {
        this.al = al;
    }

    @Override
    public String toString() {
        return "classes{" +
                "className='" + className + '\'' +
                ", al=" + al +
                '}';
    }
}

读写

package com.bjsxt.IO;

import java.io.*;
import java.util.ArrayList;

public class TestObjectOutputStream3 {
    public static void main(String[] args) {
        write();
        read();
    }

    //写对象
    public static void write(){
        //创建学生对象
        ArrayList<Stu> al = new ArrayList<>();
        Stu stu1 = new Stu("zhang",20,"123456");
        Stu stu2 = new Stu("yang",22,"654321");
        Stu stu3 = new Stu("chen",23,"888888");
        al.add(stu1);
        al.add(stu2);
        al.add(stu3);

        //创建班级对象
        Classes cl = new Classes("one", al);

        //创建对象输出流
        ObjectOutputStream oos = null;
        try {
            oos = null;
            oos = new ObjectOutputStream(new FileOutputStream("d:/java/classes.txt"));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭流
            if(oos!= null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    //读取
    public static void read(){
        ObjectInputStream ois = null;
        try {
            ois = null;
            ois = new ObjectInputStream(new FileInputStream("d:/java/classes.txt"));
            Classes cl = (Classes)ois.readObject();
            System.out.println(cl.getClassName()+"\t"+cl.getAl());
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

运行结果

查了一下说是EOFException是意外到达文件或流的末尾抛出的异常，解决方法有点没看懂。。看不出来52行哪里有问题。。第九行是调用read（）。

为什么newThr解说是24怎么还写的是12

@param 这个用法是啥，怎么和public static coid copyFile 的参数还有关系

老师，为什么我的XML下就没有Schema格式的文件啊

老师调用index校验的这个方法前面可以不用this吗

老师，在启动子线程后再让线程进入阻塞状态，之后终止线程。

那让线程进入阻塞状态只能用System.in.read();吗？

有两个问题

1）

在3.2中用declared方法获取了private成员变量，在3.3中也操作了public成员变量。

是不是就说，通过declared方法可以获取私有变量和私有方法，但是如果要操作私有变量（如修改值）和私有方法（如调用方法），则必须setAccessible？

2）对于构造方法，是不会设置为private的吗？

老师，我把防火墙关了，并且User是复制过去的，依然报Connection reset错误，找了很久没能解决问题！老师能帮我看看怎么办吗

这里是我的源码

老师你注释用的快捷键是啥