老师这个红框里面这个方法参数，是怎么理解，不太理解是什么意思？不同类型方法的我怎么确认具体的参数是什么类型

Apackage com.bjsxt.test;

import com.bjsxt.entity.User;

public class Test {
	public static void main(String[] args) throws ClassNotFoundException {
		System.out.println(int.class);
		System.out.println(void.class);
		int []arrA=new int[10];
		int[] arrB=new int[30];
		/**维数相同和类型相同的数组共享同一个Class对象*/
		System.out.println(arrA.getClass()==arrB.getClass());
		
		/**同一个类的N多对象，共享同一个Class对象*/
		User u1=new User();
		User u2=new User();
		System.out.println(u1.getClass()==u2.getClass());
		
		
		/**获取Class对象的三种方式*/
		//(1)通过对象的getClass()方法获取
		Class c1=u1.getClass();
		//(2)通过字节码文件获取
		Class c2=User.class;
		//(3)通过Class类的静态方法获取
		Class c3=Class.forName("com.bjsxt.entity.User");
		
		System.out.println((c1==c2)+"\t"+(c1==c3));
		
		
	}
}

老师这里定义User对象不需要导包吗   学的时间有点长忘了

老师，我照着视频敲的，这个怎么解决？

源码

package com.bjsxt.server;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class WebDom4j { //用于解析XML
    private List<Entity> entityList; //用于存储N多Entity,而每一个Entity都是servlet-name和servlet-class
    private List<Mapping> mappingList; //用于存储N多Mapping,而每一个Mapping都是一个servlet-name和N多个url-pattern

    public List<Entity> getEntityList() {
        return entityList;
    }

    public void setEntityList(List<Entity> entityList) {
        this.entityList = entityList;
    }

    public List<Mapping> getMappingList() {
        return mappingList;
    }

    public void setMappingList(List<Mapping> mappingList) {
        this.mappingList = mappingList;
    }

    public WebDom4j() {
        entityList = new ArrayList<Entity>();
        mappingList = new ArrayList<Mapping>();
    }
    public Document getDocument(){
        try {
            //(1)创建SAXReader对象
            SAXReader reader = new SAXReader();
            //(1)调用reader方法
            return reader.read(new File("D:\\MyCode\\IdeaProjects\\firstPreject\\http_server2\\src\\WEB_INFO\\web.xml"));
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return null;
    }
    public void parse(Document doc){
        //获取根元素
        Element root = doc.getRootElement(); //web-app
        //获取servlet子元素
        for (Iterator<Element> ite =  root.elementIterator("servlet");ite.hasNext();){
            Element subElement = ite.next(); //得到每一个servlet
            //创建一个实体类Entity
            Entity ent = new Entity(); //用于存储servlet-name和servlet-class
            for (Iterator<Element> subIte = subElement.elementIterator();subIte.hasNext();){
                Element ele = subIte.next(); //可能是servlet-name,也可能是servlet-class
                if ("servlet-name".equals(ele.getName())){
                    ent.setName(ele.getText()); //给实体类中的name赋值
                }else if ("servlet-class".equals(ele.getName())){
                    ent.setClazz(ele.getText()); //给实体类中的clazz赋值
                }
                //将Entity添加到集合中
                entityList.add(ent);
                for (Entity entity: entityList
                     ) {
                    System.out.println(entity.getName() + "\t" +entity.getClazz());
                }
            }
        }
    }
    //测试
    public static void main(String[] args) {
        WebDom4j web = new WebDom4j();
        web.parse(web.getDocument());
    }
}

这个空指针异常为什么

这是啥问题eclipse里不能直接创建xmlschema呀

太乱了 不知道啥是啥  老师讲的太快了有的地方也不说一下原因

写到Request类的这个方法时

根据名称获取多个值
    public String [] getParamterValues(String name){...}

看到老师写的方法体里面有一个判断：这里老师判断当集合values为空时，直接返回空，我认为这里优点不恰当。

上面的代码，当判断key为第一次添加进去的键时，都会为map的键值对中的值分配一个new ArrayList<String>(),然后再把值添加进去，也就是说集合对象不可能为null，集合当中的第一个值有可能为null，当出现name=&psw=666这样的情况的时候 参数集合map当中的这组键值，键为name，值为一个List集合，集合第一个元素为null。集合对象是不可能为空的，但是老师再取值方法当中判断的时候，values就是map当中取出的List集合，如果它为null，则返回null。我认为这种判断有些问题，我把它改成了：判断第一个值是否为空，如果为空，则返回空。

老师，为什么我这个运行以后出来的不是汉语？

package com.company.List;

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        InputStream is = System.in;
        InputStreamReader isr = new InputStreamReader(is,"gbk");
        BufferedReader br = new BufferedReader(isr);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:/systein.txt"),"gbk"));
        String line = null;   //用于存储读到字符串
        while (!"over".equals((line = br.readLine()))){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        if (bw!=null){
            bw.close();
        }
        if (br!=null){
            br.close();
        }
    }
}

老师，程序运行没有出现异常，用debug步入也没有异常，该走的代码没有少走，但是控制台在输入用户名和密码后直接结束，不提示登录成功或密码错误。

服务器端代码：

客户端正常运行服务器出现异常

package com.bjsxt.server;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

import com.bjsxt.entity.User;
import com.bjsxt.thread.ServerThread;

public class Server {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		System.out.println("----------------------服务器端已启动---------------------");
		//(1)创建ServerSocket对象
		ServerSocket server=new ServerSocket(8888);
		
