老师这个数据库昨天还可以登录，今天登录不进去，显示无监听程序，我重新配置服务器时，发现更改登录登不进去，请问一下这是什么原因

public class SuperCar implements ICar {
	private ICar car;
	public SuperCar(ICar car){
		this.car=car;
	}
	@Override
	public void move() {
		car.move();
	}

}

supercar类中  

private ICar car;

这句什么意思？

还有

public void move() {
		car.move();
	}

还有这里这个car.move什么意思？

老师说真实角色的move方法  什么意思   他不是Ica的变量吗？

public SuperCar(ICar car){
		this.car=car;
	}

super构造方法中参数是Icar的变量为什么这么写  干什么的

老师也不说明白，咱也不知道为啥 还得在视频下边问

老师您好，您看一下我的代码和运行结果，帮我指出哪里出现了问题

package com.bjsxt.server;

import java.util.List;
import java.util.Map;

import com.bjsxt.servlet.Servlet;



/**
 * 
 * @author zhang - dell
 *用于初始化程序运行的数据
 *和根据不同的url创建所请求的Servlet对象
 */
public class WebApp {//App应用程序
	private static ServletContext contxt;
	
	static {
		contxt=new ServletContext();
		//分别获取对应关系的Map集合
		Map<String,String> servlet=contxt.getServlet();
		Map<String,String> mapping=contxt.getMapping(); 
		
		//创建解析XML文件
		WebDom4j web = new WebDom4j();
		web.parse(web.getDocument());//解析XML
		
		//获取解析XML之后的List集合
		List<Entity> entityList = web.getEntityList();
		List<Mapping> mappingList = web.getMappingList();
		
		//将List集合中的数据存储到Map集合
		for(Entity entity : entityList) {
			
			servlet.put(entity.getName(),entity.getClazz());
		}
//		System.out.println(servlet);
		for(Mapping map : mappingList) {
			//遍历url-pattern的集合
			List<String> urlPattern=map.getUrlPattern();
			for(String s:urlPattern) {
				mapping.put(s, map.getName());
			}
//			System.out.println(mapping);
			
		}
		/**根据url创建不同的Servlet对象
		 */
		public static Servlet getServlet(String url) {
			if(url==null||url.trim().equals("")) {
				return null;
			}
			//如果url正确
			//根据url的key获取servlet-name的值 /log,/reg=register
			String servletName=contxt.getMapping().get(url);
			//servletName得到对应的servlet-class
			String servletClass=contxt.getServlet().get(servletName);
			//使用反射创建Servlet对象
			Class<?>clazz=Class.forName(servletClass);
			//调用无参构造方法创建Servlet对象
			Servlet servlet=(Servlet) clazz.newInstance();
			return servlet;
		
		}
		
	}
	public static void main(String[] args) {
		
	}
	
}

代码截图：

运行截图：

在写服务器端多线程案例的时候，思考会有线程安全问题吗？画了个图：

发现随着循环的开启，每次都accept()生成一个socket对象，再传入线程类ServerThread类当中初始化，接着开启线程start()，这也是多线程，但是没有共享资源对象，因为里面的socket都是不同的，所以不会出现线程安全问题。

也意识到多线程中是不一定出现线程安全问题的，也就是不一定需要同步。只有多条线程共同访问共享资源的时候，就是访问同一个东西的时候才会用到线程同步。

我的这些思考也不知道正不正确，想问一下老师。。

为什么没有这些注解，我写注解的时候它不能自动导包，我自己写上了包之后还是报错误，而且我的pom.xml创建的时候就有错误，

老师，请详细讲解下内部类 和 组合的异同。

public class Student implements Serializable {
    private String name;
    private int age;
    public static String schoolName;
    private transient String pwd;

    public Student() {
    }

    public Student(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;
    }
}

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

    //写对象方法
    public static void write(){
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("d:/a.txt"));
            Student stu = new Student("marry",20,"888888");
            Student.schoolName = "北校区";
            oos.writeObject(stu);
        } 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 = new ObjectInputStream(new FileInputStream("d:/a.txt"));
            Student stu = (Student) ois.readObject();
            System.out.println(stu);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois != null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行结果：

老师，为什么我这个静态成员schoolName可以被序列化？

package com.bjsxt.array;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;

