容器中有两个同名hello对象，如果用list.remove("hello"),为何默认删除索引是0的这个，如果要删除后面的hello只能根据索引删除吗？

package string;


import java.util.List;
import java.util.ArrayList;
import java.util.Scanner;

public class TestArrayList {
    public static void main(String[] args) {
        //创建集合对象，接口new实现类
        List list = new ArrayList();
        //1.添加add(Object obj)
        list.add("hello");
        list.add(123);//自动装箱

        //2.集合中元素的个数size()
        System.out.println(list.size());
        System.out.println("集合是否为空"+list.isEmpty());
        //3.addAll(collection c)集合中元素添加到其他集合中
        List list2=new ArrayList();
        list2.add("hello");
        list2.add(123);
        list.addAll(list2);
        System.out.println(list);
        System.out.println("集合中元素个数"+list.size());
        //4.删除
        System.out.println("根据对象去删除");
        list.remove("hello");
        System.out.println(list);
        list.remove(new Integer(123));//索引
        System.out.println(list);
        list.remove(0);//根据索引去删除
        System.out.println(list);
        list.add("world");
        System.out.println(list);
    }
}

后面结束了吗？IDEA操作GIT还没有讲

eve.target.contentwindow.name,老师能解释视频当中的contentwindow是啥意思吗？

老师，我之前安装的Nginx没有安装这个。我怎么在已经安装完成的Nginx上，加上下面的这个配置

public class FlyCar extends SuperCar {

    public FlyCar(Icar car) {
        super(car);
    }
}

还有supercar的子类fiycar中   为什么必须要有这样的构造方法呢   参数为什么必须是父类对象构造方法的参数呢

 public FlyCar(Icar car) {
        super(car);
    }

private Icar car;

这个语句是不是就是创建了对象 只不过没有调用构造方法

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

}

调用flycar中的move方法，会先调用父类的move方法 但是父类supercar中的move方法是Icar的变量啊  为什么会输出car的move方法呢   supercar和car没有关系啊

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

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();//调用写对象的方法

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