我把 this.manager 改为 Manager.class 效果一样。他们有什么区别吗

为什么客户端发送消息的端口与服务端监听的端口不一致，为什么不能像TCP那样，客户端与服务器端口一致？

import java.io.File;

public class TestFile {

public static void main(String[] args) {

File f=new File("E:\\013演示");

printFile(f, 0);

}

public static void printFile(File file,int level){

//打印树状结构的层次关系

for(int i=0;i<level;i++){

System.out.print("-");

}

//输出目录或文件的名称

System.out.println(file.getName());

if(file.isDirectory()){ //判断File对象是否是目录

File [] listFiles=file.listFiles();

for(File temp:listFiles){

//自己调用自己

printFile(temp,level+1);

}

}

}

}

File [] listFiles=file.listFiles();

在程序中这一行程序，在递归调用的时候是不是出现了重复定义数组的问题？

在使用HashSet容器时为什么Person类必须重写hashCode()方法及equals()方法，不重写一样可以储存啊

代码：

package cn.sxt.set;

public class Person {
	private String name;
	private int age;
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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;
	}
/*	//Person 类必须重写hashCode()方法和equals()方法
	//Hash表原理
	*//**
	 * (1)调用hashCode()方法计算Hash码值
	 * （2）根据y=k(x)这样的函数计算储存位置
	 * （3）如果该位置上没有元素，则元素储存
	 * （4）如果有元素，则调用equals方法比较内容，若相同，则不储存，若不同，则储存
	 * *//*
	public int hashCode(){
		System.out.println("person.hashCode()");
		final int prime = 31;
		int result = 1;
		result = prime*result +age;
		result = prime*result + ((name==null)?0:name.hashCode());
		return result;
		
	}
	public boolean equals(Object obj){
		
	    System.out.println("Person.equsls()");
	    if(this == obj)
	    	return true;
	    if(obj==null)
	    	return false;
	    if(getClass() !=obj.getClass())
	    	return false;
	    Person other = (Person) obj;
	    if(age !=other.age)
	    	return false;
	    if(name == null){
	    	if(other.name!=null)
	    		return false;
	    }else if(!name.equals(other.name))
	    	return false;
	    return true;
	    	
	    
	    
	   }*/
	
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	

}

package cn.sxt.set;

import java.util.HashSet;

public class TestPersonHashSet {
	public static void main(String[]args){
		
		HashSet hs = new HashSet();
		Person p = new Person("may",18);
		Person p1 = new Person("jak",20);
		Person p2 = new Person("may",22);
		Person p3 = new Person("lili",20);
		hs.add(p);
		hs.add(p2);
		hs.add(p1);
		hs.add(p3);
		System.out.println(hs);
		
	}

}

打印：

为什么要写成下面这样

MethodGeneric methodGeneric2 = new MethodGeneric(); 
String name = methodGeneric2.getName("abc");
System.out.println(name);

我写成这样不是更快吗

MethodGeneric methodGeneric2 = new MethodGeneric(); 
System.out.println(methodGeneric2.getName("abc"));

之前的那个女老师讲的啥玩意，一个天上一个地下，浪费好多精力

package com.wjklovewj.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import org.apache.commons.io.IOUtils;

public class TestIOUtils {

	public static void main(String[] args) throws FileNotFoundException, IOException {
		String str=IOUtils.toString(new FileInputStream("E:\\a.txt"));

	}

}

为什么会报异常，命名在E盘里面有a.txt，能够找得到为什么还是会报异常呢？

1.不是说端口号是唯一标识进程的吗？为什么使用不同的通信协议，端口号是可以重复的了？

老师为啥我d盘目录下的a.txt文件里有abc3个字母,实际用循环打印出来只有98和-1?

这节课最后实现的多用户客户端向服务器端发送请求,还是单线程的啊.

while(true){

Socket socket=server.accept();

//创建线程类的对象，并启动线程

ServerThread st=new ServerThread(socket);

//启动线程

new Thread(st).start();

}

因为server.accept()方法是阻塞式的,即使多个客户端发送请求,也是一个个的处理,并没有达到并发处理的效果,

而且accept()方法每次只能获取一个socket对象,也无法通过new 多个Thread()方法来并发,请问这边如果要模拟并发怎么操作.!!,

老师，反射的方式可以获取私有的方法，是不是也可以获取私有的构造方法，那么是不是用反射的方式就可以打破单例模式了呀？

老师~这是我配置的环境，但是检查是否配置成功时，黑窗口出现闪退，就是闪了以下，这是为什么。

老师，我这个为啥会报错呢，写数据和读数据顺序都是对应的呀

代码：

import java.io.*;
import java.util.Date;

/**
 * @author LLLYF
 *
 */
public class Test3 {
    public static void main(String[] args) throws IOException {
        //write();
          read();

    }
    //读取数据的方法
    public static void read() throws IOException {
        //（1）数据源
        FileInputStream fis=new FileInputStream("E:\\date.txt");
        //(2)提高读取效率
        BufferedInputStream bis=new BufferedInputStream(fis);
        //(3)处理java的基本数据类型和字符串
        DataInputStream dis=new DataInputStream(bis);
        //(4)读数据--（读数据的顺序要与写数据的顺序完全一致）
        System.out.println(dis.readInt());
        System.out.println(dis.readDouble());
        System.out.println(dis.readBoolean());
        System.out.println(dis.readChar());
        System.out.println(dis.readUTF());
        //关闭
        dis.close();
    }
    public static void write() throws IOException {
        //(1)目的地
        FileOutputStream fos=new FileOutputStream("E:\\date.txt");
        //(2)缓冲流提高写入效率
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //(3)数据流，增加对java基本数据类型和String的处理
        DataOutputStream dos=new DataOutputStream(bos);
        //(4)写入数据
        dos.writeInt(98);
        dos.writeDouble(98.5);
        dos.writeBoolean(true);
        dos.writeChar('a');
        dos.writeUTF("helloworld");
        //(5)关闭流
        if(dos!=null){
                    dos.close();
        }
    }

}

运行结果：

老师请问，在使用线程的时候，什么情况下用实现Runnable接口，什么时候用继承Thread呢？这两个之间的区别还不是太清楚。

老师能不能把第二阶段的视频的声音调大点，视频清晰度调高点啊