1、详细阐述一下Collection接口所包含的内容

                   ArrayList----按顺序存放数据(Vector的替代者)

            List   LinkList-----按顺序存放数据的链表            允许重复存放

                   Vector--------按顺序存放数据（线程安全的）

Collection

                   HashSet ---根据HashCode()和equals()方法来判断是否有重复

            Set    实现Set接口的集合不允许重复存放数据

        SortedSet(Interface)----TreeSet 通过实现Comparable接口和

                               Comparator接口而具有排序功能的集合

2、子类与父类之间的变量初始化的顺序。请看下列程序

package ch;

class Super{

int i=10;

Super(){

print();

i=20;

}

void print(){

System.out.println(i);

}

}

public class Sub extends Super{

int j=30;

Sub(){

print();

j=40;

}

void print(){

System.out.println(j);

}

public static void main(String[] args){

System.out.println(new Sub().j);

}

}

运行结果为0、30、40。

变量初始化的过程为（1）、申请空间 （2）、默认初始化 （3）、定义初始化 （4）、构造器初始化。如果有子类与父类，肯定是先加载父类。

3、动态绑定

从概念上的理解是不同的类对与同一消息做出的不同的响应。

从代码实现的角度是：

abstract public class Shape{

    abstract public void draw();

   

    abstract public  void draw(String title);

   

}

public class Rectangle extends Shape{

    public void draw(){

System.out.println("a rectangle");

    }

    public void draw(String title){

System.out.println("a rectangle named " + title);

    }

}

public class Circle extends Shape{

    public void draw(){

System.out.println("a circle");

    }

    public void draw(String title){

System.out.println("a circle named " + title);

    }   

}

public class ShapeTest{

    public static void draw(Shape shape){

shape.draw();

    }

    public static void draw(Shape shape, String title){

shape.draw(title);

    }

    public static void main(String[] args){

Shape shape = new Circle();

draw(shape);

draw(shape, "circle");

System.out.println("********************");

shape = new Rectangle();

draw(shape);

draw(shape, "rectangle");

    }

}

以上代码实现了动态绑定。动态绑定的重点在于（1）、Static的方法取决于编译类型（2）、非Static的方法取决于运行类型（3）、变量取决于编译类型。

4、sleep()和wait()有什么区别？

   sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

   wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

5、Override和Overload的区别？

   方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overload的一些限制条件：（1）、方法名和参数和返回类型必须相同（2）、异常不能扩大（3）、可见范围不能缩小（4）、不能有final的修饰符（5）、Static的方法将被隐藏。Override的一些限制条件：（1）、方法名必须相同（2）、参数必须不同（3）、返回类型可以不同

6、String和StringBuffer的区别？

   JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。

7、OOAD中的Association、Aggregation、Composition的区别？

   三者从概念上来讲：Association是一般的关联，有”use a”的含义。Aggregation和Composition都有整体和部分的关系，其中Aggregation中的部分脱离了整体，部分仍然有意义，有”has a”的含义，是共享式的。而Composition中的部分脱离了整体，部分将没有任何意义，是独占式的。

   从代码实现的角度上讲：三者都是以属性出现，其中Association中作为属性出现时，不需要对其进行强制赋值，只要在使用是对其进行初始化即可。Aggregation中作为属性出现时，需要在构造器中通过传递参数来对其进行初始化。Composition中  作为属性出现时，需要在整体的构造器中创建部分的具体实例，完成对其的实例化。

   从数据库的层面上来讲：Association不需要被级联删除，Aggregation不需要被级联删除，Composition是需要被级联删除的。

   下面通过一个例子来更深刻的理解这三者的区别。

//Association relationship

public class Student{

  private String name;

  private int age;

  BasketBall aBall;

  public Student( String name, int age){

    this.name=name;

    this.age=age;

  }

  public void getBall(BasketBall aBall){

     this.aBall=aBall;

  }

  public void play(){

   System.out.println("I am playing basketball"+aBall);

  }

}

class BasketBall{

  private Color aColor;

  private int size;

  public BasketBall(Color aColor, int size){

    this.aColor=aColor;

    this.size=size;

  }

}  

  

class StudentAdmin{

  public static void main(String aa[]){

    Student aStudent=new Student("eter", 22);

    BasketBall aBasketBall=new BasketBall(Color.red, 32);

    aStudent.getBall(aBasketBall);

    aStudent.play();

  }

}

//Aggregation relationship

public class Computer{

  private String cpu;

  private float weight;

  private Monitor aMonitor;

  public Computer(String cpu, float weight, Monitor aMonitor){

    this.cpu=cpu;

    this.weight=weight;

    this.aMonitor=aMonitor;

  }

  public void turnOn(){    System.out.println("I am on now");  }

}

class Monitor{

  private int inch;

  private boolean isFlat;

  //no information of computer

  public Monitor(int inch, boolean isFlat){

    this.inch=inch;

    this.isFlat=isFlat;

  }

}

class ComputerAdmin{

  public static void main(String aa[]){

    Monitor aMonitor=new Monitor(17, true);  

    System.out.println("I do something others here");

    Computer aComputer=new Computer(486, 32.0, aMonitor);

    System.out.println("Computer is :"+aComputer);

    aComputer.turnOn();

  }

}

//Composition

public class Computer{

  private String cpu;

  private float weight;

  private Monitor aMonitor;

  public Computer(String cpu, float weight, int inch, boolean isFlat){

    this.cpu=cpu;

    this.weight=weight;

    this.aMonitor=new Monitor(inch, isFlat);

  }

  public void turnOn(){    System.out.println("I am on now");  }

}

class Monitor{

  private int inch;

  private boolean isFlat;

  //no information of computer

  public Monitor(int inch, boolean isFlat){

    this.inch=inch;

    this.isFlat=isFlat;

  }

}

class ComputerAdmin{

  public static void main(String aa[]){

    //Monitor aMonitor=new Monitor(17, true);  

    Computer aComputer=new Computer(486, 32.0, 17, true);

    System.out.println("Computer is :"+aComputer);

    aComputer.turnOn();

  }

}

8、数据连接池的工作机制是什么?

   J2EE服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。

客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。

9、说出Servlet的生命周期，并说出Servlet和CGI的区别。

Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。

     与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。