		while(true){
			Socket socket=server.accept();
			//创建线程类的对象，并启动线程
			ServerThread st=new ServerThread(socket);
			//启动线程
			new Thread(st).start();
		}
	}
}

这个while循环是啥意思呢  要是不加会怎么样呢

这个字符串类型的localhost指本机是自己起的名字吗？192.168.31.113为啥是指本机呢

老师说192.168.31.113是ip地址指本机

那上边那个127.0.0.1是啥 也说指本机

老师，这个代码为什么21行总是报错？

package com.company.List;

import com.sun.org.apache.xpath.internal.operations.String;

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

public class TestInputstream2 {
    public static void main(String[] args) throws IOException {
        //(1)搭桥
        FileInputStream fis = new FileInputStream("D:/test.txt");

        //(2)创建大一些的中转站
        byte [] buf =  new byte[1024];
        int len = 0;  //用于存储每次读到的字节
        int i = 0;
        while ((len = fis.read(buf))!=-1){
            //借助String类构造方法
            i++;
            System.out.println(new String(buf,0,len));
        }
        //(3)关闭
        fis.close();
        System.out.println(i);
    }
}

看到有同学问这个问题，关于109行的key判断，与老师有不同的见解。

这里老师的解释是因为为了处理多次请求url的参数，进行的判断，为了以后多次的请求服务。

但是我认为不是这样的。

首先我们看一下Request这个类，参数集合map是他的一个成员变量，并且是在构造器当中进行初始化的。

也就是说，当我们点击登录，形成url，去访问服务器，服务器Server类接收到客户端请求，receive方法会为每一个请求创建Request对象。所以每一次的请求当中刚开始参数集合都是空的，没有放任何东西。所以不存在多次url会影响map参数集合的情况。

所以为什么要写if判断key，是为了处理像hobby=eat&hobby=play这样的参数而存在的。

我们存储参数map集合的时候

键：参数名称

值：为了方便处理hobby这样的对应多个参数值的参数，采用List集合作为map的值。

再来看if的判断：

当处理hobby=eat时，

判断if，集合当中是否存在hobby这样的键，不存在，向集合当中添加键为：hobby，值为一个新的List集合。

继续向下执行，根据hobby键获取到新List集合，将具体的参数值eat添加到新的List集合当中。

当处理hobby=play时，

判断if，集合当中是否存在hobby这样的值，存在，不执行if块。

继续向下执行，根据hobby键获取到对应的List集合，将具体的参数值play添加到新的List集合当中。

所以if的存在是为了判断当前处理的参数是不是第一次参加到集合的键当中。

主要是为了处理像hobby这样拥有重复参数值的参数。

如果是第一次，为其创建新的List集合作为值，将具体参数值添加到List集合当中。

如果不是第一次，获取对应的List集合，向List集合当中继续添加具体的参数值。

老师，键盘录入的时候报错，不知道哪里没对？麻烦看下。这个获取用户对象的方法这里也不是很理解，麻烦说下具体是什么意思？

下面是代码：

package com.bjsxt.entity;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Scanner;


public class client {
    /**
     * 1.创建Socket对象，用于连接服务器
     * 2.获取输出流，传递的是user对象所以用（对象流）
     * 3.创建user对象
     * 4.创建的user对象发到服务器
     * 5.获取输入流发过来是"正确或失败"（使用数据流进行获取），数据流用于存取基本数据类型和String类型方法
     * 6.关闭
     *
     * @return
     */
    public static User main(String[] args) throws IOException {
        Socket client = new Socket("localhost", 8888);

        ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream());

        User user =getUser();//new User("tent","123tx");
        oos.writeObject(user);

        DataInputStream dis = new DataInputStream(client.getInputStream());
        System.out.println(dis.readUTF());

        if (dis != null) {
            dis.close();
        }
        if (oos != null) {
            oos.close();
        }
        if (client != null) {
            client.close();
        }

        //获取用户对象的方法

    private static User getUser() {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String userName = input.next();
        System.out.println("请输入密码");
        String password = input.next();
        //封装成User对象
        return new User(userName, password);
    }
    }
}

package com.bjsxt.entity;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        System.out.println("服务器端已启动");
        /**
         * 1.创建ServerSocket对象
         * 2.建立监听器accept
         * 3.读对象，对象流
         * 4.对用户名和密码进行验证，输出"正确或错误"通过数据流
         * 5.关闭
         */
        ServerSocket server  =new ServerSocket(8888);
        Socket ss =   server.accept();

        ObjectInputStream ois =new ObjectInputStream(ss.getInputStream());//
        User u =(User)ois.readObject();//读对象的时候需要转换为User类型，目前是Object类型
        System.out.println(ss.getInetAddress().getHostAddress()+"请求登陆：用户名"+u.getUserName()+"密码："+u.getPassword());
        String str ="";
        if ("tent".equals(u.getUserName())&&"123tx".equals(u.getPassword())){
            str ="登陆成功";
        }else{
            str ="对不起，账号密码不正确";
        }

        DataOutputStream dos =new DataOutputStream(ss.getOutputStream());
                dos.writeUTF(str);

        if(dos!=null){
            dos.close();
        }
        if (ois!=null){
            ois.close();
        }
        if (ss!=null){
            ss.close();
        }
    }
}

package com.bjsxt.entity;

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = -7626780842003520333L;//用于封装用户名和密码
    private String userName;
    private  String password;

    public String getUserName() {
        return userName;
    }

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

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

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

    public User() {
    }

}