ilvest

JAVA技术面试题

一、 Java基础部分

第一天

1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。

2、 Java有没有goto?

java中的保留字，现在没有在java中使用。

3、说说&和&&的区别。

&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。

&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str != null && !str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&&改为&，则会抛出NullPointerException异常。If(x==33 & ++y>0) y会增长，If(x==33 && ++y>0)不会增长

&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。

备注：这道题先说两者的共同点，再说出&&和&的特殊之处，并列举一些经典的例子来表明自己理解透彻深入、实际经验丰富。

4、 Java中的“短路”是指什么

在java逻辑运算中使用逻辑运算符||与&&时将采取“短路”运算。举一个例子

if(a>0||a<1){

//代码1....

}

上面一段代码的执行过程是当a满足大于0的时候将不会再执行后面的a<1代码，这就是“短路”。

5、在JAVA中如何跳出当前的多重嵌套循环？

在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break 语句，即可跳出外层循环。例如，

ok://定义的标号

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

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

System.out.println(“i=” + i + “,j=” + j);

if(j == 5) {

break ok;//跳出到指定的标号

}

另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。

int arr[][] = {{1,2,3},{4,5,6,7},{9}};

boolean found = false;

for(int i=0;i

for(int j=0;j

System.out.println(“i=” + i + “,j=” + j);

if(arr[i][j] == 5){

found = true;

break;

}

6、 switch（expression）语句中的expression（表达式）可以是什么类型?

在switch（expression）中，expression只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。

7、 short s = 1; s = s + 1;有什么错? short s = 1; s += 1;有什么错?

对于short s = 1; s = s + 1; 由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。

对于short s1 = 1; s1 += 1;由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。

8、 char型变量中能不能存贮一个中文汉字?为什么?

char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

备注：后面一部分回答虽然不是在正面回答题目，但是，为了展现自己的学识和表现自己对问题理解的透彻深入，可以回答一些相关的知识，做到知无不言，言无不尽。

9、用最有效率的方法算出2乘以8等于几?

最有效率的计算方式：int result = 2 << 3;

因为将一个数左移n位(二进制移位运算)，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算是cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2 << 3。

10、冒泡排序实现

口诀：n个数字来比较，外层循环N-1，内层循环N-1-i，两两相比小靠前。

代码示例：

public static void main(String[] args) {

int[] number=new int[]{22,12,33,45,66};

int temp;

//冒泡排序

for(int i=0;i

for(int j=0;j

if(number[j]>number[j+1]){

temp=number[j+1];

number[j+1]=number[j];

number[j]=temp;

}

11、 "=="和equals方法究竟有什么区别？

（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则很难说清楚）

==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。

如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();引用变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。

equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：

String a=new String("foo");

String b=new String("foo");

两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。

在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = new String(“quit”); input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。

如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：

boolean equals(Object o){

return this==o;

}

这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须重写equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

12、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

对。

如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。

如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，我们没有理由不实现，通常都会去实现的。

13、写出Object类中定义的方法。

1) clone()：创建并返回此对象的一个副本。

2) equeals(Object obj)：指示某个其他对象是否与此对象“相等”。

3) finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

4) getClass()：返回一个对象的运行时类。

5) hashCode()：返回该对象的哈希码值。

6) notify()：唤醒在此对象监视器上等待的单个线程。

7) notifyAll：唤醒在此对象监视器上等待的所有线程。

8) toString()：返回该对象的字符串表示。

9) wait()：导致当前的线程等待，直到其他线程调用此对象的notify方法或notifyAll()方法

10) wait(long timeout):wait方法的overload方法。

11) wait(long timeout,int nanos):wait方法的overload方法。

14、 hashCode方法的作用？

hashcode这个方法是用来鉴定2个对象是否相等的。那你会说，不是还有equals这个方法吗？

不错，这2个方法都是用来判断2个对象是否相等的。但是他们是有区别的。

一般来讲，equals这个方法是给程序员编码时调用的，如果你想判断2个对象是否相等，你可以重写equals方法，然后在代码中调用，就可以判断他们是否相等了。简单来讲，equals方法主要是用来判断从表面上看或者从内容上看，2个对象是不是相等。举个例子，有个学生类，属性只有姓名和性别，那么我们可以认为只要姓名和性别相等，那么就说这2个对象是相等的。

hashcode方法一般程序员编码时不会去调用，比如在hashmap中，由于key是不可以重复的，它在判断key是不是重复的时候就判断了hashcode这个方法，而且也用到了equals方法。这里不可以重复是说equals和hashcode只要有一个不等就可以了！所以简单来讲，hashcode相当于是一个对象的编码，就好像文件中的MD5（一种唯一标识文件的加密代码），它和equals不同就在于他返回的是int型的，比较起来不直观。我们一般在重写equals的同时也要重写hashcode，让它们的逻辑一致。举个例子，还是刚刚的例子，如果姓名和性别相等就算2个对象相等的话，那么hashcode的方法也要返回姓名的hashcode值加上性别的hashcode值，这样从逻辑上，它们就一致了。

要从物理上判断2个对象是否相等，用==就可以了。

15、写clone()方法时，通常都有一行代码，是什么？

clone方法就是克隆，用于复制对象。clone 有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

16、静态变量和实例变量的区别？

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。

public class VariantTest{

public static int staticVar = 0;

public int instanceVar = 0;

public VariantTest() {

staticVar++;

instanceVar++;

System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);

}

备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！

17、谈谈你对static关键词的理解

通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法，声明为static的方法有以下几条限制：

1) 它们仅能调用其他的static 方法。

2) 它们只能访问static数据。

3) 它们不能以任何方式引用this 或super。

声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间。

18、是否可以从一个static方法内部发出对非static方法的调用？

不可以。

因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部发出对非static方法的调用。

19、 Integer与int的区别

int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。

例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。

在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为了int类型，还需要在hbm映射文件中设置其unsaved-value属性为0。

另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数Integer.parseInt(“数字字符串”);

Integer中还定义了表示整数的最大值和最小值的常量。

20、 Math.round(11.5)等於多少? Math.round(-11.5)等于多少?

Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应，例如，ceil的英文意义是天花板，该方法就表示向上取整(就是往大值靠拢)，所以，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，所以，Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。

第二天

21、请说出作用域public，private，protected，以及不写时的区别

这四个作用域的可见范围如下表所示。

说明：如果在修饰的元素上面没有写任何访问修饰符，则表示default (friendly)。

作用域	当前类	同一包内	子孙类	其他包
public	√	√	√	√
protected	√	√	√	×
default(不写)	√	√	×	×
private	√	×	×	×

备注：只要记住了有4种访问权限，4个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。

22、 public、protected和private这些访问权限修饰词的作用

1) public修饰的字段、属性可被所有的访问。

2) protected修饰的字段、属性只能被本类、本包以及其子类的访问。

3) private修饰的字段、属性只可以被本类访问。

23、 Overload和Override的区别。Overload的方法是否可以改变返回值的类型?

Overload是重载的意思，Override是覆盖的意思，也就是重写。

重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）,与方法的作用域和返回类型无关。

重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。

子类重写父类的方法时，不能扩大方法的异常范围，即只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。

子类重写父类的方法时，不能缩小作用范围，子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，此时根本不属于重写方法的概念，相当于子类中增加了一个全新的方法。

扩展性回答：(请理解这些概念)

至于Overloaded的方法是否可以改变返回值的类型这个问题，要看你倒底想问什么呢？这个题目很模糊。如果几个Overloaded的方法的参数列表不一样，它们的返回者类型当然也可以不一样。但我估计你想问的问题是：如果两个方法的参数列表完全一样，是否可以让它们的返回值不同来实现重载Overload。这是不行的，我们可以用反证法来说明这个问题，因为我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，例如，我们调用map.remove(key)方法时，虽然remove方法有返回值，但是我们通常都不会定义接收返回结果的变量，这时候假设该类中有两个名称和参数列表完全相同的方法，仅仅是返回类型不同，java就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断。

24、什么是override？

override也可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类重写父类中的方法。重写方法时要注意以下的几点：

1、重写的方法的标志必须要和被重写的方法的标志完全匹配，才能达到重写的效果；

2、重写的方法的返回值必须和被重写的方法的返回一致

3、重写的方法所抛出的异常必须和被重写方法的所抛出的异常一致，或者是其子类

4、被重写的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行重写。

25、什么是overload？

overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：

1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；

2、不能通过访问权限、返回类型、抛出的异常进行重载；

3、方法的异常类型和数目不会对重载造成影响；

4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。

26、说说has a与is a的区别。

答：is-a表示的是属于的关系。比如兔子属于一种动物（继承关系）。

has-a表示组合，包含关系。比如兔子包含有腿，头等组件（关联关系或聚集和聚合关系）；

27、一个房子里有椅子，椅子有腿和背，房子与椅子是什么关系，椅子与腿和背是什么关系？

如果房子有多个椅子，就是聚集关系，否则是一种关联关系，当然，聚集是一种特殊的关联。椅子与腿和背是组合（聚合）关系。

28、什么是参数?和参数化的意义?

参数:就是用来代替一个数的未知数，参数就是一个符号，没有实际意义，要让它有实际意义，就给参数赋一个值就可以了，例如定义一个方法来计算两个数字的和，那么该方法就必须定义2个参数表示用来计算的数字，但是只有当调用该方法时，给该方法的两个参数赋值后才能真正执行该方法，例如定义了int add(int a,int b)方法，只有调用时用具体的数字代替掉参数后，才能真正执行并获得结果，例如int result = add(2,3),最终得到结果为5.

参数化的意义：在数据库调用中，参数化能有效的防止注入式攻击，在程序方法中，参数化能避免泄露程序运行的机制与原理，也降低了方法冗余，提高代码的可读性！

29、 OOA和OOD是什么?

OOA：

Object-Oriented Analysis（面向对象分析方法）是确定需求或者业务的角度，按照面向对象的思想来分析业务。例如：OOA只是对需求中描述的问题，进行模块化的处理，描述问题的本质，区别每个问题的不同点相同点，确定问题中的对象。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上,针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。

OOD：

面向对象设计（Object-Oriented Design，OOD）方法是OO方法中一个中间过渡环节。其主要作用是对OOA分析的结果作进一步的规范化整理，以便能够被OOP直接接受。

30、构造器Constructor（构造方法）是否可被override(重写)?

构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

31、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？

接口可以继承接口。抽象类可以实现(implements)接口，抽象类可以继承具体类。抽象类中可以有静态的main方法。

备注：只要明白了接口和抽象类的本质和作用，这些问题都很好回答，你想想，如果你是java语言的设计者，你是否会提供这样的支持，如果不提供的话，有什么理由吗？如果你没有道理不提供，那答案就是肯定的了。

只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。

32、面向对象的特征有哪些方面

计算机软件系统是现实生活中的业务在计算机中的映射，而现实生活中的业务其实就是一个个对象协作的过程。面向对象编程就是按现实业务一样的方式将程序代码按一个个对象进行组织和编写，让计算机系统能够识别和理解用对象方式组织和编写的程序代码，这样就可以把现实生活中的业务对象映射到计算机系统中。

面向对象的编程语言有封装、继承、多态等3个基本特征。

1封装：

封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。通常情况下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了，就基本上算是会面向对象的编程了。把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。

例如，人要在黑板上画圆，这一共涉及三个对象：人、黑板、圆，画圆的方法要分配给哪个对象呢？由于画圆需要使用到圆心和半径，圆心和半径显然是圆的属性，如果将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，它才能访问到圆心和半径这两个属性，人以后只是调用圆的画圆方法、表示给圆发给消息而已，画圆这个方法不应该分配在人这个对象上，这就是面向对象的封装性，即将对象封装成一个高度自治和相对封闭的个体，对象状态（属性）由这个对象自己的行为（方法）来读取和改变。一个更便于理解的例子就是，司机将火车刹住了，刹车的动作是分配给司机，还是分配给火车，显然，应该分配给火车，因为司机自身是不可能有那么大的力气将一个火车给停下来的，只有火车自己才能完成这一动作，火车需要调用内部的离合器和刹车片等多个器件协作才能完成刹车这个动作，司机刹车的过程只是给火车发了一个消息，通知火车要执行刹车动作而已。

此外设计类的过程就是抽象。抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那就是抽象。抽象包括行为抽象和状态抽象两个方面。例如，定义一个Person类，如下：

class Person{

String name;

int age;

}

人本来是很复杂的事物，有很多方面，但因为当前系统只需要了解人的姓名和年龄，所以上面定义的类中只包含姓名和年龄这两个属性，这就是一种抽像，使用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解就是不要用显微镜去看一个事物的所有方面，这样涉及的内容就太多了，而是要善于划分问题的边界，当前系统需要什么，就只考虑什么。

2继承：

在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

3多态：

多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。例如，下面代码中的UserDao是一个接口，它定义引用变量userDao指向的实例对象由daofactory.getDao()在执行的时候返回，有时候指向的是UserJdbcDao这个实现，有时候指向的是UserHibernateDao这个实现，这样，不用修改源代码，就可以改变userDao指向的具体类实现，从而导致userDao.insertUser()方法调用的具体代码也随之改变，即有时候调用的是UserJdbcDao的insertUser方法，有时候调用的是UserHibernateDao的insertUser方法：

UserDao userDao = daofactory.getDao();

userDao.insertUser(user);

33、说出一些常用的类，包，接口，请各举5个

类:

1.java.lang.Object

2.java.lang.String

3.java.lang.System

4.java.io.file

5.java.io.FileInputStream

包:

1.java.lang

2.java.io

3.java.swt

4.java.util

5.java.sql

接口:

1.java.util.List

2.java.util.Map

3.java.util.Iterator

4.java.sql.CallableStatement

5.java.lang.Comparable

34、写出JDK中至少5个以上的包名。

1) java.lang包：java的核心类库，包含了运行java程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等，系统缺省加载这个包

2) java.io包：java语言的标准输入/输出类库，如基本输入/输出流、文件输入/输出、过滤输入/输出流等等

3) java.util包：包含如处理时间的date类，处理变成数组的Vector类，以及stack和HashTable类

4) java.lang.reflect包：提供用于反射对象的工具

5) java.net包：实现网络功能的类库有Socket类、ServerSocket类

6) java.sql包：提供使用JAVA编程语言访问并处理存储在数据源（通常是一个关系数据库）中的数据的 API

7) java.awt包：构建图形用户界面(GUI)的类库，低级绘图操作Graphics类，图形界面组件和布局管理如Checkbox类、Container类、LayoutManger接口等，以及界面用户交互控制和事件响应，如Event类

35、 java中实现多态的机制是什么？

靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

36、 abstract class和interface有什么区别?

含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

下面比较一下两者的语法区别：

1) 抽象类可以有构造方法，接口中不能有构造方法。

2) 抽象类中可以有普通成员变量，接口中没有普通成员变量

3) 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4) 抽象类中的抽象方法的访问类型可以是public，protected和默认作用域（不建议使用，因为默认作用域不能被其它包中的子类集成），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5) 抽象类中可以包含静态方法，接口中不能包含静态方法

6) 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

7) 一个类可以实现多个接口，但只能继承一个抽象类。

下面接着再说说两者在应用上的区别：

接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：

