————————————————————

老师请问？

为什么遍历目录，level写++，输出的结果就是错的只能是+1

package com.bjsxt.testfile;

import java.io.File;

public class Test {
	public static void main(String[] args) {
		print(new File("C:\\Users\\jiangjiexianga\\Desktop\\6第六章"),0);
	}
	
	public static void print(File f,int level){//水平
		for(int i=0;i<level;i++) {
			System.out.print("-");
		}
		
		System.out.println(f.getName());
		
		if(f.isDirectory()) {
			File[] listFiles=f.listFiles();
			for(File f4:listFiles) {
				print(f4,level+1);
				
			}
			}
		
	}
}

请问老师，动态创建类和使用import引入类有什么区别呢？动态创建有什么好处？

在进行压力测试的时候，并发量稍高就会报错，好像是请求输入流没有拿到，由于是在服务器上压测，所以没法打断点，请老师帮忙看下原因，谢谢。

老师它每次卡到这里就不动了，我试了5次大概，都不行，为啥啊，我电脑的过，还是啥

老师您好，运行结果值为null，已百度和查看了课后各种提问，也核对了代码，还把老师的代码复制尝试了还是null值，
求解答。会不会是我的XML地址错误，视频老师用的是Eclipse我用的是IDEA，不知道是不是查找XML地值错误导致的。

代码区
package com.bjsxt.server;

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

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

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>();
    }
    //获取Document对象的方法
    public Document getDocument(){
        try {
            //(1)创建SAXReader对象
            SAXReader reader=new SAXReader();
            //(2)调用read方法
            return reader.read(new File("src/WEB_INFO/web.xml"));
        } catch (DocumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
    public void parse(Document doc){
        //(1)获取根元素
        Element root=doc.getRootElement(); //web-app
        //(2)获取servlet子元素
        for(Iterator<Element> ite=root.elementIterator("servlet");ite.hasNext();){
            Element subElement=ite.next();//得到每一个servlet
            //创建一个实体类
            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("serlvet-class".equals(ele.getName())){
                    ent.setClazz(ele.getText());
                }
            }
            //将Entity添加到集合中
            entityList.add(ent);
        }
        //测试
        /**for (Entity entity : entityList) {
         System.out.println(entity.getName()+"\t"+entity.getClazz());
         }*/
        //解析servlet-mapping

        for(Iterator<Element> ite=root.elementIterator("servlet-mapping");ite.hasNext();){
            Element subEle=ite.next();//得到每一个servlet-mapping
            //创建一个Mapping类的对象
            Mapping map=new Mapping();
            //解析servlet-mapping下的子元素
            for(Iterator<Element> subIte=subEle.elementIterator();subIte.hasNext();){
                Element ele=subIte.next();  //servlet-name，也有可能是url-pattern
                if("serlvet-name".equals(ele.getName())){
                    map.setName(ele.getText());
                }else if("url-pattern".equals(ele.getName())){
                    //获取集合对象，调用集合对象的添加方法，添加元素素
                    map.getUrlPattern().add(ele.getText());
                }
            }
            //Mapping添加到集合中
            mappingList.add(map);
        }
        //测试
        for (Mapping m : mappingList) {
            System.out.println(m.getName());
            for(String s:m.getUrlPattern()){
                System.out.println(s);
            }
        }
    }
    //用于测试
    public static void main(String[] args) {
        WebDom4j web=new WebDom4j();
        web.parse(web.getDocument());
    }
}

xml文件
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
    <servlet>
        <servlet-name>login</servlet-name>
        <servlet-class>com.bjsxt.servlet.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <serlvet-name>login</serlvet-name>
        <url-pattern>/login</url-pattern>
        <url-pattern>/log</url-pattern>
    </servlet-mapping>
    <servlet>
        <servlet-name>register</servlet-name>
        <serlvet-class>com.bjsxt.servlet.RegisterServlet</serlvet-class>
    </servlet>
    <servlet-mapping>
        <serlvet-name>register</serlvet-name>
        <url-pattern>/reg</url-pattern>
        <url-pattern>/register</url-pattern>
        <url-pattern>/regis</url-pattern>
    </servlet-mapping>
</web-app>

老师，String类是不可变字符，比如使用substring方法进行截取，那么会不会重新创建一个对象

我看下面有个人问道了，接口new 实现类。回答的是运用多态，多态的三个必要条件是继承，重写，父类引用指向子类对象。我对这个有点疑问。是不是接口就可以看作是类似继承呢？然后实现接口是类似重写，接口new 实现类是父类引用指向子类对象

这是我在网上搜到的解答，是不是我们平时学的所谓的继承是第一个实现继承。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力；

Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；

Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

就不能给新的tomcat么。jdk13的用不了都。咋不更新

在cmd中运行时出现错误，显示为Error: A JNI error has occurred, please check your installation and try agai

为啥创建class出现这个了??????怎么删除这擎盾

老师，我的代码运行时只会单线程的跑？好像是出现了死锁的情况，检查不出问题，请老师帮我看看哪里出错了？

package 线程冲突3;

public class ProduceTestThread {

    public static void main(String[] args) {

    SyncStack ss=new SyncStack();

    new shengChang(ss).start();

    new xiaoFei(ss).start();

    }

}

/**

 * 馒头类

 */

class manTou{

    private int id;

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

}

/**

 * 缓冲区

 */

class SyncStack{

    //定义放馒头的盒子

    manTou []mtArr=new manTou[10];

    //定义取馒头的盒子

    int index;

    /**

     * 放馒头的方法

     */

    public synchronized void fang(manTou mt){

        while(index==mtArr.length){

            try {

                wait();

             /*   notify();*/

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        this.notify();

        mtArr[index]=mt;

        index++;

    }

    /**

     * 取馒头的方法

     */

    public synchronized manTou qu(int index){

        /*System.out.println("测试：进去取");*/

        while(index==0){

            try {

                this.wait();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

        this.notify();

        this.index--;

        return mtArr[this.index];

    }

}

/**

 * 生产者线程

 */

class shengChang extends  Thread{

    private SyncStack ss;

    shengChang(SyncStack ss){

        this.ss=ss;

    }

    @Override

    public void run() {

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

             manTou mt=new manTou();

            ss.fang(mt);

            ss.mtArr[i].setId(i+1);

            System.out.println("生产馒头："+ss.mtArr[i].getId());

        }

        /*System.out.println("共计生产了馒头"+sum+"个");*/

    }

}

/**

 * 消费者线程

 */

class xiaoFei extends  Thread{

    private  SyncStack ss;

    xiaoFei(SyncStack ss){

        this.ss=ss;

    }

    @Override

    public void run() {

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

            ss.qu(i);

            System.out.println("消费馒头:"+ss.mtArr[i].getId());

            /*manTou mt = ss.qu(i);

            System.out.println("消费馒头"+mt.getId());*/

        }

    }

}

老师这里的增强for循环意思是把目录下的每一个子文件和子目录当成元素传进print方法去然后遍历吗

老师，我发现这种情况用class作为对象锁也能实现噢！

老师，这里第8行已经通过new的方式获得集合对象，又getClass()获得了一个Class对象， 为什么同一个集合，已经new出了对象还需要getClass获得Class对象？ 这两个对象有什么区别不同呢？