public class Test {
	public static void main(String[] args) {
		byte [] buf=write();//调用写对象的方法
		//调用读对象的方法
		read(buf);
	}
	public static byte[] write(){
		//创建字节数组流对象
		ByteArrayOutputStream baos=null;
		ObjectOutputStream oos=null;
		
		try {
			baos=new ByteArrayOutputStream();//创建字节数组流对象,目的地是字节数组,底层创建一个长度数为32的字节数组
			oos=new ObjectOutputStream(baos);
			oos.writeInt(98);
			oos.writeDouble(98.5);
			oos.writeChar('a');
			oos.writeBoolean(false);
			oos.writeObject(new Date(1000));
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			//关闭流
			if (oos!=null) {
				try {
					oos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		return baos.toByteArray();
	}
	public static void read(byte [] buf){
		ByteArrayInputStream bais=null;
		ObjectInputStream ois=null;
		//创建对象
		try {
			bais=new ByteArrayInputStream(buf); //数据源是byte类型的数组
			ois=new ObjectInputStream(bais);
			
			//读数据
			System.out.println(ois.readInt());
			System.out.println(ois.readDouble());
			System.out.println(ois.readChar());
			System.out.println(ois.readBoolean());
			System.out.println(ois.readObject());
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
		
			//关闭流
			if(ois!=null){
				try {
					ois.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

这里主函数去调用写出方法时是这样调用的

byte [] buf=write();//调用写对象的方法

有什么说法吗   第一次见这种写法

老师我的xshell连接不上linux 报错信息百度 解决办法试过没啥用

Could not connect to '192.168.0.108' (port 22): Connection failed.

老师 这是为什么？ 我 哪里弄错了 就是初始化数据库不成功

package com.bjsxt.copy;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestCopy {
	public static void main(String[] args) {
		/*File srcFile=new File("D:\\180416\\五一作业.docx");
		File targetFile=new File("E:\\五一作业.docx");
		//调用复制文件的方法
		copyFile(srcFile, targetFile);*/
		File srcDir=new File("D:\\180416");
		File targetDir=new File("E:\\180416");
		//调用复制指定目录下所有文件的方法
		copyDir(srcDir, targetDir);
	}
	public static void copyDir(File srcDir,File targetDir){
		if(!targetDir.exists()){
			targetDir.mkdir();//如果目的地的目录不存在，则需要使用File类的方法进行创建目录
		}
		File []files=srcDir.listFiles(); //获取指定目录下的所有File对象
		for (File file : files) {
			if (file.isFile()) {
				 //复制  srcDir -->D:\\180416  拼接  D:\\180416\\XXXX.doc文件
				//    targetDir-->E:\\180416 拼接 E:\\180416\\XXXX.doc文件
				copyFile(new File(srcDir+"\\"+file.getName()), new File(targetDir+"\\"+file.getName()));
			}else{
				//继续调用该方法，使用递归实现
				copyDir(new File(srcDir+"\\"+file.getName()), new File(targetDir+"\\"+file.getName()));
			}
		}
	}
	public static void copyFile(File srcFile,File targetFile){
		//(1)提高读取效率，从数据源
		BufferedInputStream bis=null;
		//(2)提高写入效率，写到目的地
		BufferedOutputStream bos=null;
		try {
			bis = new BufferedInputStream(new FileInputStream(srcFile));
			
			bos = new BufferedOutputStream(new FileOutputStream(targetFile));
			//(3)边读边写
			byte [] buf=new byte[1024];//中转站
			int len=0;//用于存储读到的字节的个数
			while((len=bis.read(buf))!=-1){
				bos.write(buf,0,len);
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
		//(4)关闭
			if(bos!=null){
				try {
					bos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(bis!=null){
				try {
					bis.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		
		}
	}
}

这个方法中拼接文件名字部分代码不太理解

public static void copyDir(File srcDir,File targetDir){
		if(!targetDir.exists()){
			targetDir.mkdir();//如果目的地的目录不存在，则需要使用File类的方法进行创建目录
		}
		File []files=srcDir.listFiles(); //获取指定目录下的所有File对象
		for (File file : files) {
			if (file.isFile()) {
				 //复制  srcDir -->D:\\180416  拼接  D:\\180416\\XXXX.doc文件
				//    targetDir-->E:\\180416 拼接 E:\\180416\\XXXX.doc文件
				copyFile(new File(srcDir+"\\"+file.getName()), new File(targetDir+"\\"+file.getName()));
			}else{
				//继续调用该方法，使用递归实现
				copyDir(new File(srcDir+"\\"+file.getName()), new File(targetDir+"\\"+file.getName()));
			}
		}
	}

要传入copyFile方法的参数是文件 不是只能传文件吗 又传入"\\"是干什么的  还有file.getName 完全不懂

老师，打印的结果怎么会是请输入一个分数80，分数为[0],等级为[1]

a = int(input("请输入一个分数"))
b =""
if a>100 or a<0:
    a = int(input("输入的错误有误，请重新输入"))
else:
    if a<60:
        b = 'E'
    elif a>=60:
        b = 'D'
    elif a>=70:
        b = 'c'
    elif a>=80:
        b = 'B'
    else:
        b = "A"
    print("分数为[0],等级为[1]".format(a,b))

老师，遍历的时候，像这样也可以打出来，但是结果和您的好像不太一样。您那个是一维和二维的地址下表都用到了，在这儿我只用了一维地址的下标，不知道我的理解有没有错误，这两者最后的结果应该是一样的吧？