public abstract class BaseServlet extends HttpServlet{

public final void service(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException{

//记录访问日志

//进行权限判断

if(具有权限){

try{

doService(request,response);

}

catch(Excetpion e){

//记录异常信息

}

protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException;

//注意访问权限定义成protected，显得既专业，又严谨，因为是专门给子类用的

}

public class MyServlet1 extends BaseServlet{

protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException{

//本Servlet处理具体业务逻辑代码

}

父类方法中间的某段代码不确定，留给子类去实现，就用模板方法设计模式。

备注：这道题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等6个方面逐一去比较回答，接着从第三者继承的角度的回答，特别是最后用了一个典型的例子来展现自己深厚的技术功底。

37、 java的接口和C++虚类的相同和不同之处

C++虚类相当于java中的抽象类，与接口的不同之处是：

1.一个子类只能继承一个抽象类（虚类），但能实现多个接口

2.一个抽象类可以有构造方法，接口没有构造方法

3.一个抽象类中的方法不一定是抽象方法，即其中的方法可以有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有方法声明

4.一个抽象类可以是public、private、protected、default，接口只有public

5.一个抽象类中的方法可以是public、private、protected、default，接口中的方法只能是public和default修饰，实际上都是public的abstract方法

相同之处是：都不能实例化。

补充说明：接口是一类特殊的抽象类，是更抽象的抽象类，你可能这样理解。抽象类是一个不完整的类，接口只是定义了一些功能。

38、 abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

abstract的method 不可以是static的，因为抽象的方法是要被子类实现的，而static与子类扯不上关系！

native方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与abstract混用。例如，FileOutputSteam类要硬件打交道，底层的实现用的是操作系统相关的api实现，例如，在windows用c语言实现的，所以，查看jdk 的源代码，可以发现FileOutputStream的open方法的定义如下：

private native void open(String name) throws FileNotFoundException;

如果我们要用java调用别人写的c语言函数，我们是无法直接调用的，我们需要按照java的要求写一个c语言的函数，又我们的这个c语言函数去调用别人的c语言函数。由于我们的c语言函数是按java的要求来写的，我们这个c语言函数就可以与java对接上，java那边的对接方式就是定义出与我们这个c函数相对应的方法，java中对应的方法不需要写具体的代码，但需要在前面声明native。

关于synchronized与abstract合用的问题，我觉得也不行，因为在我几年的学习和开发中，从来没见到过这种情况，并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且，方法上的synchronized同步所使用的同步锁对象是this，而抽象方法上无法确定this是什么。

39、什么是内部类？Static Nested Class 和 Inner Class的不同。

内部类就是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c语言的全局变量，而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示：

public class Outer{

int out_x = 0;

public void method(){

Inner1 inner1 = new Inner1();

public class Inner2 //在方法体内部定义的内部类

{

public method(){

out_x = 3;

}

Inner2 inner2 = new Inner2();

}

public class Inner1 //在方法体外面定义的内部类

{

}

在方法体外面定义的内部类的访问类型可以是public,protecte,默认的，private等4种类型，这就好像类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其它类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下：

Outer outer = new Outer();

Outer.Inner1 inner1 = outer.new Innner1();

在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其它类是不可见的其它类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其它类访问。这种内部类必须是先定义，后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符。

对于这些细节，只要在eclipse写代码试试，根据开发工具提示的各类错误信息就可以马上了解到。

在方法体内部还可以采用如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义名称：

public class Outer{

public void start(){

new Thread(

new Runable(){

public void run(){};

}

).start();

}

最后，在方法外部定义的内部类前面可以加上static关键字，从而成为Static Nested Class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么区别，只是在编程引用时的语法上有一些差别，它可以定义成public、protected、默认的、private等多种类型，而普通类只能定义成public和默认的这两种类型。在外面引用Static Nested Class类的名称为“外部类名.内部类名”。在外面不需要创建外部类的实例对象，就可以直接创建Static Nested Class，例如，假设Inner是定义在Outer类中的Static Nested Class，那么可以使用如下语句创建Inner类：

Outer.Inner inner = new Outer.Inner();

由于static Nested Class不依赖于外部类的实例对象，所以，static Nested Class能访问外部类的非static成员变量。当在外部类中访问Static Nested Class时，可以直接使用Static Nested Class的名字，而不需要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不需要加上外部类的名字。

在静态方法中定义的内部类也是Static Nested Class，这时候不能在类前面加static关键字，静态方法中的Static Nested Class与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。

备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义方式的语法区别，静态内部类，以及匿名内部类。

40、内部类可以引用它的包含类的成员吗？有没有什么限制？

完全可以。如果不是静态内部类，那没有什么限制！

如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如，下面的代码：

class Outer{

static int x;

static class Inner{

void test(){

syso(x);

}

答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让人家满意，然后再说特殊情况，让人家吃惊。

41、 Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

可以继承其它类或实现其它接口。不仅是可以，而是必须!

42、 jdk中哪些类是不能继承的？

不能继承的是类是那些用final关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是final的，在jdk中System,String,StringBuffer等都是基本类型。

43、 Java是否有过程和函数?

在Java中可以存在过程和函数。在Java中，对于程序的各种功能的实现，都是通过方法实现的；而方法在运行的时候，就被称为过程。Java中的函数有main()，时间函数等。

第三天

44、 String是最基本的数据类型吗?

基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

45、 String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 "Hello"，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：
public class Demo {
private String s;
public Demo {
s = "Initial Value";
}
}
而非s = new String("Initial Value");
后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，它们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。
至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即 StringBuffer。

46、 String类是否可以继承?

String类是final类，不可以继承。

47、 String s = new String("xyz");创建了几个String Object?

如果第一次调用该语句，创建两个对象

第一个：”xyz”对象，对应一个字符串对象，这个对象放在字符串常量缓冲池，常量”xyz”不管出现多少遍，都是字符串常量缓冲池中的那一个。

第二个：new String()对象，每写一遍new String，就创建一个新的对象，它依据那个常量”xyz”对象的内容来创建出一个新String对象。

注意，如果再写一次String s1 = new String("xyz"),此时”xyz”直接从字符串常量缓冲池中获取，此时将只多创建一个String对象。

48、 String 和StringBuffer的区别

JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。String类表示内容不可改变的字符串。而StringBuffer类表示内容可以被修改的字符串。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。

接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。

StringBuffer sbf = new StringBuffer();

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

sbf.append(i);

}

上面的代码效率很高，因为只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象。

String str = new String();

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

str = str + i;

}

在讲两者区别时，应把循环的次数搞成10000，然后用endTime-beginTime来比较两者执行的时间差异，最后还要讲讲StringBuilder与StringBuffer的区别。

String重写了equals方法和hashCode方法，而StringBuffer没有重写equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。

49、 StringBuffer与StringBuilder的区别

StringBuffer和StringBuilder类都表示内容可以被修改的字符串，StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用，那么最好用StringBuffer。

50、数组有没有length()这个方法? String有没有length()这个方法？

数组没有length()这个方法，有length的属性。String有有length()这个方法。

51、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。例如，对于如下语句：

final StringBuffer a=new StringBuffer("immutable");
执行如下语句将报告编译期错误：

a=new StringBuffer("");
但是，执行如下语句则可以通过编译：

a.append(" broken!");

有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：

public void method(final StringBuffer param){

}

实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：

param.append("a");

52、 final关键词有哪些应用

当你在类中定义变量时，在其前面加上final关键字，那便是说，这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。

其初始化可以在两个地方:

一是其定义处，也就是说在final变量定义时直接给其赋值。

二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。

53、 final, finally, finalize的区别。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可重写，类不可继承。

内部类要访问局部变量，局部变量必须定义成final类型，例如，一段代码……

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以重写此方法提供垃圾收集时的其它资源回收，例如关闭文件等。JVM不保证此方法总被调用

54、运行时异常（RuntimeException）与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误，只要是RuntimeException类的子类都属于运行时异常，而不是RuntimeException类的子类的其它异常类都是一般异常或叫做受检异常。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

55、程序中try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被执行？在什么时候被执行？

try-catch-finally的执行顺序是先执行try块中的代码，如果发生异常则进入catch块处理，但是无论是否发生异常都会进入finally块，所以finally块中的代码会在try块中的return语句执行前执行

56、 error和exception有什么区别?

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。 exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况,可以使用异常处理机制处理。

57、 Java中的异常处理机制的简单原理和应用。

异常是指java程序运行时（非编译）所发生的非正常情况或错误，与现实生活中的事件很相似，现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息，可以用一个对象来表示，Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。

Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error 表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。

java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。

提示答题者：就按照三个级别去思考：虚拟机必须宕机（就是挂掉的意思，相当于崩溃）的错误，程序可以死掉也可以不死掉的错误，程序不应该死掉的错误；

58、 java语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别代表什么意义？在try块中可以抛出异常吗?

Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。

throws声明方法有可能抛出的异常

throw手动抛出异常

try catch是内部捕获异常并做自定义处理

finally是无论是否有异常都会被处理的语句，除非在finally前，存在System.exit（整数值）时除外

在try块中可以抛出异常，但是必须catch或者在方法中声明抛出的异常类型（运行时异常除外）。

59、请写出你最常见到的5个runtime exception(运行时异常)。

这道题主要考你的代码量到底多大，如果你长期写代码的，应该经常都看到过一些系统方面的异常，你不一定真要回答出5个具体的系统异常，但你要能够说出什么是系统异常，以及几个系统异常就可以了，当然，这些异常完全用其英文名称来写是最好的，如果实在写不出，那就用中文吧，有总比没有强！

所谓系统异常，就是…..，它们都是RuntimeException的子类，在jdk doc中查RuntimeException类，就可以看到其所有的子类列表，也就是看到了所有的系统异常。我比较有印象的系统异常有：NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException。

第四天

60、介绍Collection框架的结构

答：随意发挥题，天南海北谁便谈，只要让别人觉得你知识渊博，理解透彻即可。

可以从以下的面试题中汇总一下介绍一些经验和心得即可，同时可以结合框架来讲解，例如hibernate中一对多关联属性就使用到了Set集合等等。

61、 Collection（集合）框架中实现比较要实现什么接口

comparable/comparator

62、 ArrayList和Vector的区别

答：这两个类都实现了List接口（List接口继承了Collection接口），它们都是有序集合，即存储在这两个集合中的元素的位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引号取出某个元素，，并且其中的数据是允许重复的，这是HashSet之类的集合的最大不同处，HashSet之类的集合不可以按索引号去检索其中的元素，也不允许有重复的元素（本来题目问的与hashset没有任何关系，但为了说清楚ArrayList与Vector的功能，我们使用对比方式，更有利于说明问题）。

接着才说ArrayList与Vector的区别，这主要包括两个方面：.
（1）同步性：

Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。

备注：对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一诞生就提供了的，它们是线程安全的，ArrayList与HashMap是java2时才提供的，它们是线程不安全的。所以，我们讲课时先讲老的。
（2）数据增长：

ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时，不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，而ArrayList的增长策略在文档中没有明确规定（从源代码看到的是增长为原来的1.5倍）。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。

总结：即Vector增长原来的一倍，ArrayList增加原来的0.5倍。

63、 ArrayList和LinkedList有什么异同之处？

ArrayList。它实现了可变长度的数组，和数组采用相同的存储方式，在内部分配了连续的空间。有点在于遍历元素和随机访问元素的效率比较高。

LinkedList采用链表存储方式，它提供了addFirst(),addLast(),removeFirst(),removeLast(),可以在LinkedList的首部或尾部插入或删除元素。优点在与插入，删除元素的效率比较高。

64、 HashMap和Hashtable的区别

（条理上还需要整理，也是先说相同点，再说不同点）

HashMap是Hashtable的轻量级实现（非线程安全的实现），它们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，在只有一个线程访问的情况下，效率要高于Hashtable。

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey。因为contains方法容易让人引起误解。

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问 Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

就HashMap与HashTable主要从三方面来说。
1.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
2.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
3.值：只有HashMap可以让你将空值作为一个表的条目的key或value

65、 List 和 Map 区别?

List是存储单列数据的集合，Map是存储键和值这样的双列数据的集合，

List中存储的数据是有顺序，并且允许重复；

Map中存储的数据是没有顺序的，键不能重复，值是可以有重复的。

66、 List, Set, Map是否继承自Collection接口?

List，Set是，Map不是

67、 List、Map、Set三个接口，存取元素时，各有什么特点？

这样的题属于随意发挥题：这样的题比较考水平，两个方面的水平：一是要真正明白这些内容，二是要有较强的总结和表述能力。如果你明白，但表述不清楚，在别人那里则等同于不明白。

首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫Collection。Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。

List表示有先后顺序的集合，注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。

Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)返回值为key 所对应的value。另外，也可以获得所有的key的结合，还可以获得所有的value的结合，还可以获得key和value组合成的Map.Entry对象的集合。

List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

HashSet按照hashcode值的某种运算方式进行存储，而不是直接按hashCode值的大小进行存储。例如，"abc" ---> 78，"def" ---> 62，"xyz" ---> 65在hashSet中的存储顺序不是62,65,78。LinkedHashSet按插入的顺序存储，那被存储对象的hashcode方法还有什么作用呢？HashSet集合比较两个对象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。new 两个Student插入到HashSet中，看HashSet的size，实现hashcode和equals方法后再看size。

同一个对象可以在Vector中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往HashSet中却加不了多次的（不支持重复元素）。

68、说出ArrayList,Vector, LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据效率较低，Vector由于使用了synchronized（同步）方法（线程安全），通常性能上较ArrayList差。

LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。

69、如何去掉一个Vector集合中重复的元素，有几种方法

Vector newVector = new Vector();

for (int i=0;i

Object obj = vector.get(i);

if(!newVector.contains(obj);

newVector.add(obj);

}

还有一种简单的方式，HashSet set = new HashSet(vector); 因为Set集合中不允许出现重复元素，会自动去除掉重复对象。

70、 Collection 和 Collections的区别。

Collection是集合类的顶级接口，继承它的接口主要有Set 和List.

Collections是针对集合框架的一个算法工具类，它提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

71、 Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

Set里的元素是不能重复的，在Set集合内部实现元素重复与否的判断是使用equals()方法进行比较的。

两个比较方式的区别是：

1）equals()比较的是对象的值

2）==比较的是对象的内存地址是否相同

72、你所知道的集合类都有哪些？主要方法？

最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按顺序索引访问元素的情形，Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。具体的集合实现类如下：

ArrayList/Vector à List à Collection

HashSet/TreeSet à Set

Propeties à HashTable à Map

TreeMap/HashMap à Map

针对有哪些主要方法的问题，推荐如下回答：

我记的不是方法名，而是思想，我知道它们都有增删改查的方法，但这些方法的具体名称，我记得不是很清楚，对于Set，大概的方法是add,remove, contains；对于Map，大概的方法就是put、remove、containsKey、containsValue等，因为，我只要在开发工具（如Eclipse）中按点操作符，很自然的这些方法就出来了。我记住的一些思想就是List类会有get(int index)这样的方法，因为它可以按顺序取元素，而Set类中没有get(int index)这样的方法。List和Set都可以迭代出所有元素，迭代时先要得到一个Iterator（迭代器）对象，所以，Set和List类都有一个iterator方法，用于返回对应的iterator对象,该对象用于帮助执行遍历集合的功能。Map可以返回三个集合，一个是返回所有的key的集合（keySet方法），另外一个返回的是所有value的集合（values方法），再一个返回的key和value组合成的EntrySet对象的集合（entrySet方法），map也有get方法，参数是key，返回值是key对应的value。

73、实现Map、Set接口有哪些集合

实现Map接口最常见的有HashMap、LinkedMashMap集合

实现Set接口最常见的有HashSet、LinkedHashSet、TreeSet集合

74、列出你知道的容器类(就是指集合类)，简单说明其功能

Java容器类Collection、List、ArrayList、Vector及Map、HashTable、HashMap。

Collection是List、Set两个接口的父接口，

List在Collection上增加了“有序”的特性，而set增加了“唯一”的特性；

Arraylist是有序不唯一的；

Vector(向量类)可以实现类似动态数组的功能，但是又区别于C语言中的概念，因为Java中是不存在“指针”这一概念，相对于Arraylist而言，Vector线程是安全的，也就是说是支持线程同步的，创建了一个Vector类的对象后，可以往其中随意地插入不同的类的对象，既不需顾及类型也不需预先选定向量的容量，并可方便地进行查找；

Map不能包括两个相同的键，它是无序的，但是Map的值是可以重复的；

Hashtable是Dictionary类的子类，缺省是线程同步的，不允许关键字或值为null；HashMap是Map接口的实现类，缺省情况下是非同步的。

75、 Set和List的区别?

List接口对Collection进行了简单的扩充，它的具体实现类常用的有ArrayList和LinkedList。你可以将任何东西放到一个List容器中，并在需要时从中取出。

ArrayList从其命名中可以看出它是一种类似数组的形式进行存储，因此它的随机访问速度极快，而LinkedList的内部实现是链表，它适合于在链表中间需要频繁进行插入和删除操作。在具体应用时可以根据需要自由选择。

Set接口也是Collection的一种扩展，而与List不同的时，在Set中的对象元素不能重复，

也就是说你不能把同样的东西两次放入同一个Set容器中。

它的常用具体实现有HashSet和TreeSet类。HashSet能快速定位一个元素，但是你放到HashSet中的对象需要实现hashCode()方法。而TreeSet则将放入其中的元素按序存放，这就要求你放入其中的对象是可排序的，这就用到了集合框架提供的另外两个实用类Comparable和Comparator。一个类是可排序的，它就应该实现Comparable接口。有时多个类具有相同的排序算法，那就不需要在每个类中分别重复定义相同的排序算法，只要实现Comparator接口即可。

76、集合框架中Collections和Arrays类的作用

集合框架中有两个很实用的公用类：

Collections和Arrays。Collections提供了对一个Collection容器进行诸如排序、复制、查找和填充等一些非常有用的方法，Arrays则是对一个数组进行类似的操作。

77、 TreeSet里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类还是子类的compareTo方法

（应该是没有针对问题的确切的答案），当前的add方法放入的是哪个对象，就调用哪个对象的compareTo方法(基于多态的理解)，至于这个compareTo方法怎么做，就看当前这个对象的类中是如何编写这个方法的

78、数据结构中，数组与链表有哪些区别？为什么？

数组就像身上编了号站成一排的人，要找第10个人很容易，根据人身上的编号很快就能找到。但插入、删除慢，要望某个位置插入或删除一个人时，后面的人身上的编号都要变。当然，加入或删除的人始终末尾的也快。

链表就像手牵着手站成一圈的人，要找第10个人不容易，必须从第一个人一个个数过去。但插入、删除快。插入时只要解开两个人的手，并重新牵上新加进来的人的手就可以。删除一样的道理。

第五天

79、 java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？

java中主要有四种流：字节输入流、字节输出流、字符输入流、字符输出流。

字节输入流继承InputStream，字节输出流继承OutputStream，

字符输入流继承Reader，字符输出流继承Writer。

流主要定义在java.io包中，还有许多其它的流类型，都是以上四种流的子类，主要是为了提高性能和使用方便。

80、字节流与字符流的区别

要把一段二进制数据逐一输出到某个设备中，或者从某个设备中逐一读取一段二进制数据，不管输入输出设备是什么，我们要用统一的方式来完成这些操作，用一种抽象的方式进行描述，这个抽象描述方式起名为IO流，对应的抽象类为OutputStream和InputStream ，不同的实现类就代表不同的输入和输出设备，它们都是针对字节进行操作的。

在应用中，经常要完全是字符的一段文本输出去或读进来，用字节流可以吗？计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符，首先要得到其对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符。由于这样的需求很广泛，人家专门提供了字符流的包装类。

底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入。字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，这为我们向IO设别写入或读取字符串提供了一点点方便。

字符向字节转换时，要注意编码的问题，因为字符串转成字节数组，

其实是转成该字符的某种编码的字节形式，读取也是反之的道理。

81、什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。

我们有时候要将一个java对象变成字节流的形式传出去或者从一个字节流中恢复成一个java对象，例如，要将java对象存储到硬盘或者传送给网络上的其他计算机，这个过程我们可以自己写代码去把一个java对象变成某个格式的字节流再传输，但是，java虚拟机本身就提供了这种支持，我们可以调用OutputStream的writeObject方法来做，如果要让java 帮我们做，要被传输的对象必须实现serializable接口，这样，javac编译时就会进行特殊处理，编译的类才可以被writeObject方法操作，这就是所谓的序列化。需要被序列化的类必须实现Serializable接口，该接口是一个mini接口，其中没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。

例如，在web开发中，如果对象被保存在了Session中，Tomcat在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi等远程调用，这就需要在网络上传输对象，被传输的对象就必须实现Serializable接口。

82、序列化的概念和序列化ID的作用？

对象经常要通过I/O(输入输出设备)进行传送，让你写程序传递对象，你会怎么做？把对象的状态数据用某种格式写入到硬盘，Person->“zxx,male,28,30000”àPerson，既然大家都要这么干，并且没有个统一的干法，于是，sun公司就提出一种统一的解决方案，它会把对象变成某个格式进行输入和输出，这种格式对程序员来说是透明（transparent）的，但是，我们的某个类要想能被sun的这种方案处理，必须实现Serializable接口。

ObjectOutputStream.writeObject(obj);//对象输出流保存对象，要使用序列化操作

Object obj = ObjectInputStream.readObject();//对象输入流读取对象，使用反序列化操作

序列化id的作用是什么呢，用以下场景来解释它的作用：

假设两年前我保存了某个类的一个对象，这两年来，我修改该类（类名保持不变），删除了某个属性和增加了另外一个属性，两年后，我又去读取那个保存的对象，会有什么结果？Sun的jdk无法获知你保存的对象到底是未修改前的类的对象还是修改后的类的对象。为此，一个解决办法就是在类中增加版本号信息，每一次类的属性修改，都应该把版本号升级一下，这样，在读取时，比较存储对象时的版本号与当前类的版本号，如果不一致，则直接报版本号不同的错!，此处的版本号其实就是序列化ID

83、描述一下JVM（JAVA虚拟机）加载class文件的原理机制?

JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

84、 ClassLoader（类加载器）如何加载class 。

JVM（JAVA虚拟机）里有多个类加载器，每个类加载器可以负责加载特定位置的类，例如，bootstrap类加载器负责加载jre/lib/rt.jar中的类，我们平时用的jdk中的类都位于rt.jar中。extclassloader负责加载jar/lib/ext/*.jar中的类，appclassloader负责classpath指定的目录或jar中的类。除了bootstrap之外，其他的类加载器本身也都是java类，它们的父类是ClassLoader。

85、能不能自己写个类，也叫java.lang.String？

可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。由于在tomcat的web应用程序中，都是由webapp自己的类加载器先自己加载WEB-INF/classess目录中的类，然后才委托上级的类加载器加载，如果我们在tomcat的web应用程序中写一个java.lang.String，这时候Servlet程序加载的就是我们自己写的java.lang.String，但是这么干就会出很多潜在的问题，原来所有用了java.lang.String类的都将出现问题。

86、 heap和stack有什么区别。

java的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。

堆是与栈作用不同的内存，一般用于存放那些不存入当前方法栈中的那些数据，例如，使用new创建的对象都放在堆里，所以，它不会随方法的结束而消失。此外，方法中的局部变量使用final修饰后，放在堆中，而不是栈中。

87、解释内存中的栈(stack)、堆(heap)和静态储存区的用法

栈：

1) 每个线程包含一个栈区,栈中只保存基础数据类型对的象和自定义对象的引用(不是对象)，对象都存放在堆区中

2) 每个栈中的数据都是私有的，其他栈不能访问

3) 栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区

4) 由编译器自动分配释放，存放函数的参数值，局部变量的值等

堆：

1) 存储的全是对象，每个对象都包含一个与之对应的class信息

2) jvm(Java虚拟机)只有一个堆区被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身

3) 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收

静态储存区：

1) 静态区又叫方法区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量

2) 方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量

3) 全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域

88、 GC是什么? 为什么要有GC?

GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法，回收内存的工作完全由JVM控制。

89、 Java内存动态管理机制

分配：内存的分配是由程序完成的，程序员需要通过关键字new 为每个对象申请内存空间 (基本类型除外)，所有的对象都在堆 (Heap)中分配空间。所有的声明的基本数据类型变量都存储在栈内存中

释放：对象的释放是由垃圾回收机制决定和执行的，这样做确实简化了程序员的工作。但同时，它也加重了JVM的工作。因为，GC为了能够正确释放对象，GC必须监控每一个对象的运行状态，包括对象的申请、引用、被引用、赋值等，GC都需要进行监控。

90、垃圾回收的优点和原理。并考虑2种回收机制。

Java语言中一个显著的特点就是引入了垃圾回收机制，使C++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。垃圾回收可以有效的防止内存泄露，有效的使用内存。垃圾回收器通常是作为一个单独的低级别的线程（后台线程）运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有引用计数和对象引用遍历两种。

以下为扩展内容：（选择记忆即可）

1）引用计数收集器

引用计数是垃圾收集器中的早期策略。在这种方法中，堆中每个对象（不是引用）都有一个引用计数。当一个对象被创建时，且将该对象分配给一个变量，该变量计数设置为1。当任何其它变量被赋值为这个对象的引用时，计数加1，但当一个对象的某个引用超过了生命周期或者被设置为一个新值时，对象的引用计数减1。任何引用计数为0的对象可以被当作垃圾收集。当一个对象被垃圾收集时，它引用的任何对象计数减1。

2）跟踪收集器

早期的JVM使用引用计数，现在大多数JVM采用对象引用遍历。对象引用遍历从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集。

91、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

1）基本原理（对象引用遍历方式）：对于GC（垃圾收集）来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。

2）垃圾回收器不可以马上回收内存。垃圾收集器不可以被强制执行，但程序员可以通过调研System.gc方法来建议执行垃圾收集。记住，只是建议。一般不建议自己写System.gc，因为会加大垃圾收集工作量

3）程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。

92、 java中会存在内存泄漏吗，请简单描述。

所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。

java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。

检查java中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。

如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。

内存泄露的另外一种情况：当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，造成内存泄露。

93、如何使用log4j记录日志？

(1)在项目中加入log4j所使用的jar文件。

(2)创建log4j.properties文件。

(3)编写log4j.properties文件，配置日志信息。

(4)在程序中使用log4j记录的日志信息。

输出级别的优先级:fatal>error>warn>info>debug

第六天

94、单一职能原则

单一职责原则(SRP)，英文全称是Single Responsibility Principle,该原则的思想是：系统中的每一个类都应该只有一个单独的职责，而所有类所关注的就是自身职责的完成。
SRP中，把职责定义为“变化的原因”。如果你能想到多个原因去改变一个类，那么这个类就具有多于一个的职责。

描述：就一个类而言，应该仅有一个引起它变化的原因。
应用：在构造对象时，将对象的不同职责分离至两个或多个类中，确保引起该类变化的原因只有一个。
带来的好处：提高内聚、降低耦合。

95、开闭原则

1“开-闭”原则的定义及优点

1）定义：一个软件实体应当对扩展开放，对修改关闭( Software entities should be open for extension,but closed for modification.)。即在设计一个模块的时候，应当使这个模块可以在不被修改的前提下被扩展。

2）满足“开-闭”原则的系统的优点

a)通过扩展已有的软件系统，可以提供新的行为，以满足对软件的新需求，使变化中的软件系统有一定的适应性和灵活性。

b)已有的软件模块，特别是最重要的抽象层模块不能再修改，这就使变化中的软件系统有一定的稳定性和延续性。

c)这样的系统同时满足了可复用性与可维护性。

2如何实现“开-闭”原则

在面向对象设计中，不允许更改的是系统的抽象层，而允许扩展的是系统的实现层。换言之，定义一个一劳永逸的抽象设计层，允许尽可能多的行为在实现层被实现。

解决问题关键在于抽象化，抽象化是面向对象设计的第一个核心本质。

对一个事物抽象化，实质上是在概括归纳总结它的本质。抽象让我们抓住最最重要的东西，从更高一层去思考。这降低了思考的复杂度，我们不用同时考虑那么多的东西。换言之，我们封装了事物的本质，看不到任何细节。

在面向对象编程中，通过抽象类及接口，规定了具体类的特征作为抽象层，相对稳定，不需更改，从而满足“对修改关闭”；而从抽象类导出的具体类可以改变系统的行为，从而满足“对扩展开放”。

对实体进行扩展时，不必改动软件的源代码或者二进制代码。关键在于抽象。

3对可变性的封装原则

“开-闭”原则也就是“对可变性的封装原则”（Principle of Encapsulation of Variation ，EVP）。即找到一个系统的可变因素，将之封装起来。换言之，在你的设计中什么可能会发生变化，应使之成为抽象层而封装，而不是什么会导致设计改变才封装。

对可变性的封装原则”意味着：

a)一种可变性不应当散落在代码的许多角落，而应当被封装到一个对象里面。同一可变性的不同表象意味着同一个继承等级结构中的具体子类。因此，此处可以期待继承关系的出现。继承是封装变化的方法，而不仅仅是从一般的对象生成特殊的对象。

b)一种可变性不应当与另一种可变性混合在一起。作者认为类图的继承结构如果超过两层，很可能意味着两种不同的可变性混合在了一起。

使用“可变性封装原则”来进行设计可以使系统遵守“开-闭”原则。

即使无法百分之百的做到“开-闭”原则，但朝这个方向努力，可以显著改善一个系统的结构。

96、里氏替代原则

定义：如果对每一个类型为T1的对象O1，都有类型为T2 的对象O2，使得以T1定义的所有程序P在所有的对象O1都代换为O2时，程序P的行为没有变化，那么类型T2是类型T1的子类型。即，一个软件实体如果使用的是一个基类的话，那么一定适用于其子类。而且它觉察不出基类对象和子类对象的区别。也就是说,在软件里面,把基类都替换成它的子类,程序的行为没有变化，任何基类可以出现的地方，子类一定可以出现。

反过来的代换不成立，如果一个软件实体使用的是一个子类的话，那么它不一定适用于基类。

97、 Java反射机制

反射机制是Java语言在运行时拥有的一项自观能力，简单来说：它就是通过名称来得到对象(类，属性，方法)的技术。

它获取Class类实例的方法：类名.class、实例名.getClass()、Class.forName(DE);

Class类支持反射的概念，Java附带的库java.lang.reflect包含了Field、Method、以及Constructor类(每个类都实现了Member接口)。这些类的对象是由JVM在运行时创建的，用以表示类里对应的成员。这样可以使用Constructor创建新的对象，用get()和set()方法读取和修改于Field对象关联的字段，用invoke()方法调用与Method对象关联的方法。另外，还可以调用getFields(),getMethods,getConstructors()方法，返回表示字段，方法以及构造器的对象数组。

98、线程的基本概念、线程的基本状态以及状态之间的关系

一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行，每个程序至少都有一个线程，即main方法执行的那个线程。如果只是一个cpu，它怎么能够同时执行多段程序呢？这是从宏观上来看的，cpu一会执行a线索，一会执行b线索，切换时间很快，给人的感觉是a,b在同时执行，好比大家在同一个办公室上网，只有一条链接到外部网线，其实，这条网线一会为a传数据，一会为b传数据，由于切换时间很短暂，所以，大家感觉都在同时上网。

状态：就绪，运行，synchronize阻塞，wait和sleep挂起，结束。wait必须在synchronized内部调用。

调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到synchronized语句时，由运行状态转为阻塞，当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。

99、同步和异步有何异同，在什么情况下分别使用他们？举例说明。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

100、 Java中有几种实现方法多线程，都是什么？用什么方法启动该线程

1) 继承Thread类，重写run函数

开启线程：对象.start()

2) 实现Runnable接口，重写run函数

开启线程：Thread t = new Thread(Runnable对象)

t.start()//启动线程

101、多线程有几种实现方法?同步有几种实现方法?

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口

同步的实现方面有两种，分别是synchronized,wait与notify

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

102、启动一个线程是用run()还是start()? .

启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码,run()方法可以产生必须退出的标志来停止一个线程。

103、 java中有几种方法可以实现一个线程？用什么关键字修饰同步方法?

1）实现线程的方式：JDK1.5以前，有如下两种：

第一种：继承Thread类

第二种：实现Runnable接口

JDK1.5开始，可以使用线程池创建线程实例：

2）用synchronized关键字修饰同步方法

104、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的该方法?

不能，一个对象的一个synchronized（同步）方法只能由一个线程访问.

105、请说出你所知道的线程同步的方法。

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

106、 sleep() 和 wait() 有什么区别?

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间（毫秒数），给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。

107、线程类中的stop()和suspend()方法为何不推荐使用？

反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

二、 Java web部分

第七天

1、什么是Servlet

Servlet是一种服务器端的Java应用程序，具有独立于平台和协议的特性，可以生成动态的Web页面。它承担处理客户请求（Web浏览器或其他HTTP客户程序）与服务器响应（HTTP服务器上的数据库或应用程序）的工作。 Servlet是位于Web 服务器内部的服务器端的Java应用程序，与传统的从命令行启动的Java应用程序不同，Servlet由Web服务器进行加载，该Web服务器必须包含支持Servlet的Java虚拟机。

1、说一说Servlet的生命周期?

servlet有良好的生命周期的定义，包括加载和实例化、初始化、处理请求以及服务结束四个阶段。WEB容器加载Servlet，生命周期开始。首先服务器调用Servlet的构造方法执行实例化操作，然后容器调用Servlet的init方法执行初始化操作，请求到达时运行Servlet的service方法，service方法自动调用与请求类型对应的doXXX方法（doGet，doPost）等来处理请求，当服务器决定将Servlet实例销毁前调用其destroy方法（用于释放Servlet占用资源，例如流、数据库连接等）。

2、 Servlet的基本架构

Servlet的框架是由两个Java包组成:javax.servlet和javax.servlet.http。在javax.servlet包中定义了所有的Servlet类都必须实现或扩展的的通用接口和类，在javax.servlet.http包中定义了支持HTTP通信协议的HttpServlet类。Servlet的框架的核心是javax.servlet.Servlet接口，所有的Servlet都必须实现这一接口。在Servlet接口中定义了5个方法,其中有3个方法代表了Servlet的生命周期：
init方法,负责初始化Servlet对象
service方法,负责相应客户的请求
destory方法,当Servlet对象退出生命周期时,负责释放占有的资源
Servlet被设计成请求驱动（根据请求来调用Servlet）。Servlet的请求可能包含多个数据项,当Web容器接收到某个Servlet请求时,Servlet把请求封装成一个HttpServletRequest对象,然后把对象传给Servlet的对应的服务方法.
HTTP的请求方式包括DELETE,GET,OPTIONS,POST,PUT和TRACE,在HttpServlet类中分别提供了相应的服务方法,它们是doDelete(),doGet(),doOptions(),doPost(), doPut()和doTrace().不过目前很多服务器只支持get和post请求，所以通常自定义的Servlet中只需要重写doPost和doGet方法即可。

3、服务器如何响应Web客户请求？

HttpServlet容器响应Web客户请求流程如下：
1）Web客户向Servlet容器发出Http请求；
2）Servlet容器解析Web客户的Http请求；
3）Servlet容器创建一个HttpRequest对象，在这个对象中封装Http请求信息；
4）Servlet容器创建一个HttpResponse对象；
5）Servlet容器调用HttpServlet的service方法，把HttpRequest和HttpResponse对象作为service方法的参数传给HttpServlet对象；
6）HttpServlet调用HttpRequest的有关方法，获取HTTP请求信息；
7）HttpServlet调用HttpResponse的有关方法，生成响应数据；
8）Servlet容器把HttpServlet的响应结果传给Web客户。

4、 Servlet API中forward() 与sendRedirect ()的区别？（就是请求转发和重定向的区别）？

请求转发：请求转发是指将请求再转发到另一资源（一般为JSP或Servlet）。此过程依然在同一个请求范围内，转发后浏览器地址栏内容不变，请求转发使用RequestDispatcher接口中的forward()方法来实现，该方法可以把请求转发到另外一个资源，并让该资源对浏览器的请求进行响应 RequestDispatcher rd = request.getRequestDispatcher(path); rd.forward(request,response); 或 request.getRequestDispatcher(path) .forward(request,response);

重定向：重定向是指页面重新定位到某个新地址，之前的请求失效，进入一个新的请求，且跳转后浏览器地址栏内容将变为新的指定地址。重定向是通过HttpServletResponse对象的sendRedirect()来实现，该方法相当于浏览器重新发送一个请求 response.sendRedirect(path); • 请求转发和重定向区别如下：

forward()只能将请求转发给同一个Web应用中的组件，而sendRedirect()方法不仅可以重定向到当前应用程序中的其他资源，还可以重定向到其他站点的资源。

请求转发和重定向是Servlet处理完数据后进行页面跳转的两种主要方式

p sendRedirect()方法重定向的访问过程结束后，浏览器地址栏中显示的URL会发生改变，由初始的URL地址变成重定向的目标URL；而调用forward()方法的请求转发过程结束后，浏览器地址栏保持初始的URL地址不变。forward()方法的调用者与被调用者之间共享相同的request对象和response对象；而sendRedirect()方法调用者和被调用者使用各自的request对象和response对象，它们属于两个独立的请求和响应过程。

5、什么情况下调用doGet()和doPost()？

Jsp页面中的form表单标签里的method属性为get时调用doGet()，为post时调用doPost()。

6、 request对象的几个常用方法:

方法名称说明

String getParameter(String name) 根据页面表单组件名称获取页面提交数据

String[] getParameterValues(String name) 获取一个页面表单组件对应多个值时的用户的请求数据

void setCharacterEncoding(String charset) 指定每个请求的编码，在request.getParameter()方法之前进行设定，可以用于解决中问乱码问题

getRequestDispatcher(String path) 返回一个Javax.servlet.RequestDispatcher对象，该对象的forward方法用于转发请求

setAttribute(String name,Object) 设置名字为name的request的参数值

getAttribute(String name) 返回由name指定的属性值

getAttributeNames() 返回request对象所有属性的名字集合，结果是一个枚举的实例

7、什么是Jsp

JSP（Java Server Pages, JSP）是由Sun公司提倡，许多公司共同参与一同建立起来的一种动态网页技术标准，它在动态网页建设中有强大的而特别的功能，它具有跨平台性，易维护性，易管理性等优点。

8、 JSP的执行过程?

1)翻译阶段：

当Web服务器接收到JSP请求时，首先会对JSP文件进行翻译，将编写好的JSP文件通过JSP引擎转换成可识别的Java源代码。

2)编译阶段：

经过翻译后的JSP文件相当于我们编写好的Java源文件，此时仅有Java源文件是不够的，必须要将Java源文件编译成可执行的字节码文件。所以Web容器处理JSP请求的第二阶段就是执行编译。

3)执行阶段：

Web容器接收了客户端的请求后，经过翻译和编译两个阶段，生成了可被执行的二进制字节码文件，此时就进入执行阶段。当执行结束后，会得到处理请求的结果，Web 容器又会再把生成的结果页面返回到客户端用户面前显示。

注意:只有第一次请求JSP页面或者JSP页面内容修改后访问才会执行翻译阶段和编译阶段，所有JSP的执行效率并不低，只是第一次访问页面时会稍微慢一点

9、 JSP页面由哪几部分组成？

JSP页面由：静态内容，指令，表达式，小脚本，声明，标准动作，注释等七种元素构成。

10、在JSP页面中如何定义一个方法？

使用JSP声明来定义方法,语法格式为:<%！ 声明方法或者声明变量 %>。

11、 JSP指令有几种？

JSP指令主要有三种：page指令，include指令，taglib指令

12、 page指令常用属性？

_______________________________________________________________________

属性描述

language 指定JSP页面使用的脚本语言，默认为“Java”

import 通过该属性来引用脚本语言中使用到的类文件

contentType 用来指定JSP页面所采用的编码格式，默认为“text/html;charset=GBK”

_______________________________________________________________________

13、 JSP有哪些内置对象?作用分别是什么? 分别有什么方法？

JSP共有以下9个内置的对象：

request 用户端请求，此请求会包含来自GET/POST请求的参数

response 网页传回用户端的回应

pageContext 网页的属性是在这里管理

session 与请求有关的会话期

application servlet 正在执行的内容

out 用来传送回应的输出

config servlet的构架部件

page JSP网页本身

exception 针对错误网页，未捕捉的例外

request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。

response表示HttpServletResponse对象，并提供了几个用于设置送回浏览器的响应的方法（如cookies,头信息等）

out对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。

pageContext表示一个javax.servlet.jsp.PageContext对象。该对象提供了对JSP页面内所有的对象及名字空间（就是四大作用域空间，如page空间、request空间、session空间、application空间）的访问，也就是说他可以访问到当前请求对应session中保存的信息，也可以取当前应用所在的application的某一属性值，它相当于页面中所有功能的集大成者，包装了通用的servlet相关功能的方法。

session表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息

applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息

config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。

page表示从该页面产生的一个servlet实例

14、 JSP如何处理HTML form（页面表单）中的数据？

使用JSP 中的request内置对象处理HTML 表单中的数据。

15、 JSP有哪些标准动作?作用分别是什么?

JSP主要共有以下几种基本动作

jsp:include：在页面被请求的时候引入一个文件。

jsp:useBean：寻找或者实例化一个JavaBean。

jsp:setProperty：设置JavaBean的属性。

jsp:getProperty：输出某个JavaBean的属性。

jsp:forward：把请求转到一个新的页面。

jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

16、 JSP中动态Include与静态Include的区别？

动态Include用动作实现，它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数

静态Include使用include指令实现,不会检查所含文件的变化，适用于包含静态页面

<%@ include file=”included.htm” %>

17、 JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？

JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于展示内容，Servlet主要用于控制逻辑。

18、如何实现servlet的单线程模式

通过page指令设置<%@ page isThreadSafe="false"%>，默认Servlet支持多线程模式，即有多个客户端同时请求同一个Servlet，服务器上的Servlet只会产生一个实例，但是会启动多个线程来响应客户请求，但是这样会导致线程安全问题，编程时建议不要在Servlet中定义成员属性来共享数据，以避免出现数据同步的问题。

19、在JSP中如何实现页面跳转？

1) 使用javascript中的window.location.href=”要跳转的页面”。

2) 在超链接中:href=”location=要跳转的页面”，例如首页。

3) form表单中提交：action=”要跳转的页面”。

4) 使用jsp内置对象request或response，执行请求转发或重定向来实现页面跳转

20、在servlets和JSP之间能共享session对象吗？

当然可以，session作用域中的内容，可以在多个请求中共享数据。例如可以在Servlet中通过request.getSession()来得到HttpSession对象，然后将相应数据存储到该session对象中，在其它jsp页面上都可以通过内置对象session来获取存入的值,即使这些页面是通过重定向方式跳转过去的，也可以得到值。Session本来就是用来保障在同一客户端和服务器之间多次请求之间的数据能够共享的一种机制。

第八天

21、什么是Cookie？

Cookie，有时也用其复数形式cookies，指某些网站为了辨别用户身份、进行session跟踪而储存在用户本地终端上的数据（通常经过加密）。

Cookie是由服务器端生成，发送给客户端浏览器的，浏览器会将其保存成某个目录下的文本文件。

22、如何设置cookie在某一时间后过期？

使用cookie的setMaxAge方法设置cookie的有效时间

代码如下：

Cookie ipAddrCookie = new Cookie(“inAddr”,””+request.getRemoteAddr());

ipAddrCookie.setMaxAge(60*10);

23、在JSP中如何设置Cookie？

Cookie cookie = new Cookie("cookieName","cookieValue");

其中cookieName为Cookie对象的名称,未来获取Cookie的时候需要使用。cookieValue为Cookie

对象的值也就是储存用户的信息如用户名、密码等。

24、 Cookie的应用场景？

1.对特定对象的追踪，如访问者的访问次数，最后访问时间、路径等

2.统计网页浏览记录。

3.在Cookie有效期内，记录用户登入信息。

4.实现各种个性化服务，如针对不同用户喜好以不同的风格展示不同的内容

提示：由于Cookie保存在客户端，所以使用Cookie存在一定的风险，所以不建议在Cookie中保存比较重要或敏感的内容。

25、 cookie与session有什么区别?

1)session是服务器端保存用户信息，cookie是在客户端保存用户信息。

2)session中保存的是对象，cookie保存的是字符串。

3)session对象随会话结束而关闭，cookie可以长期保存在客户端

4)cookie通常用于保存不重要的用户信息，重要的信息使用session保存。

26、什么是MVC设计模式

MVC模式是一种流行的软件的设计模式,MVC模式将应用程序实现分为3个不同的基本部分.模型,视图和控制器.

模型(Model):表示数据和业务处理.在MVC的三个部件中,模型拥有最多的处理任务.被模型返回的数据是中立的,就是说模型与数据格式无关,这样一个模型能为多个视图提供数据,由于应用于模型的代码只需写一次就可以被多个视图重用,所以减少了代码的重复性.对应的组件是java Bean(java类).

视图(view): 是用户看到并与之交互的界面.MVC一个最大的好处就是它能为应用程序处理很多不同的视图,在视图中其实没有真正的处理发生,不管这些数据是什么,作为视图来讲,它只是作为一种输出数据并允许用户操作的方式.对应的组件是JSP或HTML文件.视图提供可交互的界面,向客户显示模型数据.

控制器(Controller): 接收用户的输入并调用模型组件去完成用户的请求。当用户提交一个请求时,控制器本身不做执行业务处理.它只是接收请求并决定调用哪个模型组件去处理请求,然后确定用哪个视图来显示模型处理返回的数据.对应的组件可以是Servlet. 控制器响应客户的请求,根据客户的请求来操作模型,并把模型的响应结果经由视图展现给客户.

MVC最重要的特点就是把显示和数据分离,提高代码的可重用性.

MVC的处理过程:

首先控制器接收用户的请求,并决定应该调用哪个模型来处理,然后模型处理用户的请求并返回数据,最后控制器确定相应的视图将模型返回的数据呈现给用户.

27、 MVC设计模式的优缺点：

1)优点：

各司其职、互不干涉；

有利于开发中的分工；

有利于组建的重用；

2)缺点：

系统结构和实现复杂；

视图与控制器过于紧密；

不适用于小型甚至中型应用程序；

28、 Web应用的目录结构:

_____________________________________________________________________

目录说明

/ Web应用的根目录，该目录下的所有文件对客户端都可以访问包括JSP、HTML

/WEB-INF 存放应用程序所使用的各种资源，该目录及其子目录对客户端都是不可以访问的，其中包括web.xml（部署表述符）

/WEB-INF/classes 存放应用的所有class文件

/WEB-INF/lib 存放Web应用使用的JAR文件

_____________________________________________________________________

29、 Tomcat的目录结构:

_____________________________________________________________________

目录说明

/bin 存放各种平台下用于启动和停止Tomcat的脚本文件

/conf 存放Tomcat服务器的各种配置文件，其中最重要的文件时server.xml

/lib 存放Tomcat服务器所需的各种JAR文件

/logs 存放Tomcat的日志文件

/temp Tomcat运行时用于存放临时文件

/webapps Web应用的发布目录

/work Tomcat把由JSP生成的Servler放于此目录下

_____________________________________________________________________

30、 Tomcat工作原理？

Tomcat是Servlet运行环境（容器），每个Servlet执行init(),service(),destory()。

下面以分析Tomcat Server处理一个http请求的过程来解释Tomcat原理。

假设来自客户的请求为：http://localhost:8080/wsota/wsota_index.jsp

1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得

2) Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应

3) Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host

4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）

5) localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context

6) Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）

7) path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet

8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类

9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法

10) Context把执行完了之后的HttpServletResponse对象返回给Host

11) Host把HttpServletResponse对象返回给Engine

12) Engine把HttpServletResponse对象返回给Connector

13) Connector把HttpServletResponse对象返回给客户browser

31、什么是URL：

URL，是英文Uniform Resource Locator 的缩写，意思是统一资源定位符，是标准的互联网行资源（图片，Javacript脚本文件等）的地址，是用于完整的描述Internet上网页和其他资源的地址的一种标识方法。简单的说，URL就是我们常说的网址.

32、什么是Session机制

会话的跟踪，就是session机制，Session机制是一种服务器端的机制，服务器使用一种类似于散列表(HashTable)的结构来保存信息，主要用于在整个会话请求过程中共享数据。

Session机制的实现原理：

1) 当程序需要为某个客户端的请求创建session的时候，服务器首先检查这个客户端的请求里是否包含一个session标识，即称为sessionid

2) 如果包含sessionid则说明该客户端创建过session，服务器就会按照sessionid把这个session检索出来使用，如果检索不到，会创建一个新的session对象，并生成一个新的与此session关联的sessionid。

3) 如果客户端请求不包含sessionid，则为此客户端创建一个session并生成一个于此session相关联的sessionid

Sessionid传递的方式有两种：

Cookie方式：服务器分配的sessionid将作为Cookie发送给浏览器，浏览器保存这个Cookie。当再次发送Http请求时，浏览器将Cookie随请求一起发送，服务器从请求对象中读取sessionid，再根据sessionid找到对应的HttpSession对象。

URL重写：当cookie被人禁止的时候，我们就可以使用Url重写的方式把sessionid传递回服务器。就是把sessionid附加在URL路径的后面。附加的方式有两种：一种是作为URL路径的附加信息，一种是作为查询字符串附加在URL后面。

33、四种会话跟踪技术

由于HTTP事务是无状态的，因此必须采取特殊措施是服务器在系列事务期间能继续确定和记住特定用户，这就是会话跟踪的概念。

实现此功能有四种实现技术：

1、用隐藏表单域（）

非常适合不需要大量数据存储的会话应用。

2、URL重写

URL可以在后面附加参数，和服务器的请求一起发送，服务器根据相应的参数来判断是否为同一个客户端发送的请求，一般可以直接使用HTTP会话API执行URL重写，会自动附加相应的sessionid，该技术主要使用场景是客户端的浏览器禁用cookie导致session无法使用的情况。

3、Cookie技术

服务器通过cookie对象来保存session对象的id，用来保证客户端每次发送请求过来都会带上sessionid以保证服务器可以识别不同客户端的请求，是session机制实现的前提，如果用户禁用cookie就只能使用url重写来保证sessionid的传递了。

4、Session技术

根据session对象的sessionid（唯一标识）即可识别不同的客户端请求

34、 Web应用中的四大作用域（注意不要和四种会话跟踪技术搞混淆了）

page是代表与一个页面相关的对象和属性。一个页面由一个编译好的 Java Servlet 类（可以带有任何的 include 指令，但是没有 include 动作）表示。这既包括 servlet 又包括被编译成 servlet 的 JSP 页面
request是代表与Web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个Web 组件（由于 forward 指令和 include 动作的关系）
session是代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常会跨越多个客户机请求
application是代表与整个Web 应用程序相关的对象和属性。这实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域

35、 B/S与C/S的联系与区别

C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、MySQL或 SQL Server。客户端需要安装专用的客户端软件。

B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安装Oracle、Sybase、MySQL或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分业务逻辑在前端实现，但是主要业务逻辑在服务器端实现。浏览器通过Ｗeb Server同数据库进行数据交互。

36、软件系统B/S和C/S架构是什么，它们有什么区别

C/S是Client/Server的缩写（客户机和服务器）结构，B/S是浏览器和服务器结构

C/S架构软件的优势与劣势（特点）：

1) 应用服务器运行数据符合较轻

2) 数据的存储管理功能较为透明

3) 高昂的维护成本且投资大

B/S架构软件的优势与劣势（特点）：

1) 维护升级方式简单

2) 成本降低，选择更多

3) 应用服务器运行数据符合较重

37、 http协议有几种提交方式

常用的有get()、post()两种

38、什么是EL表达式

EL全称 Expression Language ，是一种借鉴了JS和XPath的表达式语言，它定义了一系列隐含对象和操作符，开发人员能方便的访问页面的上下文，以及不同作用域的对象，无需嵌入java代码，即使开发人员不懂java代码，也能轻松编写JSP程序。

EL表达式的语法：${表达式}

39、 EL隐式对象有哪些？

1）.作用域访问对象

pageScope 与页面作用域（page）中属性相关联的Map类

requestScope 与请求作用域（request）中属性相关联的Map类

sessionScope 与会话作用域（session）中属性相关联的Map类

applicationScope 与应用程序作用域（application）中属性相关联的Map类

使用例子：request.setAttribute("Student",stu);当使用EL表达式访问某个属性值时候，应该指定查找范围，如${requestScope.Student}如果不指定查找范围，会按照page->request->session->application的顺序查找

注意：必须将对象保存在作用域中，才可以用EL表达式访问对象。

2）.参数访问对象

param 按照参数名称访问单一请求值的Map对象

paramValues 按照参数名称访问数组请求值的Map对象

参数访问对象是和页面输入参数有关的隐式对象，通过它们可以得到用户的请求参数：

比如登录页面表单有个表单项提交用户名，

在登录处理页面可以通过 ${param.userName} 访问它

3）.JSP隐式对象

pageContext 提供对页面信息的JSP内置对象的访问

40、什么是JSTL

JSTL 全称 java server pages Standard Tag Library JSP标准标签库，它包含了我们在开发JSP页面经常用到的一组标准标签

41、 JSTL迭代标签使用？

其中：用 statu.index获得等同for的循环变量i一样。

var 是对当前成员的引用

beigin 表示开始位置默认为0 。可省略

end 表示结束位置，可省略

step表示步长，默认为1，可以省略

也可以指定循环次数来循环，

如：

代码块

通过begin 和end 指定循环次数

42、 Filter 基本工作原理

当在 web.xml 中配置了一个 Filter 来对某个 Servlet 程序进行拦截处理时，这个 Filter 就成了 Servlet 容器与该 Servlet 程序的通信线路上的一道关卡，该 Filter 可以对 Servlet 容器发送给 Servlet 程序的请求和 Servlet 程序回送给 Servlet 容器相应进行拦截，可以决定是否将请求继续传递给 Servlet 程序，以及对请求和相应信息是否进行修改。

在一个 web 应用程序中可以注册多个 Filter 程序，每个 Filter 程序都可以对一个或一组 Servlet 程序进行拦截。

若有多个 Filter 程序对某个 Servlet 程序的访问过程进行拦截，当针对该 Servlet 的访问请求到达时，web 容器将把多个 Filter 程序组合成一个 Filter 链(过滤器链)。Filter 链中各个 Filter 的拦截顺序与它们在应用程序的 web.xml 中映射的顺序一致。

三、 JavaScript和Ajax部分

第九天

1、 JavaScript变量有哪些数据类型？

JavaScript是一种弱类型语言，在声明变量时不需要指变量的类型，变量的类型由赋给变量的值来决定。

常用的基本数据类型：

1 undefined（未定义类型）

2 null（空类型）

3 number（数值类型）

4 string（字符串类型）

5 boolean（布尔类型）

2、 JavaScript中常用的系统函数其作用？

parselnt(): 可解析一个字符串，并返回一个整数。

parseFloat():可解析一个字符串，并返回一个浮点数。

isNaN():用于检查其参数是否是数字，不是数字为true，反之为false。

prompt(); 显示用户输入的对话框。

alert(); 显示带有一个“确定”按钮的警示框。

confirm(); 显示带有一个“确定”“取消”按钮的对话款。

close(); 关闭浏览器窗口。

open(); 弹出新的浏览器窗口。

setTimeout(); 在指定毫秒数后调用函数或计算表达式。

setInterval(); 按照指定的周期（以毫秒计）来调用函数或表达式。

3、 js中的3种弹出式消息提醒(警告窗口，确认窗口，信息输入窗口)的命令是什么？

弹出警告窗口“输入数据无效”

弹出确认窗口“确认保存吗？”

弹出信息输入窗口“请在此输入你的姓名”

“输入数据无效”：

alert("输入数据无效");//警告

“确认保存吗？”：

confirm("你是菜鸟吗");//确认

“请在此输入你的姓名”：

prompt("请在此输入你的姓名")//信息输入

4、 Javascript中定时执行如何实现，JavaScript如何实现一段代码在执行时间后运行？如何指定一段代码每隔指定时间就运行？

定时执行有两种函数，setTimeout()和setInterval()，setTimeout()是在一段时间后执行指定方法，而setInterval()是每隔一段时间后执行指定的方法

5、 javaScript的变量能复制到JSP的session中吗？

可以，但是比较麻烦，例如可以通过js调用ajax，将变量传递到服务器端，然后在服务器将获取到的变量值存入session中。

6、什么是BOM？

BOM是Browser Object Model（浏览器对象模型）的简称，提供了独立于内容与浏览器窗口进行交互的对象。

7、什么是DOM?

DOM即Document Object Model（文档对象模型），如果需要对HTML文档中的元素进行访问，添加，删除，移动或重排，JavaScript就是通过DOM来实现的，DOM可被JavaScript用来读取，改变HTML,XHTML及XML文档，所以DOM是由三部分组成的。

分别是：

1.Core DOM，即核心DOM编程，定义了一套标准的针对任何结构化文档的对象。

2.XML DOM：定义了一套标准的针对XML文档的对象。

3.HTML DOM：定义了一套标准的针对HTML文档的对象。

8、 DOM模型中的常用对象及其方法？

1) document对象的常用方法：

write()

getElementById()

getElementByName()

getElementByTagName()

2) location对象提供了当前页面的URL信息。主要方法有：

reload()是用于重新加载当前文档。

replace()是用新的文档替换当前文档。

3) history对象提供了用户最近浏览过的URL列表，主要方法有：

back()：实现浏览器后退页面功能

forwarc()：实现浏览器前进页面功能

go()：在页面上实现前进、后退的功能。

9、如何设置页面元素的显示和隐藏？

主要用到两个属性，visibility和display，区别在于：属性的值不同：visibility属性的值有：visible（可见），hidden（不可见），Display属性的值有：none(不可见),block（可见）。

visibility属性设置元素不可见时，元素仍然占据页面上的空间，而display属性设置元素不可见不会占据页面上的空间。

代码示例：

1) document.getElementById('对象1').style.display = "none";(会释放元素所在页面上所占的空间)

2) document.getElementById('对象1').style.visibility= "visible";(不会释放元素所在页面上所占的空间)

10、使用什么事件可以实现当鼠标移动某文本上时，文本样式改变，当鼠标离开时文本样式恢复为原来的样式？

1)onmouseover事件可以将鼠标移动到某文本上时改变文本的样式。

2)onmouseout事件可以当鼠标离开文本是恢复原来的样式。

11、 DOM如何操作文档的标准节点？

1) 查看节点：使用getElementById()，getElementByName(),getElementByTagName可以查看HTML文档中的任何元素。

2) 创建和增加节点：创建节点要用到createElement(“标签名”)，例如：createElement(“img”)。

3) 增加节点有三种方式：

appendChild(nodeName)向已经存在节点列表的末尾添加新的子节点。

insertBefore(newNode,oldNode)向指定的节点前插入一个新的子节点。

cloneNode(deep)复制某个指定的节点，deep是布尔值，当deep为true时，会复制指定的节点和所有子节点，当deep为false时，只复制指定的节点和它的属性。

4) 删除和替换节点：分别用removeChild(none),replaceChild(newNode,oldNode)。

12、 CSS样式表有哪几种？

内联样式表：内联样式表是混合在HTML标签里使用的。

内部样式表：内部样式表是放置在标签内的，并且以来定义的。

外部样式表：外部样式表是一个独立的文件，文件里定义了各种各样的样式规定，方便被多个HTML文件使用。导入外部样式表有两种方法：

1）在页面中使用标签来链接到外部样式文件。

2）在页面中使用@import方法导入外部样式文件。

13、 Javascript中String对象常用方法？

属性length的用法：字符串对象.length。

字符串对象常用方法：

tolowerCase() ：把字符串转换为小写。

toUpperCase( )：把字符串转换为大写。

charAt(index) ：返回在指定位置中的字符。

indexOf(字符串，index)：查找某个指定的字符串在字符串中首次出现的位置。

substring(index1,index2)：返回位于指定索引index1和index2之间的字符串，并且包括索引index1的位置，不包括index2对应的位置。

14、文本框对象常用的方法和事件

事件：onblur：失去焦点，当光标离开某个文本框时触发。

onfocus：获得焦点，当光标进入某个文本框时触发。

onkeypress：某个键盘按键被按下并松开。

方法：blur：从文本框中移开焦点。

focus：在文本框中设置焦点，即获得鼠标光标。

select：选取文本域中的内容。

属性：id：设置或返回文本域的ID。

value：设置返回文本域的value属性的值。

name：控件的名称

制作文本输入提示特效，使用innerHTML属性动态改变层中的提示内容。

15、正则表达式的概念

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

正则表达式作用：

1. 测试给定的字符串是否符合正则表达式的过滤逻辑（称作“匹配”）；

2. 可以通过正则表达式，从字符串中获取我们想要的特定部分。　　

正则表达式的特点是：

1. 灵活性、逻辑性和功能性非常的强；

2. 可以迅速地用极简单的方式达到字符串的复杂控制。

3. 对于刚接触的人来说，比较晦涩难懂。　　

由于正则表达式主要应用对象是文本，因此它在各种文本编辑器场合都有应用，小到著名编辑器EditPlus，大到Microsoft Word、Visual Studio等大型编辑器，都可以使用正则表达式来处理文本内容。

16、正则表达式有几种构造方式，分别是什么？

一种是普通方式 var reg = /表达式/;

一种是构造方式 var reg = new RegExp(‘表达式’,’参数’);

17、 RegExp对象使用什么方法匹配正则表达式？

test()：检索字符串中指定的值，返回true或 false

exec()：检索字符中是正则表达式的匹配，返回找到的值，并确定位置。

18、用正则表达式写出HTTP的url格式

/^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$/

http://baike.baidu.com/view/94238.htm?fr=aladdin

第十天

19、你是怎么理解Ajax的，什么是Ajax？

Ajax 的全称是Asynchronous JavaScript and XML，其中Asynchronous 是异步的意思，它有别于传统web开发中采用的同步的方式。

Ajax并非一种新的技术，而是几种原有技术的结合体。它由下列技术组合而成。

1) 使用CSS和XHTML来表示。

2) 使用DOM模型来交互和动态显示。

3) 使用XMLHttpRequest来和服务器进行异步通信。

4) 使用javascript来绑定和调用。

20、实现AJAX异步调用需要哪些步骤

1) 创建XMLHttpRequest对象,也就是创建一个异步调用对象.

2) 创建一个新的HTTP请求,并指定该HTTP请求的方法、URL及验证信息.

3) 设置响应HTTP请求状态变化的函数.

4) 发送HTTP请求.

5) 获取异步调用返回的数据.

6) 使用JavaScript和DOM实现局部刷新.

21、原生（native）Ajax使用示例

//创建XMLHttpRequest对象的方法

function createXmlHttpRequest(){

if(window.ActiveXObject){

return new ActiveXObject("Microsoft.XMLHTTP");

}else if(window.XMLHttpRequest){

return new XMLHttpRequest();

}

//ajax操作

function showContent(titleobj){

var url="ShowContentServlet?id="+titleobj.id; //设置提交路径

XmlHttp2 = createXmlHttpRequest(); //创建对象

XmlHttp2.onreadystatechange = contentProcessRequest; //设置回调函数

XmlHttp2.open("get",url,true);//get表示路径中带参传值，post表示send方法传值

XmlHttp2.send("null"); //发送请求

}

//回调函数，就是返回响应后调用的函数

function contentProcessRequest(){

if(XmlHttp2.readyState == 4){

if(XmlHttp2.status == 200){

//根据ajax返回值操作页面元素

}

22、 XMLHttpRequest对象简介？

1）.XMLHttpRequest常用方法，

open("post/get","请求的地址","true/false") ：第三个参数是是否使用异步请求，可以为true;和false

send(content)：发送请求，content参数指定请求的参数，如果不需要，则为null,

setRequestHeader(header,value) ：设置请求的头信息

2）XMLHttpRequest常用属性，

a) onreadystatechange 指定XMLHttpRequest对象的回调函数。相当于一个事件，当XMLHttpRequest的状态发生

改变的时候，都会调用onreadystatechange指定的回调函数。

代码案例: XMLHttpRequest对象.onreadystatechange = 函数名;

b) readyState: XMLHttpRequest的状态信息,取值如下

0:已经创建了XMLHttpRequest对象，但是还没有初始化

1:此时，代码已经调用open()方法并且XMLHttpRequest已经准备好把一个请求发送到服务器

2:此时，已经通过一个send()方法把一个请求发送到了服务器，但还没收到响应

3:此时已经接受了HTTP响应头部信息，但是消息体部分还没完全接收结束

4:响应被完全接收

c) status：HTTP的状态码，仅当readyState的值为3或4的时候，status属性才可，status的值为: 200 ：服务器响应正常， 400：无法找到请求的资源， 403：没有访问权限 404：访问的资源不存在、 500：服务器内部错误

d)responseText: 获得响应的文本内容(服务器返回的普通文本信息)

f)responseXML:获取响应的XML格式的内容信息

23、怎么处理Ajax中的缓存

1) 在服务端加 header("Cache-Control: no-cache, must-revalidate");

2) 在ajax发送请求前加上 anyAjaxObj.setRequestHeader("If-Modified-Since","0");

3) 在ajax发送请求前加上 anyAjaxObj.setRequestHeader("Cache-Control","no-cache");

4) 在 Ajax 的 URL 参数后加上 "?fresh=" + Math.random(); //当然这里参数 fresh 可以任意取了

5) 第五种方法和第四种类似，在 URL 参数后加上 "?timestamp=" + new Date().getTime();

6) 用POST替代GET：不推荐

24、为什么使用Ajax框架？

1).简化JavaScript的开发难度

过去JavaScript的往往用于实现一些小玩意、

弹出警告信息、动态文字等。而JavaScript被赋予的操作文档对象模型（DOM）与测控CSS的强大能力被忽视了。

2).解决浏览器的兼容性问题

即使能轻松使用JavaScript，但一旦遇到各式浏览器也会头痛。不同浏览器对JavaScript的支持并不一致，同一浏览器的版本不同的支持也不一样

3).简化开发流程

之前开发客户端与服务器异步交互程序一定能体会到在开发过程中相当繁琐，必须检查处理状态、指定服务器处理程序和设置回调函数等细节

25、常用的Ajax框架有哪些？

1).Prototype

是一個純粹的JavaScript函數庫，對Ajax提供了良好的支持

2).jQuery

另一個非常優秀的JavaScript庫，對Ajax提供良好的支持，與Prototype設計思想不同的是在使用JQuery之後，開發者提供了不再是DOM對象而是JQuery對象。

3).DWR

非常专业的Java Ajax框架，通过DWR框架，可以将Java类中的方法直接暴露给客户端

4).Dojo

功能强大，包含许多内容，AJax只是其中之一，特点在于控件和控件系统

5).AjaxTags

由一系列JSP标签组成，将常用的Ajax应用场景封装为简单的标签。

26、什么是jQuery

jQuery也就是JavaScript和Query(查询),即是辅助JavaScript开发的库。

jQuery优势：

1).轻量级

2).强大的选择器

3).出色的DOM操作封装

4).可靠的事件处理机制

5).出色的浏览器兼容性

6).完善的Ajax支持

7).出色的浏览器兼容性等

8).jQuery理念：写的少，做的多

27、你为什么要使用jQuery？

答：因为jQuery是轻量级的框架，大小不到30kb,它有强大的选择器，出色的DOM操作的封装，有可靠的事件处理机制(jQuery在处理事件绑定的时候相当的可靠)，完善的ajax(它的ajax封装的非常的好，不需要考虑复杂浏览器的兼容性和XMLHttpRequest对象的创建和使用的问题。) 出色的浏览器的兼容性。而且支持链式操作，隐式迭代。行为层和结构层的分离，还支持丰富的插件，jQuery的文档也非常的丰富。

28、 Jquery与Javascript的区别

JavaScript 是一种脚本语言，主要用在浏览器中，实现对网页的文档对象的操作和一些用户交互动作的处理。

而 jQuery 则是 JavaScript 的一个代码库（或习惯性叫类库），它将一些在 JavaScript 开发中经常用到的功能集合起来，以方便开发者直接使用，而不需要再用原生 JavaScript 语句写大量代码，同时可在不同浏览器间实现一致的效果。是当前最流行的 JavaScript 库之一。

1) jQuery 作为 JavaScript 的代码库，自然是使用 JavaScript 语言编写的。

2) jQuery 的代码非常规范，执行效率也很高，是 JavaScript 编码的优秀范例。

3) 很多情况下，只要使用 jQuery 的方法就可以实现大部分的 JavaScript 功能。

PS：关于程序语言和代码库之间的联系，打个比方，程序语言是原料，代码库则是用原料做成的半成品，而你的程序项目则是成品。你可以选择直接用原料做，也可以选择加入一些半成品。当然用原料做，你可以更自由，而用半成品则效率更高。

29、你在公司是怎么用jQuery的？

答：在项目中是怎么用的是看看你有没有项目经验(根据自己的实际情况来回答)

你用过的选择器啊，复选框啊，表单啊，ajax啊，事件等

配置JQuery环境的步骤

1）下载jQuery类库，在jsp页面引用jQuery类库即可

30、 jQuery 能做什么？

答：1. 获取页面的元素

2. 修改页面的外观

3. 改变页面大的内容

4. 响应用户的页面操作

5. 为页面添加动态效果

6. 无需刷新页面，即可以从服务器获取信息

7. 简化常见的javascript任务

31、 $(document).ready()方法和window.onload有什么区别？

答: 两个方法有相似的功能，但是在执行时机方面是有区别的。

1） window.onload方法是在网页中所有的元素(包括元素的所有关联文件)完全加载到浏览器后才执行的。

2） $(document).ready() 方法可以在DOM载入就绪时就对其进行操纵，并调用执行绑定的函数。

32、什么是jQuery选择器

1)jQuery选择器继承了CSS与Path语言的部分语法，允许通过标签名、属性名或内容对DOM元素进行快速、准确的选择，而不必担心浏览器的兼容性，通过jQuery选择器对页面的元素的精准定位，才能完成元素属性和行为的处理。

选择器是jQuery的根基，在jQuery中，对象的事件处理，遍历DOM和Ajax操作都依赖于选择器

2)jQuery选择器的优点：

简洁的写法

完善的事件处理机制

支持CSS1到CSS3选择器

33、 jQuery选择器的种类

1).基本选择器

基本选择器是jQuery中最常见的选择器，也是最简单的选择器，它通过元素id,class和标记名来查找DOM元素

2).层次选择器

如果想通过DOM元素之间的层次关系来获取特定元素，就需要使用层次选择器

3).过滤器选择器

过滤选择器主要是通过特定的过滤规则来筛选出所需的DOM元素，该选择器都以“：”开头，过滤选择器又分以下几种

4).表单选择器

表单选择器主要是通过所选择的表单元素进行过滤

5).属性选择器

属性过滤选择器的过滤规则是通过元素的属性来获取相应的元素

7).内容过滤器选择器

内容过滤选择器的过滤规则主要体现在它所包含的子元素和和文本内容上

8).可见性过滤选择器

可见性过滤选择器是根据元素的可见和不可见状态来选择相应的元素

34、 JQuery选择器中“#”和“.”各自的作用？

“#”是ID选择器，根据ID得到元素，而“.”是类选择器，根据class得到元素

35、 jQuery中的选择器和 css中的选择器有区别吗？

答：jQuery选择器支持CSS里的选择器，jQuery选择器可用来添加样式和添加相应的为CSS 中的选择器是只能添加相应的样式。

36、 siblings() 方法和 $('prev~div')选择器是一样的嘛？

答: $('prev~div') 只能选择'#prev'元素后面的同辈

元素而siblings()方法与前后的位置无关，只要是同辈节点就都能匹配。

37、 jQuery中的hover()和toggle()有什么区别？

答： hover()和toggle()都是jQuery中两个合成事件。

hover()方法用于模拟光标悬停事件。

toggle()方法是连续点击事件。

38、 $("#msg").text()和 $("#msg").text("new content")有什么区别？
$("#msg").html()及$("#msg").html("new content")的区别呢？

答：$("#msg").text() 是返回id为msg的元素节点的文本内容

$("#msg").text("new content"); 是将“new content” 作为普通文本串写入id为msg的元素节点内容中,页面直接显示“new content”，text()方法对HTML和XML文档都有效

$("#msg").html()则是取得id为msg的元素节点的html内容。这个函数不能用于XML文档。但可以用于XHTML文档

$("#msg").html("new content")，是将“new content”作为HTML内容写入id为msg的元素节点内容中,页面直接显示粗体的“new content”内容

39、 Jquery对象和dom对象的区别

Jquery对象才能调用jquery中特有的方法。例如jqueryObj.html()、jqueryObj.val()等方法，而不能使用dom对象特有的属性和方法，例如domObj.value,domObj.innerHTML等。

Jquery对象可以和dom对象相互转化

40、 jQuery对象和dom对象是怎样转换的？

1.jQuery转DOM对象:

1）jQuery 对象是一个数组对象，可以通过[index]的方式得到相应的DOM对象，例如页面有个id为myDiv的DIV对象，可以使用var domObj = $(“#myDiv”)[0]这种方式来获取该DIV对应的dom对象

2）通过get(index)去得到相应的DOM对象，var domObj = $(“#myDiv”).get(0);

2.DOM对象转jQuery对象:

直接使用$(DOM对象)来转换,示例代码：

var domObj = document.getElementById(“myDiv”);

var jQueryObj = $(domObj);

$()就相当于一个jquery对象的构造函数

41、你是如何使用jQuery中的ajax的？

答: 如果是一些常规的ajax程序的话，使用$.load(),$.get(),$.post(),就可以搞定了，

一般我会使用的是$.get() 方法。

如果需要设定beforeSend(提交前回调函数),error(失败后处理),success(成功后处理)

及complete(请求完成后处理)回调函数等，这个时候我会使用$.ajax()

42、 jQuery中$.get()提交和$.post()提交有区别吗？

1）$.get() 方法使用GET方法来进行异步请求的，$.post() 方法使用POST方法来进行异步请求的。

2）get请求会将参数跟在URL后进行传递，而POST请求则是作为HTTP消息的实体正文内容发送给Web服务器的，这种传递是对用户不可见的。

3）get方式传输的数据大小不能超过2KB 而POST要大的多

4）GET 方式请求的数据会被浏览器缓存起来，因此有安全问题。

43、 jQuery中的load方法一般怎么用的？

答：load方法一般在载入远程HTML 代码并插入到DOM中的时候用通常用来从Web服务器上获取静态的数据文件。

如果要传递参数的话，可以使用$.get() 或 $.post()。

44、你在ajax中使用过JSON吗，你是如何用的？

答:使用过，在$.getJSON()方法的时候就是。因为 $.getJSON() 就是用于加载JSON文件的。此外，在使用jQuery的时候也使用json来进行参数的传递及执行结果的接收处理。

45、你使用过哪些数据格式，它们各有什么特点？

答: HTML格式 ,JSON格式, XML格式

1） HTML片段提供外部数据一般来说是最简单的。

2）如果数据需要重用，而且其他应用程序也可能一次受到影响，那么在性能和文件大小方面具有优势的JSON通常是不错的选择。

3）而当远程应用程序未知时，XML则能够为良好的互操作性提供最可靠的保证。

46、在jQuery执行ajax中，提交的data（数据）主要有几种方式？

答：三种，html拼接的，json数组，form表单经serialize()序列化的。

47、 jQuery是如何处理缓存的？

答：要处理缓存就是禁用浏览器缓存.

1）通过$.post()方法来获取数据，那么默认就是禁用缓存的。

2）通过$.get()方法来获取数据，可以通过设置时间戳来避免缓存。

可以在URL后面加上+(+new Date)来增加上时间戳参数

例：$.get('ajax.xml?'+(+new Date),function () {

//函数内容代码

});

3）通过$.ajax方法来获取数据，只要设置参数cache:false即可。

48、你读过有关于jQuery的书吗？

《jQuery基础教程》《jQuery实战》《锋利的jQuery》《巧用jQuery》《jQuery用户界面库学习指南》等

49、你知道jQuery中的事件冒泡吗，它是怎么执行的，如何来停止冒泡事件？

答: 知道,事件冒泡是从里面的往外面开始触发。

在jQuery中提供了stopPropagation()方法可以停止冒泡。

50、例如单击超链接后会自动跳转，单击"提交"按钮后表单会提交等，有时候我想阻止这些默认的行为，该怎么办？

答: 可以用 event.preventDefault()

或在事件处理函数中返回false，即 return false;

第十一天

51、你使用过jQuery中的动画吗，是怎样用的？

答:使用过。

hide() 和 show() 同时修改多个样式属性。像高度，宽度，不透明度。

fadeIn() 和fadeOut() fadeTo() 只改变不透明度

slideUp() 和 slideDown() slideToggle() 只改变高度

animate() 属于自定义动画的方法.

52、你使用过jQuery中的插件吗？

答:看个人的实力和经验来回答了。例如easyUI，树形插件，表单验证插件，自动补全插件等等，结合项目大概说一下

53、怎样给jQuery动态附加新的元素?那么怎样给新生成的元素绑定事件呢？

jQuery的html()可以给现有元素附加新的元素。

直接在元素还未生成前就绑定肯定是无效的，因为所绑定的元素目前根本不存在。

所以我们可以通过live和livequery来动态绑定事件，这种绑定方式对现有和新生成的元素都有效。

54、 jQuery中有几种方法可以来设置和获取样式

答：addClass() 方法，attr() 方法

55、 jQuery中如何来获取或和设置属性？

答：jQuery中可以用attr()方法来获取和设置元素属性

removeAttr() 方法来删除元素属性

56、解决jQuery和其它库的冲突

答：调用jQuery.noConflict()放弃对变量$的控制权，然后可以直接使用jQuery()来代替$()的调用方式。

两全其美的方式：

jQuery.noConflict();//移交变量$控制权

(function($){

$(“#myTable”).show();//此处又可以直接使用

变量$来执行jQuery的代码

})(jQuery)

57、 Jquery获取表格第二行第三列(td)的值?

例如：页面上的表格id为”tab”.

示例1：$("#tab").find("tr").eq(1).find("td").eq(2).html();

示例2：$(“#tab>tr:eq(1)>td:eq(2)”).html();

58、用Jquery设置文本框不可编辑？

$('#id属性值').attr('readonly',true);

59、用Jquery给文本框赋值

$("#id属性值").val("赋予的值");

四、项目开发经验

1、在eclipse中调试时，怎样查看一个变量的值？

在要查看的变量前先设置断点，然后选中变量，右键选debug as-->Java Application，打开debug透视图，这时在Variables窗口中可以看到变量当前的值。

如果是局部变量，也可以在局部变量窗口中查看。

要知道一个方法，被调用的方法的调用链，可以在方法栈中查看。

2、你们公司使用的代码配置管理工具是什么？

除了说以前使用cvs，现在新项目使用svn了，还简要说一下使用的过程，如果有可能，还说说仓库的概念和如何使用锁之类的细节。

3、你们的项目总金额多少，多少人开发，总共花了多少个月？

像CRM这种规模的项目，可以说是4、5个人、开发了4、5个月，费用则是40~50万。按每人每月两万的成本去计算，就差不多了。

4、对表单输入的数据应该作哪些验证？

1、验证必填项不能为空

2、验证数据的类型、如手机、年龄、分数，必须是数字组合，保证数据的真实性。

3、验证数据的长度，如用户名、密码均规定长度范围，阻止用户输入过段或过长数据。

4、验证数据的有效性，如Email须含“@”符号，手机号第一位是“1”等。

5、密码、确认密码，两者必须保持一致。

5、防止SQL 注入有哪些方法？

1、对于连接的SQL语句要过滤SQL关键字

2、使用参数化查询

6、 DDoS攻击的主要攻击方式包括？

DDos也叫拒绝服务式攻击，它就是利用合理的服务请求来占用过多的服务器资源，从而让目标服务器无法正常提供服务的一种攻击方式。

DDos攻击主要有两种方式：

1、流量攻击：

发送大量攻击包导致网络带宽阻塞，致使正常的网络请求的数据包无法达到主机。

2、资源耗尽攻击：

主要是针对服务器主机的攻击，即通过大量的攻击数据包导致主机的内存、CPU被耗尽而无法提供网络服务。

7、为什么需要单元测试？

我们编写代码时，一定会反复调试保证它能够编译通过。如果是编译没有通过的代码，没有任何人会愿意交付给自己的老板。但代码编译通过后，只是说明了它的语法正确，我们却无法保证它的语义也一定正确，没有任何人可以轻易承诺这段代码的行为一定是正确的。但是单元测试能为我们保证代码质量。编写单元测试就是为了验证我们所编写的代码的行为是否与我们期望一致。有了单元测试，我们可以自信地交付出自己的代码，而没有任何的后顾之忧。同时，进行单元测试也是降低软件风险和减少维护成本的有途径。

8、你在项目开发过程中遇到的最大的问题是什么？

最大的问题可以说是没有学过的技术啊！需求不明确啊！等等！

9、分层设计的好处

把各个功能按调用流程进行了模块化，模块化带来的好处就是可以随意组合，举例说明：如果要注册一个用户，流程为显示界面并通过界面接收用户的输入，接着进行业务逻辑处理，在处理业务逻辑又访问数据库，如果我们将这些步骤全部按流水帐的方式放在一个方法中编写，这也是可以的，但这其中的坏处就是，当界面要修改时，由于代码全在一个方法内，可能会破坏业务逻辑和数据库访问的码，同样，当修改业务逻辑或数据库访问的代码时，也会破坏其他部分的代码。分层就是要把界面部分、业务逻辑部分、数据库访问部分的代码放在各自独立的方法或类中编写，这样就不会出现牵一发而动全身的问题了。这样分层后，还可以方便切换各层，譬如原来的界面是Swing，现在要改成WEB界面，如果最初是按分层设计的，这时候不需要涉及业务和数据访问的代码，只需编写新的Web界面代码就可以了。

下面的仅供参考，不建议照搬照套，一定要改成自己的语言，发现内心的感受：

a、分层的原则：

1) 上层依赖其下层，依赖关系不跨层

也就是说表示层是顶层，只能依赖其下层业务逻辑层，而不能直接依赖数据访问层

2) 下一层不能调用上一层

下一层不能调用上一层，为什么要这么规定？大家都知道，去餐厅吃饭的时首先都是服务员帮助顾客点菜，然后将菜单交给厨师，厨师根据菜单让采购员提供原料，然后制作，这个流程完全就遵循上层调用下层的原则，那么试想一下，如果反其道而行，下层调用上层的话会是一个什么样的结果，？采购员提供什么原料给厨师，厨师就做什么菜，然后

服务员告诉顾客只有什么菜可以点。那么这家餐厅就倒闭不远了

3) 下一层不依赖上一层

上一层调用下一层得到的是一个执行结果，即下一层的代码实现决定了上一层获得的内容，所以说上一层依赖下一层。从另一个角度来说，上一层不管如果发生改变，对于其调用下一层的业务是不会发生变化的，因此对于下一层来说，上一层的改变不会对其产生任何影响。

4) 在上一层中不能出现下一层的概念

也就是说层次要分的很清楚，业务逻辑层，只能有用于业务逻辑控制的代码，不能有数据访问层的代码。

b、分层的好处：

1.实现了软件之间的解耦；

2.便于进行分工

3.便于维护

4，提高软件组件的重用

5.便于替换某种产品，比如持久层用的是hibernate,需要更换产品用toplink，就不用改其它业务代码，直接更换访问层的接口实现就可以了。

6.便于产品功能的扩展

7.便于适用用户需求的不断变化

10、你们公司的开发流程是什么？

1. 项目计划阶段

1)、项目组成立(公司成员、客户成员)

　　 2)、制定项目预期目标

　　 3)、制定项目计划周期

　　 4)、建立好项目组成员沟通机制

2. 需求阶段

　　 1)、创建调研计划、协调调研时间

　　 2)、收集客户资料，获取客户需求

　　 3)、编写需求文档

　　 4)、需求变更记录

　　 5)、确定开发环境和运行环境

　　 6)、扩展性要求

　　 7)、与旧系统的接驳要求。

　　 8)、估算出项目工作量

3. 系统设计/详细设计（一个系统可以分为基础平台和应用模块两部分。）

1)、选择基础平台，无论是采用第三方平台还是自行开发平台，都需要深入了解，查看是否符合要求。

　　 2)、应用模块设计(针对业务流程)

　　 3)、中间件的采用或自行开发，需要深入了解。

　　 4)、用户界面的设计

　　 5)、变更记录

4. 编码阶段

1)、优先编写测试用例

　　 2)、按照编码规范编写代码

　　 3)、按照文档注释规范注释

5. 测试阶段

1)、编写测试计划和测试方案

　　 2)、功能测试

3)、性能测试

6. 维护阶段

　　本阶段需要解决：

　　 1)、解决异地修改和公司修改的同步问题。

　 2)、用户测试中的Bug修改问题，按照级别分为

　 a)程序Bug b)设计变更 c)需求变更

11、你们项目成员组成？

1、项目经理PM 2、项目组长PL 3、测试人员

5、高级程序员 6、初中级程序员

五、数据库部分

第十二天

1、设计数据库的三大范式是什么?

1) 第一范式（1NF）：字段具有原子性,不可再分。所有关系型数据库系统都满足第一范式）

a) 数据库表中的字段都是单一属性的，不可再分。例如，姓名字段，其中的姓和名必须作为一个整体，无法区分哪部分是姓，哪部分是名，如果要区分出姓和名，必须设计成两个独立的字段。

2) 第二范式（2NF）：

a) 第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。

3) 要求数据库表中的每个实例或行必须可以被唯一地区分。通常需要为表加上一个列，以存储各个实例的唯一标识。这个唯一属性列被称为主关键字或主键。

4) 第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的唯一标识。简而言之，第二范式就是非主属性非部分依赖于主关键字。

5) 第三范式的要求如下：

6) 满足第三范式（3NF）必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。

7) 所以第三范式具有如下特征：
         1，每一列只有一个值
         2，每一行都能区分。
         3，每一个表都不包含其他表已经包含的非主关键字信息。

8) 例如，在一个帖子表中只能出现发帖人的id！不能有了发帖人的i d字段，还同时有发帖人的姓名字段，否则，这就是数据冗余。

2、说出一些数据库优化方面的经验?

1) 从JDBC编程的角度讲，用PreparedStatement 一般来说比Statement性能高，因为在使用时，SQL 语句被预编译并存储在 PreparedStatement 对象中。然后可以使用PreparedStatement对象多次高效地执行该语句。

2) 有外键约束会影响插入和删除性能，如果程序能够保证数据的完整性，那在设计数据库时就可以去掉外键。（比喻：就好比免检产品，就是为了提高效率，充分相信产品的制造商）

3) 表中允许适当冗余，譬如，主题帖的回复数量和最后回复时间等，将姓名和密码单独从用户表中独立出来等，这些都是分析了业务的特点后，对数据库中表做了优化后的解决方案。也就是说在有些情况下，我们设计数据库可以适度的违反三个范式的设计原则，来获得更好的程序性能。

4) sql语句全部大写，特别是列名和表名都大写。因为数据库中的语句执行机制是这样的：sql语句à发给oracle服务器à语法检查和编译成为内部指令à缓存和执行指令。而数据库在对语句进行检查和编译时，会自动将sql语句转换成大写，并且根据SQL缓存的特点，不要拼凑条件，而是用?（占位符参数）和PreparedStatment来执行参数化的sql语句。

5) 还有索引对查询性能的改进。当经常查询索引列中的数据时，需要在表上创建索引。索引占用磁盘空间，并且降低添加、删除和更新行的速度。在多数情况下，索引用于数据检索的速度优势大大超过它的不足之处。但是，如果应用程序非常频繁地更新数据或磁盘空间有限，则可能需要限制索引的数量

3、 Oracle数据库如何提高访问性能？

a) 避免在索引列上使用IS NULL和IS NOT NULL 操作
避免在索引中使用任何可以为空的列，ORACLE将无法使用该索引．对于单列索引，如果列包含空值，索引中将不存在此记录. 对于复合索引，如果每个列都为空，索引中同样不存在此记录.　如果至少有一个列不为空，则记录存在于索引中．
举例:
如果唯一性索引建立在表的A列和B列上, 并且表中存在一条记录的A,B值为(123,null) , ORACLE将不接受下一条具有相同A,B值（123,null）的记录(插入). 然而如果所有的索引列都为空，ORACLE将认为整个键值为空而空不等于空. 因此你可以插入1000 条具有相同键值的记录,当然它们都是空! 因为空值不存在于索引列中,所以WHERE子句中对索引列进行空值比较将使ORACLE停用该索引.

b) 用UNION替换OR (适用于索引列)
通常情况下, 用UNION替换WHERE子句中的OR将会起到较好的效果. 对索引列使用OR将造成全表扫描. 注意, 以上规则只针对多个索引列有效. 如果有column没有被索引, 查询效率可能会因为你没有选择OR而降低.

c) 分离表和索引
总是将你的表和索引建立在不同的表空间内(TABLESPACES). 决不要将不属于ORACLE内部系统的对象存放到SYSTEM表空间里. 同时,确保数据表空间和索引表空间置于不同的硬盘上（通过指定表空间的方式可以实现这个要求）.

d) 共享SQL语句

为了不重复解析相同的SQL语句,在第一次解析之后, ORACLE将SQL语句存放在内存中.这块位于系统全局区域SGA(system global area)的共享池(shared buffer pool)中的内存可以被所有的数据库用户共享. 因此,当你执行一个SQL语句(有时被称为一个游标)时,如果它和之前的执行过的语句完全相同, ORACLE就能很快获得已经被解析的语句以及最好的执行路径. ORACLE的这个功能大大地提高了SQL的执行性能并节省了内存的使用.
当你向ORACLE 提交一个SQL语句,ORACLE会首先在这块内存中查找相同的语句.
这里需要注明的是,ORACLE对两者采取的是一种严格匹配,要达成共享,SQL语句必须完全相同(包括空格,换行等).

e) WHERE子句中的连接顺序．
ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾.
例如:

示例1.(低效,执行时间156.3秒)
SELECT * FROM EMP E
WHERE SAL > 50000
AND JOB = ‘MANAGER' AND 25 < (SELECT COUNT(*) FROM EMP
WHERE MGR=E.EMPNO);
示例2(高效,执行时间10.6秒)
SELECT … FROM EMP E
WHERE 25 < (SELECT COUNT(*) FROM EMP WHERE MGR=E.EMPNO)
AND SAL > 50000
AND JOB = ‘MANAGER';

f) SELECT子句中避免使用 ‘ * ‘
当你想在SELECT子句中列出所有的COLUMN时,使用动态SQL列引用 ‘*' 是一个方便的方法.不幸的是,这是一个非常低效的方法. 实际上,ORACLE在解析的过程中, 会将'*' 依次转换成所有的列名, 这个工作是通过查询数据字典完成的, 这意味着将耗费更多的时间.

g) 使用DECODE函数来减少处理时间
使用DECODE函数可以避免重复扫描相同记录或重复连接相同的表.
例如:
SELECT COUNT(*)，SUM(SAL)
FROM　EMP
WHERE DEPT_NO = 0020
AND ENAME LIKE　‘SMITH%';

SELECT COUNT(*)，SUM(SAL)
FROM　EMP
WHERE DEPT_NO = 0030
AND ENAME LIKE　‘SMITH%';
你可以用DECODE函数高效地得到相同结果
SELECT COUNT(DECODE(DEPT_NO,0020,'X',NULL)) D0020_COUNT,
COUNT(DECODE(DEPT_NO,0030,'X',NULL)) D0030_COUNT,
SUM(DECODE(DEPT_NO,0020,SAL,NULL)) D0020_SAL,
SUM(DECODE(DEPT_NO,0030,SAL,NULL)) D0030_SAL
FROM EMP WHERE ENAME LIKE ‘SMITH%';
类似的,DECODE函数也可以运用于GROUP BY 和ORDER BY子句中.

h) 用TRUNCATE替代DELETE
当删除表中的记录时,在通常情况下, 回滚段(rollback segments ) 用来存放可以被恢复的信息. 如果你没有COMMIT事务,ORACLE会将数据恢复到删除之前的状态(准确地说是恢复到执行删除命令之前的状况) 而当运用TRUNCATE时, 回滚段不再存放任何可被恢复的信息.当命令运行后,数据不能被恢复.因此很少的资源被调用,执行时间也会很短.
(注意: TRUNCATE只在删除全表适用,TRUNCATE是DDL不是DML)

i) 尽量多使用COMMIT
只要有可能,在程序中尽量多使用COMMIT, 这样程序的性能得到提高,需求也会因为COMMIT所释放的资源而减少:
COMMIT所释放的资源:
a. 回滚段上用于恢复数据的信息.
b. 被程序语句获得的锁
c. redo log buffer 中的空间
d. ORACLE为管理上述3种资源中的内部花费
(注意: 在使用COMMIT时必须要注意到事务的完整性,现实中效率和事务完整性往往是鱼和熊掌不可得兼)

j) 用Where子句替换HAVING子句
避免使用HAVING子句, HAVING 只会在检索出所有记录之后才对结果集进行过滤. 这个处理需要排序,总计等操作. 如果能通过WHERE子句限制记录的数目,那就能减少这方面的开销.
例如:
低效:
SELECT REGION，AVG(LOG_SIZE)
FROM LOCATION
GROUP BY REGION
HAVING REGION REGION != ‘SYDNEY'
AND REGION != ‘PERTH'

高效
SELECT REGION，AVG(LOG_SIZE)
FROM LOCATION
WHERE REGION REGION != ‘SYDNEY'
AND REGION != ‘PERTH'
GROUP BY REGION
(注意: HAVING 中的条件一般用于对一些集合函数的比较,如COUNT() 等等. 除此而外,一般的条件应该写在WHERE子句中)

k) 用EXISTS替代IN
在许多基于基础表的查询中,为了满足一个条件,往往需要对另一个表进行联接.在这种情况下, 使用EXISTS(或NOT EXISTS)通常将提高查询的效率.
低效:
SELECT *
FROM EMP (基础表)
WHERE EMPNO > 0
AND DEPTNO IN (SELECT DEPTNO
FROM DEPT
WHERE LOC = ‘MELB')

高效:
SELECT *
FROM EMP (基础表)
WHERE EMPNO > 0
AND EXISTS (SELECT ‘X'
FROM DEPT
WHERE DEPT.DEPTNO = EMP.DEPTNO
AND LOC = ‘MELB')

l) 用NOT EXISTS替代NOT IN
在子查询中,NOT IN子句将执行一个内部的排序和合并. 无论在哪种情况下,NOT IN都是最低效的 (因为它对子查询中的表执行了一个全表遍历). 为了避免使用NOT IN ,我们可以把它改写成外连接(Outer Joins)或NOT EXISTS.
例如:
SELECT …
FROM EMP
WHERE DEPT_NO NOT IN (SELECT DEPT_NO
FROM DEPT
WHERE DEPT_CAT='A');

为了提高效率.改写为:
(方法一: 高效,左外连接)
SELECT ….
FROM EMP A,DEPT B
WHERE A.DEPT_NO = B.DEPT(+)
AND B.DEPT_NO IS NULL
AND B.DEPT_CAT(+) = ‘A'

(方法二: 最高效)
SELECT ….
FROM EMP E
WHERE NOT EXISTS (SELECT ‘X'
FROM DEPT D
WHERE D.DEPT_NO = E.DEPT_NO
AND DEPT_CAT = ‘A');

4、你有优化SQL查询数据经验吗？如有能说一下你一般用那些什么方式进行优化？

1) 用索引提高效率

2) 选择最有效率的表名顺序(ORACLE的解析器按照从右到左的顺序处理FROM子句中的表名，FROM子句中写在最后的表(基础表 driving table)将被最先处理)

3) WHERE子句中的连接顺序：ORACLE采用自下而上的顺序解析WHERE子句,根据这个原理,表之间的连接必须写在其他WHERE条件之前, 那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾

4) SELECT子句中避免使用 ‘ * ‘：需要写全查询的字段列名。

5、什么是事务，事务的四个特性是什么？有哪些隔离级别？

1) 事务（Transaction）：是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合（工作逻辑单元）；

2) 事务具有4个属性，通常称为ACID特性：

3) 原子性（atomicity）：事务是一个完整的操作。事务的各步操作是不可分的；要么都执行、要么都不执行。

4) 一致性（consistency）：当事务完成时，数据必须处于一致状态。

5) 隔离性（isolation）：对数据进行修改的所有并发事务是彼此隔离的，这表明事务必须是独立的，它不应以任何方式依赖于或影响其他事务。

6) 持久性（durability）：事务完成后，它对数据库的修改被永久保存，事务日志能保持事务的永久性。

7) 隔离级别分为：Read Uncommitted(读未提交)、Read Committed(读提交)、Repeatable Read(可以重复读)、Serializable(序列化)这4种级别

6、怎样建索引及索引的分类，索引有什么好处，要注意一些什么问题,如会不会影响其他表？

1) 建索引语法：create index dept_unique_idx on dept(dept_no) tablespace idx_1;

2) 索引的分类：

逻辑分类：单列索引、多列（复合）索引、唯一索引、非唯一索引、函数索引

物理分类：B-tree：B树索引、反向键索引、位图索引

3)创建索引可以大大提高系统的性能。第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。第二，可以大大加快数据的检索速度，这也是创建索引的最主要的原因。第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。第四，在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。

一般来说，应该在这些列上创建索引，例如：在经常需要搜索的列上，可以加快搜索的速度；在作为主键的列上，强制该列的唯一性和组织表中数据的排列结构；在经常用在连接的列上，这些列主要是一些外键，可以加快连接的速度；在经常需要根据范围进行搜索的列上创建索引，因为索引已经排序，其指定的范围是连续的；在经常需要排序的列上创建索引，因为索引已经排序，这样查询可以利用索引的排序，加快排序查询时间；在经常使用在WHERE子句中的列上面创建索引，加快条件的判断速度。

对于有些列不应该创建索引。一般来说，不应该创建索引的的这些列具有下列特点：第一，对于那些在查询中很少使用或者参考的列不应该创建索引。这是因为，既然这些列很少使用到，因此有索引或者无索引，并不能提高查询速度。相反，由于增加了索引，反而降低了系统的维护速度和增大了空间需求。第二，对于那些只有很少数据值的列也不应该增加索引。这是因为，由于这些列的取值很少，例如人事表的性别列，在查询的结果中，结果集的数据行占了表中数据行的很大比例，即需要在表中搜索的数据行的比例很大。增加索引，并不能明显加快检索速度。第三，对于那些定义为text, image和bit数据类型的列不应该增加索引。这是因为，这些列的数据量要么相当大，要么取值很少。第四，当修改性能远远大于检索性能时，不应该创建索引。这是因为，修改性能和检索性能是互相矛盾的。当增加索引时，会提高检索性能，但是会降低修改性能。当减少索引时，会提高修改性能，降低检索性能。因此，当修改性能远远大于检索性能时，不应该创建索引。

7、数据库中，数据类型char与varchar2有什么区别？性能方面各有什么优势？

char表示的是固定长度，所占存储空间为你定义时的大小，数据量较大的时候以char字段为查询条件时查询得快一些。

Varchar2表示的是实际长度的数据类型，所占存储空间为实际大小，前提是不超过你定义时的长度，如果存储的字段不是定长的，用varchar2好一些。

8、你怎么知道查询SQL的性能高还是低？

1）简单的通过查看执行SQL的运行时间。

2）可以通过查看数据库提供的语句执行计划来分析相应的数据信息，例如查看执行计划中对应的COST(即成本耗费)值，反应了运行这段SQL的总体估计成本，通常COST低的执行计划要好一些

9、在开发过程中遇到过数据库锁吗？怎样解锁？

1）如果oracle中有事务未提交，又打开一个窗口去提交一个新的事务则可能会产生数据库锁。

2）解锁的方式：

a) 结束当前的session（会话，此处指和数据库的通讯）自动解锁

例如,退出当前数据库连接所用的工具或应用程序.

b) 利用dba权限强行关闭掉了执行Lock操作的Session.

示例：通过以上查询知道了sid和 SERIAL#(流水号)就可以开杀（就是去关掉会话，俗称杀掉会话）了

--查询出对应会话操作的sid和serial

SELECT sid, serial#, username, osuser FROM v$session;

--根据指定的sid和serial来关闭对应的会话（杀会话的意思）

ALTER SYSTEM KILL SESSION 'sid,serial';

10、怎样处理并发数据?

就数据库操作来说是通过加锁的概念来确保并发数据操作下事务的完整性和数据库的一致性

数据库主要有共享锁和排它锁.当你在修改数据的时候,别人也可以查看,但是他不能修改数据并提交,只能优先你的操作,等你向数据库提交了数据之后他才能执行增删改的操作,这就是排它锁.共享锁就是你和另外一个用户可以同时共享数据（查看）,但是你和他都不能修改.

11、能写出oracle中你常用到的sqlplus命令吗？

1) 首先查看当前使用的数据库实例

select name from V$database;

2) 切换两个数据库实例

connect username/password@sid

3) 执行一个SQL脚本文件

SQL>start file_name

SQL>@ file_name

4) 重新运行上一次运行的sql语句

SQL>/

5) 显示一个表的结构

SQL> desc table_name

6) 执行一个存储过程

EXECUTE procedure_name

7) 显示当前的用户名

show user

12、 delete from table 与 truncate table的区别？drop table呢

1) Truncate是数据定义语言(DDL)做的修改是不能回滚的，就是不可恢复的操作。用了这个命令后就收回了表空间。Delete是数据操作语言(DML)删除是要把数据写入系统回滚段(rollback segement)中以便恢复时使用。

2) 两者都是删除表中的数据而不会影响到表的结构和定义.

3) 使用drop 的话就会删除表的结构

13、 union和union all有什么不同?

UNION在进行表连接后会筛选掉重复的记录，所以在表连接后会对所产生的结果集进行排序运算，删除重复的记录再返回结果。
　而UNION ALL只是简单的将两个结果合并后就返回。这样，如果返回的两个结果集中有重复的数据，那么返回的结果集就会包含重复的数据了。
　从效率上说，UNION ALL 要比UNION快很多，所以，如果可以确认合并的两个结果集中不包含重复的数据的话，那么就使用UNION ALL，

14、一个用户表中有一个积分字段，假如数据库中有100多万个用户，若要在每年第一天凌晨将积分清零，你将考虑什么，你将想什么办法解决?

alter table drop column score;

alter table add colunm score int;

可能会很快，但是需要试验，试验不能拿真实的环境来操刀，并且要注意，

这样的操作时无法回滚的，在我的印象中，只有inert update delete等DML语句才能回滚，

对于create table,drop table ,alter table等DDL语句是不能回滚。

解决方案一，update user set score=0;

解决方案二，假设上面的代码要执行好长时间，超出我们的容忍范围，那我就alter table user drop column score;alter table user add column score int。

下面代码实现每年的那个凌晨时刻进行清零，或者使用spring框架集成quartz来实现定时调度。

Runnable runnable =

new Runnable(){

public void run(){

clearDb();

schedule(this,new Date(new Date().getYear()+1,0,0));

}

};

schedule(runnable,new Date(new Date().getYear()+1,0,1));

第十三天

15、用JDBC如何调用存储过程

代码如下：

package com.huawei.interview.lym;

public class JdbcTest {

public static void main(String[] args) {

Connection con = null;

CallableStatement cstmt = null;

try {

con = ds.getConnection();

//调用的存储过程名字是insert_Student

cstmt = cn.prepareCall("{call insert_Student(?,?,?)}");

cstmt.registerOutParameter(3,Types.INTEGER);//输出参数

cstmt.setString(1, "wangwu");

cstmt.setInt(2, 25);

cstmt.execute();

} catch (Exception e) {

e.printStackTrace();

}finally{

//关闭资源

}

16、 JDBC访问数据库的步骤？

1) 加载JDBC驱动

2) 与数据库建立连接

3) 发送SQL语句，并得到返回结果

4) 处理返回结果

5) 关闭资源

17、写一个用jdbc连接并访问oracle数据的程序代码

Connection cn = null;

PreparedStatement pstmt =null;

Resultset rs = null;

try{

Class.forname(driveClassName);

cn = DriverManager.getConnection(url,username,password);

pstmt = cn.prepareStatement(“select * from user where username = ?”);

pstmt.setString(1,userName);

Resultset rs = pstmt.executeQuery();

while(rs.next()){

system.out.println(rs.getInt(“subject”) + “ |” + rs.getFloat(“score”) );

}

}catch(Exception e){e.printStackTrace();}

finally{

if(rs != null) try{ rs.close() }catch(exception e){}

if(pstmt != null) try{pstmt.close()}catch(exception e){}

if(cn != null) try{ cn.close() }catch(exception e){}

}

18、 Class.forName的作用?为什么要用?

答：Class.forName(“类的全限定名”)，按参数中指定的字符串形式的类名去搜索并加载相应的类，如果该类字节码已经被加载过，则返回代表该字节码的Class实例对象，否则，按类加载器的委托机制去搜索和加载该类，如果所有的类加载器都无法加载到该类，则抛出ClassNotFoundException。加载完这个Class字节码后，接着就可以使用Class字节码的newInstance方法去创建该类的实例对象了（反射机制）。

有时候，我们程序中所有使用的具体类名在设计时（即开发时）无法确定，只有程序运行时才能确定，这时候就需要使用Class.forName去动态加载该类.

JDBC中也使用Class.forName来动态加载对应数据库的驱动类，驱动类在加载的时候会自动执行对应驱动类中用于注册驱动的代码。

19、大数据量下的分页解决方法。

答：最好的办法是利用sql语句进行分页，这样每次查询出的结果集中就只包含某页的数据内容。在sql语句无法实现分页的情况下，可以考虑对大的结果集通过游标定位方式来获取某页的数据。

不同的数据库下的分页方案各不一样，下面是主流的三种数据库的分页sql：

sql server:

String sql =

"select top " + pageSize + " * from students where id not in" +

"(select top " + pageSize * (pageNumber-1) + " id from students order by id)" +

"order by id";

mysql:

String sql =

"select * from students order by id limit " + pageSize*(pageNumber-1) + "," + pageSize;

oracle:

String sql = "select * from " +

(select *,rownum rid from (select * from students order by postime desc) where rid<=" + pagesize*pagenumber + ") as t" + "where t>" + pageSize*(pageNumber-1);

20、这段代码有什么不足之处?

try {
Connection conn = ...;
Statement stmt = ...;

resultSet rs = stmt.executeQuery("select * from table1");

while(rs.next()) {

//封装记录

}

} catch(Exception ex) {

//异常处理

}

答：没有finally语句来关闭各个对象，另外，使用finally之后，要把变量的定义放在try语句块的外面，以便在try语句块之外的finally块中仍可以访问这些变量。

21、简述建立索引的作用和索引的分类 ?

索引的作用：通过使用索引，大大提高数据库的检索速度，改善数据库性能。

索引分类：

1) 唯一索引：唯一索引不允许两行具有相同的索引值

2) 主键索引：在数据库关系图中为表定义一个主键自动创建主键索引，主键索引是唯一索引的特殊类型

3) 聚集索引：在聚集索引中表中各行的事物顺序与键值的逻辑(索引)顺序相同且唯一

4) 非聚集索引：非聚集索引建立在索引页上，在查询数据时可以从索引中找到记录存放的位置

5) 复合索引：在创建索引时，并不是只能对其中一列创建索引，与创建主键一样，可以将多个列组合作为索引，这种索引称为复合索引

6) 全文索引：全文索引是一种特殊类型的基于标记的功能性索引，由SQL Server 中全文引擎服务创建和维护

22、什么是存储过程，有什么优缺点

存储过程（Stored Procedure）是一组为了完成特定功能的SQL语句集，是由流程控制和SQL语句书写的命名语句块，经编译和优化后存储在数据库服务器中，应用程序使用时只要调用即可，可以通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来调用。

使用存储过程有以下的优点：

a) 具有良好的安全性：可保证数据的安全性和完整性。通过存储过程可以使没有权限直接访问相应数据库对象的用户受控制的间接地执行数据库相关操作，从而保证数据的安全。

b) 执行速度快，效率高：在运行存储过程前，数据库已对其进行了语法和句法分析，并给出了优化执行方案。这种已经编译好的过程可极大地改善SQL语句的性能。由于执行SQL语句的大部分工作已经完成，所以存储过程能以极快的速度执行。

c) 减少网络流量：可以降低网络的通信量。

d) 模块化程序设计：存储过程可以封装业务逻辑，并存入数据服务器中，当业务逻辑发生变化时，无需修改调用存储过程的应用程序，只需修改存储过程即可。

使用存储过程的缺点是：

a) 相对而言，调试比较麻烦

b) 移植问题，数据库端代码当然是与具体数据库相关的。

c) 代码可读性差

23、数据库锁概念

在数据库中有两种基本的锁类型：排它锁（Exclusive Locks，即X锁）和共享锁（Share Locks，即S锁）。当数据对象被加上排它锁时，其他的事务不能对它读取和修改。加了共享锁的数据对象可以被其他事务读取，但不能修改。数据库利用这两种基本的锁类型来对数据库的事务进行并发控制。

从程序员的角度看,锁分为以下两种类型：

1.乐观锁（Optimistic Lock）

乐观锁假定在处理数据时，不需要在应用程序的代码中做任何事情就可以直接在记录上加锁、即完全依靠数据库来管理锁的工作。一般情况下，当执行事务处理时SQL Server会自动对事务处理范围内更新到的表做锁定。

2.悲观锁（Pessimistic Lock）

悲观锁对数据库系统的自动管理不感冒，需要程序员直接管理数据或对象上的加锁处理，并负责获取、共享和放弃正在使用的数据上的任何锁。

24、 Oracle存储过程的基本语法是什么？

CREATE OR REPLACE PROCEDURE 存储过程名 //1

IS //2

BEGIN //3

NULL; //4

END; //5

行1:

CREATE OR REPLACE PROCEDURE 是一个SQL语句通知Oracle数据库去创建一个叫做skeleton存储过程, 如果存在就覆盖它;

行2:

IS关键词表明后面将跟随一个PL/SQL体。

行3:

BEGIN关键词表明PL/SQL体的开始。

行4:

NULL PL/SQL语句表明什么事都不做，这句不能删去，因为PL/SQL体中至少需要有一句;

行5:

END关键词表明PL/SQL体的结束

25、存储过程与SQL的区别？

存储过程是一组预编译的SQL语句，经编译后存储在数据库中，可包含一个或多个SQL语句。能够完成一定功能的子程序，需要的时候用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。存储过程可以包含数据操作语言，逻辑和调用函数等；它又可分为系统存储过程和用户自定义的存储过程。

SQL指结构化查询语言，是一种ANSI的标准计算机语言。

26、什么是视图？它的作用？

视图是一个数据库中虚拟的表，经过查询操作形成的结果，具有普通表的结构，不能实现数据的存储，对视图的修改将会影响实际的数据表

作用：

1：是出于安全考虑，用户不必看到整个数据结构，而隐藏部分数据

2：符合用户日常业务逻辑，使他们对数据更容易理解

27、视图给用户和开发人员带来的好处

1) 对最终用户的好处：结果更容易理解，获得数据更容易

2) 对开发人员的好处：限制数据检索更容易，维护应用程序更方便

28、如何创建视图？

语法：create view 视图名 AS

JAVA技术面试题

一、 Java基础部分

第一天

1、 一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

2、 Java有没有goto?

3、 说说&和&&的区别。

4、 Java中的“短路”是指什么

5、 在JAVA中如何跳出当前的多重嵌套循环？

6、 switch（expression）语句中的expression（表达式）可以是什么类型?

7、 short s = 1; s = s + 1;有什么错? short s = 1; s += 1;有什么错?

8、 char型变量中能不能存贮一个中文汉字?为什么?

9、 用最有效率的方法算出2乘以8等于几?

10、 冒泡排序实现

11、 "=="和equals方法究竟有什么区别？

12、 两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

13、 写出Object类中定义的方法。

14、 hashCode方法的作用？

15、 写clone()方法时，通常都有一行代码，是什么？

16、 静态变量和实例变量的区别？

17、 谈谈你对static关键词的理解

18、 是否可以从一个static方法内部发出对非static方法的调用？

19、 Integer与int的区别

20、 Math.round(11.5)等於多少? Math.round(-11.5)等于多少?

第二天

21、 请说出作用域public，private，protected，以及不写时的区别

22、 public、protected和private这些访问权限修饰词的作用

23、 Overload和Override的区别。Overload的方法是否可以改变返回值的类型?

24、 什么是override？

25、 什么是overload？

26、 说说has a与is a的区别。

27、 一个房子里有椅子，椅子有腿和背，房子与椅子是什么关系，椅子与腿和背是什么关系？

28、 什么是参数?和参数化的意义?

29、 OOA和OOD是什么?

30、 构造器Constructor（构造方法）是否可被override(重写)?

31、 接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？

32、 面向对象的特征有哪些方面

33、 说出一些常用的类，包，接口，请各举5个

34、 写出JDK中至少5个以上的包名。

35、 java中实现多态的机制是什么？

36、 abstract class和interface有什么区别?

37、 java的接口和C++虚类的相同和不同之处

38、 abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

39、 什么是内部类？Static Nested Class 和 Inner Class的不同。

40、 内部类可以引用它的包含类的成员吗？有没有什么限制？

41、 Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

42、 jdk中哪些类是不能继承的？

43、 Java是否有过程和函数?

第三天

44、 String是最基本的数据类型吗?

45、 String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

46、 String类是否可以继承?

47、 String s = new String("xyz");创建了几个String Object?

48、 String 和StringBuffer的区别

49、 StringBuffer与StringBuilder的区别

50、 数组有没有length()这个方法? String有没有length()这个方法？

51、 使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

52、 final关键词有哪些应用

53、 final, finally, finalize的区别。

54、 运行时异常（RuntimeException）与一般异常有何异同？

55、 程序中try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被 执行？在什么时候被执行？

56、 error和exception有什么区别?

57、 Java中的异常处理机制的简单原理和应用。

58、 java语言如何进行异常处理，关键字：throws、throw、try、catch、finally分别代表什么意义？在try块中可以抛出异常吗?

59、 请写出你最常见到的5个runtime exception(运行时异常)。

第四天

60、 介绍Collection框架的结构

61、 Collection（集合）框架中实现比较要实现什么接口

62、 ArrayList和Vector的区别

63、 ArrayList和LinkedList有什么异同之处？

64、 HashMap和Hashtable的区别

65、 List 和 Map 区别?

66、 List, Set, Map是否继承自Collection接口?

67、 List、Map、Set三个接口，存取元素时，各有什么特点？

68、 说出ArrayList,Vector, LinkedList的存储性能和特性

69、 如何去掉一个Vector集合中重复的元素，有几种方法

70、 Collection 和 Collections的区别。

71、 Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

72、 你所知道的集合类都有哪些？主要方法？

73、 实现Map、Set接口有哪些集合

74、 列出你知道的容器类(就是指集合类)，简单说明其功能

1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？

3、说说&和&&的区别。

5、在JAVA中如何跳出当前的多重嵌套循环？

9、用最有效率的方法算出2乘以8等于几?

10、冒泡排序实现

12、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

13、写出Object类中定义的方法。

15、写clone()方法时，通常都有一行代码，是什么？

16、静态变量和实例变量的区别？

17、谈谈你对static关键词的理解

18、是否可以从一个static方法内部发出对非static方法的调用？

21、请说出作用域public，private，protected，以及不写时的区别

24、什么是override？

25、什么是overload？

26、说说has a与is a的区别。

27、一个房子里有椅子，椅子有腿和背，房子与椅子是什么关系，椅子与腿和背是什么关系？

28、什么是参数?和参数化的意义?

30、构造器Constructor（构造方法）是否可被override(重写)?

31、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？

32、面向对象的特征有哪些方面

33、说出一些常用的类，包，接口，请各举5个

34、写出JDK中至少5个以上的包名。

39、什么是内部类？Static Nested Class 和 Inner Class的不同。

40、内部类可以引用它的包含类的成员吗？有没有什么限制？

50、数组有没有length()这个方法? String有没有length()这个方法？

51、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

54、运行时异常（RuntimeException）与一般异常有何异同？

55、程序中try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被执行？在什么时候被执行？

59、请写出你最常见到的5个runtime exception(运行时异常)。

60、介绍Collection框架的结构

68、说出ArrayList,Vector, LinkedList的存储性能和特性

69、如何去掉一个Vector集合中重复的元素，有几种方法

72、你所知道的集合类都有哪些？主要方法？

73、实现Map、Set接口有哪些集合

74、列出你知道的容器类(就是指集合类)，简单说明其功能

76、集合框架中Collections和Arrays类的作用

78、数据结构中，数组与链表有哪些区别？为什么？

80、字节流与字符流的区别

81、什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。

82、序列化的概念和序列化ID的作用？

83、描述一下JVM（JAVA虚拟机）加载class文件的原理机制?

85、能不能自己写个类，也叫java.lang.String？

87、解释内存中的栈(stack)、堆(heap)和静态储存区的用法

90、垃圾回收的优点和原理。并考虑2种回收机制。

91、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

93、如何使用log4j记录日志？

94、单一职能原则

95、开闭原则

96、里氏替代原则

98、线程的基本概念、线程的基本状态以及状态之间的关系

99、同步和异步有何异同，在什么情况下分别使用他们？举例说明。

101、多线程有几种实现方法?同步有几种实现方法?

102、启动一个线程是用run()还是start()? .

104、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的该方法?

105、请说出你所知道的线程同步的方法。

107、线程类中的stop()和suspend()方法为何不推荐使用？

1、什么是Servlet

1、说一说Servlet的生命周期?

3、服务器如何响应Web客户请求？

4、 Servlet API中forward() 与sendRedirect ()的区别？（就是请求转发和重定向的区别）？

5、什么情况下调用doGet()和doPost()？

7、什么是Jsp

10、在JSP页面中如何定义一个方法？

18、如何实现servlet的单线程模式

19、在JSP中如何实现页面跳转？

20、在servlets和JSP之间能共享session对象吗？

21、什么是Cookie？

22、如何设置cookie在某一时间后过期？

23、在JSP中如何设置Cookie？

26、什么是MVC设计模式