Java面试-北大青鸟合肥科海学院

&&还具有短路的功能，即如果第一个表达式为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。

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

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

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

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

//代码1....

}

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

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

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

ok://定义的标号

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

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

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

if(j== 5) {

breakok;//跳出到指定的标号

}

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

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

boolean found = false;

for(int i=0;i<arr.length && !found;i++){

for(intj=0;j<arr[i].length;j++){

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

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

found= true;

break;

}

5、 switch语句能否作用在byte上，能否作用在long上?

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

6、 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编译器会对它进行特殊处理，因此可以正确编译。

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

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

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

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

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

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

9、冒泡排序实现

口诀：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<number.length-1;i++){

for(int j=0;j<number.length-1-i;j++){

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

temp=number[j+1];

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

number[j]=temp;

}

10、 "=="和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方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。

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

对。

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

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

12、写出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方法。

13、 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个对象是否相等，用==就可以了。

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

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

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

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

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

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

public class VariantTest{

public static intstaticVar = 0;

public int instanceVar= 0;

public VariantTest() {

staticVar++;

instanceVar++;

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

}

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

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

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

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

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

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

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

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

不可以。

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

18、 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中还定义了表示整数的最大值和最小值的常量。

19、 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。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

23、什么是override？

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

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

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

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

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

24、什么是overload？

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

面向对象的编程语言有封装、继承、多态等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);

31、说出一些常用的类，包，接口，请各举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<E>

2.java.util.Map<E>

3.java.util.Iterator<E>

4.java.sql.CallableStatement

5.java.lang.Comparable<T>

32、写出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类

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

public abstract class BaseServlet extends HttpServlet{

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

//记录访问日志

//进行权限判断

if(具有权限){

try{

doService(request,response);

}

catch(Excetpione){

//记录异常信息

}

protected abstract voiddoService(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个方面逐一去比较回答，接着从第三者继承的角度的回答，特别是最后用了一个典型的例子来展现自己深厚的技术功底。

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

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

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

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

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

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

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

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

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

36、 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是什么。

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

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

public class Outer{

int out_x = 0;

public void method(){

Inner1 inner1 = newInner1();

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

{

publicmethod(){

out_x =3;

}

Inner2 inner2 = newInner2();

}

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(){

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

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

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

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

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

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

class Outer{

static int x;

static class Inner{

void test(){

syso(x);

}

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

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

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

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

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

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

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

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

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

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

43、 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。

44、 String类是否可以继承?

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

45、 String s = new String("xyz");创建了几个String Object? 二者之间有什么区别？

两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。new String()每写一遍，就创建一个新的对象，它依据那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

46、 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集合类中时会出现问题。

47、 StringBuffer与StringBuilder的区别

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

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

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

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

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

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

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

a.append(" broken!");

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

public void method(final StringBuffer param){

}

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

param.append("a");

50、 final关键词有哪些应用

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

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

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

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

51、 final, finally, finalize的区别。

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

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

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

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

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

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

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

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

54、 error和exception有什么区别?

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

55、 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异常。

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

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

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

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

throw手动抛出异常

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

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

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

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

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

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

58、介绍Collection框架的结构

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

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

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

comparable/comparator

60、 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倍。

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

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

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

62、 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

63、 List 和 Map 区别?

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

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

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

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

List，Set是，Map不是

65、 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,Obje)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。

Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,objvalue)，每次存储时，要存储一对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中却加不了多次的（不支持重复元素）。

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

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

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

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

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

Vector newVector= new Vector();

for (int i=0;i<vector.size();i++){

Object obj = vector.get(i);

if(!newVector.contains(obj);

newVector.add(obj);

}

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

68、 Collection 和 Collections的区别。

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

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

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

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

两个比较方式的区别是：

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

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

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

最常用的集合类是 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的集合，另外一个返回的是所有value的集合，再一个返回的key和value组合成的EntrySet对象的集合，map也有get方法，参数是key，返回值是key对应的value。

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

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接口的实现类，缺省情况下是非同步的。

72、 Set和List的区别?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

82、能不能自己写个类，也叫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类的都将出现问题。

83、 heap和stack有什么区别。

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

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

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

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

85、 Java内存动态管理机制

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

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

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

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

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

1）引用计数收集器

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

2）跟踪收集器

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

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

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

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

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

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

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

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

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

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

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

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

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

(2)创建log4j.properties文件。

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

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

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

90、什么是DAO模式，使用该模式有哪些好处？

DAO 就是 Data Access Object(数据存取对象)，位于业务逻辑和持久化数据之间实现对持久化数据访问接口。

1.隔离了数据访问代码和业务逻辑代码

2.隔离了不同数据库实现

91、 DAO模式由哪几部分组成？

DAO接口：把对数据库的所有操作定义成一个抽象方法，可以提供多种实现。

DAO实现类：针对不同数据库的给出DAO接口定义方法的具体实现。

实体类：用于存放与传输对象数据

数据库连接和关闭工具类：提供了数据库连接和关闭资源的公共方法

92、单一职能原则

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

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

93、开闭原则

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

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

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

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

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

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

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

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

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

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

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

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

3对可变性的封装原则

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

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

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

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

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

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

94、里氏替代原则

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

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

95、 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()方法，返回表示字段，方法以及构造器的对象数组。

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

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

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

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

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

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

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

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

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

开启线程：对象.start()

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

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

t.start()//启动线程

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

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

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

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

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

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

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

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

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

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

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

第一种：继承Thread类

第二种：实现Runnable接口

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

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

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

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

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

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

104、 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状态和程序可以再次得到锁后继续向下运行。

105、线程类中的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虚拟机。

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

servlet有良好的生命周期的定义，包括加载和实例化、初始化、处理请求以及服务结束四个阶段。WEB容器加载Servlet，生命周期开始。首先

服务器调用Servlet的构造方法执行实例化操作，然后容器调用

Servlet的init方法执行初始化操作，请求到达时运行

Servlet的service方法，service方法自请求处理doXXX方法（doGet，doPost）等来处理请求，

当服务器决定将Servlet实例销毁前调用其destroy方法（用于释放Servlet占用资源，例如流、数据库连接等）。

3、 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方法即可。

4、服务器如何响应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）HttpServle调用HttpResponse的有关方法，生成响应数据；
　　8）Servlet容器把HttpServlet的响应结果传给Web客户。

5、 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处理完数据后进行页面跳转的两种主要方式

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

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

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

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

_______________________________________________________________________________ 方法名称说明

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

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

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

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

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

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

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

8、什么是Jsp

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

9、 JSP的执行过程?

1)翻译阶段：

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

2)编译阶段：

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

3)执行阶段：

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

注意:只有第一次请求JSP页面或者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有哪些标准动作?作用分别是什么?

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

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

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

jsp:setProperty：设置JavaBean的属性。

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

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

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

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

动态Include用jsp:include动作实现，<jsp:include page=”included.jsp” flush=true />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数

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

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

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

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

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

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

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

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

2) 在超链接中:href=”location=要跳转的页面”，例如<a href=”index.jsp”>首页</a>。

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

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

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

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

20、什么是Cookie？

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

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

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

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

代码如下：

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

ipAddrCookie.setMaxAge(60*10);

22、在JSP中如何设置Cookie？

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

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

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

23、 Cookie的应用场景？

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

2.统计网页浏览记录。

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

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

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

24、 cookie与session有什么区别?

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

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

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

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

25、什么是MVC设计模式

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

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

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

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

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

MVC的处理过程:

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

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

1)优点：

各司其职、互不干涉；

有利于开发中的分工；

有利于组建的重用；

2)缺点：

系统结构和实现复杂；

视图与控制器过于紧密；

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

27、 Web应用的目录结构:

_____________________________________________________________________

目录说明

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

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

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

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

_____________________________________________________________________

28、 Tomcat的目录结构:

_____________________________________________________________________

目录说明

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

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

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

/logs 存放Tomcat的日志文件

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

/webapps Web应用的发布目录

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

_____________________________________________________________________

29、 Tomcat工作原理？

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

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

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

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

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

30、什么是URL：

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

31、什么是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后面。

32、四种会话跟踪技术

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

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

1、用隐藏表单域（<inputtype="hidden">）

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

2、URL重写

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

3、Cookie技术

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

4、Session技术

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

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

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

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

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

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

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

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

36、什么是EL表达式

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

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

37、 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对象

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

比如登录页面表单有个表单项 <input type="text" name="userName">提交用户名，

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

3）.JSP隐式对象

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

38、什么是JSTL

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

39、 JSTL迭代标签使用？

<c:forEach var="变量名" items="被迭代的集合对象"varStatus="statu" begin="" end=""step="1">

</c:forEach>

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

var 是对当前成员的引用

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

end 表示结束位置，可省略

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

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

如：<c:forEach var ="变量名"varStatus="statu" begin="0" end="10" >

代码块

</c:forEach>

通过begin 和end 指定循环次数

40、 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标签里使用的。

内部样式表：内部样式表是放置在<head>标签内的，并且以<styletype=”text/css”></style>来定义的。

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

1）在页面中使用<linkrel=”stylesheet”href=”style.css”type=”text/css”>标签来链接到外部样式文件。

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，大到MicrosoftWord、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");

}elseif(window.XMLHttpRequest){

return new XMLHttpRequest();

}

//ajax操作

function showContent(titleobj){

varurl="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的？

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

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

配置JQuery环境的步骤

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

2）jQuery的调用示例：

//创建一个页面默认启动调用的特效

$(document).ready(

function(){

alert("页面启动时调用该方法!");

}

);

//以上代码也可以写成如下的简写方式

$(function(){

alert("页面启动时调用该方法!");

});

</script>

29、 jQuery 能做什么？

答：1.获取页面的元素

2. 修改页面的外观

3. 改变页面大的内容

4. 响应用户的页面操作

5. 为页面添加动态效果

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

7. 简化常见的javascript任务

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

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

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

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

31、什么是jQuery选择器

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

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

2)jQuery选择器的优点：

简洁的写法

完善的事件处理机制

支持CSS1到CSS3选择器

32、 jQuery选择器的种类

1).基本选择器

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

2).层次选择器

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

3).过滤器选择器

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

4).表单选择器

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

5).属性选择器

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

7).内容过滤器选择器

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

8).可见性过滤选择器

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

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

答：jQuery选择器支持CSS里的选择器，jQuery选择器可用来添加样式和添加相应的为CSS 中的选择器是只能添加相应的样式。

34、 siblings() 方法和 $('prev~div')选择器是一样的嘛？

答:$('prev~div') 只能选择'#prev'元素后面的同辈<div>元素而siblings()方法与前后的位置无关，只要是同辈节点就都能匹配。

35、 jQuery中的hover()和toggle()有什么区别？

答： hover()和toggle()都是jQuery中两个合成事件。

hover()方法用于模拟光标悬停事件。

toggle()方法是连续点击事件。

36、 $("#msg").text()和$("#msg").text("<b>new content</b>")有什么区别？
$("#msg").html()及$("#msg").html("<b>newcontent</b>")的区别呢？

答：$("#msg").text()是返回id为msg的元素节点的文本内容

$("#msg").text("<b>newcontent</b>"); 是将“<b>new content</b>” 作为普通文本串写入id为msg的元素节点内容中,页面直接显示“<b>newcontent</b>”，text()方法对HTML和XML文档都有效

$("#msg").html()则是取得id为msg的元素节点的html内容。这个函数不能用于XML文档。但可以用于XHTML文档

$("#msg").html("<b>newcontent</b>")，是将“<b>new content</b>”作为HTML内容写入id为msg的元素节点内容中,页面直接显示粗体的“new content”内容

37、 Jquery对象和dom对象的区别

Jquery对象才能调用jquery中特有的方法。例如jqueryObj.html()、jqueryObj.val()等方法，而不能使用dom对象特有的属性和方法，例如domObj.value,domObj.innerHTML等。

Jquery对象可以和dom对象相互转化

38、 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对象的构造函数

39、你是如何使用jQuery中的ajax的？

答: 如果是一些常规的ajax程序的话，使用$.load(),$.get(),$.post(),就可以搞定了，

一般我会使用的是$.get() 方法。

如果需要设定beforeSend(提交前回调函数),error(失败后处理),success(成功后处理)

及complete(请求完成后处理)回调函数等，这个时候我会使用$.ajax()

40、 jQuery中$.get()提交和$.post()提交有区别吗？

1）$.get() 方法使用GET方法来进行异步请求的，$.post() 方法使用POST方法来进行异步请求的。

2）get请求会将参数跟在URL后进行传递，而POST请求则是作为HTTP消息的实体正文内容发送给Web服务器的，这种传递是对用户不可见的。

3）get方式传输的数据大小不能超过2KB 而POST要大的多

4）GET 方式请求的数据会被浏览器缓存起来，因此有安全问题。

41、 jQuery中的load方法一般怎么用的？

答：load方法一般在载入远程HTML 代码并插入到DOM中的时候用通常用来从Web服务器上获取静态的数据文件。

如果要传递参数的话，可以使用$.get() 或 $.post()。

42、你在ajax中使用过JSON吗，你是如何用的？

答:使用过，在$.getJSON()方法的时候就是。因为 $.getJSON() 就是用于加载JSON文件的。此外，在使用jQuery的时候也使用json来进行参数的传递及执行结果的接收处理。

43、你使用过哪些数据格式，它们各有什么特点？

答: HTML格式 ,JSON格式, XML格式

1） HTML片段提供外部数据一般来说是最简单的。

2）如果数据需要重用，而且其他应用程序也可能一次受到影响，那么在性能和文件大小方面具有优势的JSON通常是不错的选择。

3）而当远程应用程序未知时，XML则能够为良好的互操作性提供最可靠的保证。

44、在jQuery执行ajax中，提交的data（数据）主要有几种方式？

答：三种，html拼接的，json数组，form表单经serialize()序列化的。

45、 jQuery是如何处理缓存的？

答：要处理缓存就是禁用浏览器缓存.

1）通过$.post()方法来获取数据，那么默认就是禁用缓存的。

2）通过$.get()方法来获取数据，可以通过设置时间戳来避免缓存。

可以在URL后面加上+(+new Date)来增加上时间戳参数

例：$.get('ajax.xml?'+(+newDate),function () {

//函数内容代码

});

3）通过$.ajax方法来获取数据，只要设置参数cache:false即可。

46、你读过有关于jQuery的书吗？

《jQuery基础教程》《jQuery实战》《锋利的jQuery》《巧用jQuery》《jQuery用户界面库学习指南》等

47、你知道jQuery中的事件冒泡吗，它是怎么执行的，何如来停止冒泡事件？

答: 知道,事件冒泡是从里面的往外面开始触发。

在jQuery中提供了stopPropagation()方法可以停止冒泡。

48、例如单击超链接后会自动跳转，单击"提交"按钮后表单会提交等，有时候我想阻止这些默认的行为，该怎么办？

答: 可以用 event.preventDefault()

或在事件处理函数中返回false，即 return false;

49、你使用过jQuery中的动画吗，是怎样用的？

答:使用过。

hide() 和 show() 同时修改多个样式属性。像高度，宽度，不透明度。

fadeIn() 和fadeOut() fadeTo() 只改变不透明度

slideUp() 和 slideDown() slideToggle() 只改变高度

animate() 属于自定义动画的方法.

50、你使用过jQuery中的插件吗？

答:看个人的实力和经验来回答了。例如easyUI，树形插件，表单验证插件，自动补全插件等等，结合项目大概说一下

51、怎样给jQuery动态附加新的元素?那么怎样给新生成的元素绑定事件呢？

jQuery的html()可以给现有元素附加新的元素。

直接在元素还未生成前就绑定肯定是无效的，因为所绑定的元素目前根本不存在。

所以我们可以通过live和livequery来动态绑定事件，这种绑定方式对现有和新生成的元素都有效。

52、 jQuery中有几种方法可以来设置和获取样式

答：addClass() 方法，attr() 方法

53、 jQuery中如何来获取或和设置属性？

答：jQuery中可以用attr()方法来获取和设置元素属性

removeAttr()方法来删除元素属性

54、解决jQuery和其它库的冲突

答：调用jQuery.noConflict()放弃对变量$的控制权，然后可以直接使用jQuery()来代替$()的调用方式。

两全其美的方式：

jQuery.noConflict();//移交变量$控制权

(function($){

$(“#myTable”).show();//此处又可以直接使用

变量$来执行jQuery的代码

})(jQuery)

四、项目开发经验

1、在eclipse中调试时，怎样查看一个变量的值？

在要查看的变量前先设置断点，然后选中变量，右键选debugas-->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)的共享池(sharedbuffer 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) 用NOTEXISTS替代NOTIN
在子查询中,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) 隔离级别分为：ReadUncommitted(读未提交)、Read Committed(读提交)、Repeatable Read(可以重复读)、Serializable(序列化)这4种级别

6、怎样建索引及索引的分类，索引有什么好处，要注意一些什么问题,如会不会影响其他表？

1) 建索引语法：create indexdept_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) 首先查看当前使用的数据库实例

selectname from V$database;

2) 切换两个数据库实例

connectusername/password@sid

3) 执行一个SQL脚本文件

SQL>startfile_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)删除是要把数据写入系统回滚段(rollbacksegement)中以便恢复时使用。

2) 两者都是删除表中的数据而不会影响到表的结构和定义.

3) 使用drop 的话就会删除表的结构

13、 union和union all有什么不同?

　UNION在进行表连接后会筛选掉重复的记录，所以在表连接后会对所产生的结果集进行排序运算，删除重复的记录再返回结果。
　而UNION ALL只是简单的将两个结果合并后就返回。这样，如果返回的两个结果集中有重复的数据，那么返回的结果集就会包含重复的数据了。
　从效率上说，UNION ALL 要比UNION快很多，所以，如果可以确认合并的两个结果集中不包含重复的数据的话，那么就使用UNION ALL，

14、一个用户表中有一个积分字段，假如数据库中有100多万个用户，若要在每年第一天凌晨将积分清零，你将考虑什么，你将想什么办法解决?

alter table dropcolumn score;

alter table addcolunm score int;

可能会很快，但是需要试验，试验不能拿真实的环境来操刀，并且要注意，

这样的操作时无法回滚的，在我的印象中，只有inert updatedelete等DML语句才能回滚，

对于create table,droptable ,alter table等DDL语句是不能回滚。

解决方案一，update user setscore=0;

解决方案二，假设上面的代码要执行好长时间，超出我们的容忍范围，那我就alter table userdrop column score;alter table user add column score int。

下面代码实现每年的那个凌晨时刻进行清零，或者使用spring框架集成quartz来实现定时调度。

Runnable runnable=

new Runnable(){

public void run(){

clearDb();

schedule(this,new Date(newDate().getYear()+1,0,0));

}

};

schedule(runnable,

new Date(new Date().getYear()+1,0,1));

15、用JDBC如何调用存储过程

代码如下：

packagecom.huawei.interview.lym;

publicclass JdbcTest {

public static void main(String[] args) {

Connection con= null;

CallableStatement cstmt = null;

try {

con = ds.getConnection();

//调用的存储过程名字是insert_Student

cstmt = cn.prepareCall("{callinsert_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(Exceptione){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:

Stringsql =

"select * from students order by idlimit " + pageSize*(pageNumber-1) + "," + pageSize;

oracle:

String sql = "select * from " +

(select *,rownum rid from (select * fromstudents 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(Exceptionex) {

//异常处理

}

答：没有finally语句来关闭各个对象，另外，使用finally之后，要把变量的定义放在try语句块的外面，以便在try语句块之外的finally块中仍可以访问这些变量。

21、简述建立索引的作用和索引的分类 ?

索引的作用：通过使用索引，大大提高数据库的检索速度，改善数据库性能。

索引分类：

1) 唯一索引：唯一索引不允许两行具有相同的索引值

2) 主键索引：在数据库关系图中为表定义一个主键自动创建主键索引，主键索引是唯一索引的特殊类型

3) 聚集索引：在聚集索引中表中各行的事物顺序与键值的逻辑(索引)顺序相同且唯一

4) 非聚集索引：非聚集索引建立在索引页上，在查询数据时可以从索引中找到记录存放的位置

5) 复合索引：在创建索引时，并不是只能对其中一列创建索引，与创建主键一样，可以将多个列组合作为索引，这种索引称为复合索引

6) 全文索引：全文索引是一种特殊类型的基于标记的功能性索引，由SQLServer 中全文引擎服务创建和维护

22、什么是存储过程，有什么优缺点

存储过程（StoredProcedure）是一组为了完成特定功能的SQL语句集，是由流程控制和SQL语句书写的命名语句块，经编译和优化后存储在数据库服务器中，应用程序使用时只要调用即可，可以通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来调用。

使用存储过程有以下的优点：

a) 具有良好的安全性：可保证数据的安全性和完整性。通过存储过程可以使没有权限直接访问相应数据库对象的用户受控制的间接地执行数据库相关操作，从而保证数据的安全。

b) 执行速度快，效率高：在运行存储过程前，数据库已对其进行了语法和句法分析，并给出了优化执行方案。这种已经编译好的过程可极大地改善SQL语句的性能。由于执行SQL语句的大部分工作已经完成，所以存储过程能以极快的速度执行。

c) 减少网络流量：可以降低网络的通信量。

d) 模块化程序设计：存储过程可以封装业务逻辑，并存入数据服务器中，当业务逻辑发生变化时，无需修改调用存储过程的应用程序，只需修改存储过程即可。

使用存储过程的缺点是：

a) 相对而言，调试比较麻烦

b) 移植问题，数据库端代码当然是与具体数据库相关的。

c) 代码可读性差

23、 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体的结束

24、存储过程与SQL的区别？

存储过程是一组预编译的SQL语句，经编译后存储在数据库中，可包含一个或多个SQL语句。能够完成一定功能的子程序，需要的时候用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。存储过程可以包含数据操作语言，逻辑和调用函数等；它又可分为系统存储过程和用户自定义的存储过程。

SQL指结构化查询语言，是一种ANSI的标准计算机语言。

25、什么是视图？它的作用？

视图是一个数据库中虚拟的表，经过查询操作形成的结果，具有普通表的结构，不能实现数据的存储，对视图的修改将会影响实际的数据表

作用：

1：是出于安全考虑，用户不必看到整个数据结构，而隐藏部分数据

2：符合用户日常业务逻辑，使他们对数据更容易理解

26、视图给用户和开发人员带来的好处

1) 对最终用户的好处：结果更容易理解，获得数据更容易

2) 对开发人员的好处：限制数据检索更容易，维护应用程序更方便

27、如何创建视图？

语法：create view 视图名 AS <select 语句>

28、如何删除视图？

drop view 视图名

29、 Oracle数据库的主要特点如下：

1) 支持多用户，大事务量的事务处理

2) 在保持数据安全性和完整性方面性能优越

3) 支持分布式数据处理，将分布在不同物理位置的数据用通信网络连接起来，在分布式数据库管理系统的控制下，组成一个逻辑上统一的数据库，完成数据处理任务。

4) 具有可移植性。Oracle可以在Windows，Linux等多个操作系统平台上使用，可以在不同操作系统间移植数据库。而SQL Server只能在Windows平台上运行

30、 Oracle 基本概念

1) 数据库: 这里的数据库不是通常情况下我们所说的数据库，而是Oracle的一个专业名词。

2) 数据库实例：每个启动的数据库都对应一个数据库实例，然后由这个实例来访问和控制数据库

3) 数据文件(扩展名是.DBF)：是用于存储数据的文件，例如存储数据库表中的记录，索引，存储过程，视图，数据字典定义等。

4) 控制文件(扩展名是.CTL)：是一个二进制文件，控制文件中存储信息很多，其中包括数据文件和日志文件的名字和位置。

5) 日志文件（扩展名是.LOG）它记录了对数据库的所有更改信息，并提供了一种数据恢复机制，确保在系统崩溃或其他意外出现后重新恢复数据库

6) 表空间：每个Oracle数据库都是由若干个表空间构成的，用户在数据库建立的所有内容都被存储表空间中，一个表空间可以有多个数据文件，但是一个数据文件只能属于一个表空间

31、数据库、数据库实例的含义及区别？

数据库是指磁盘上存储数据的集合，在物理上表现为数据文件，日志文件和控制文件等，在逻辑上以表空间形式存在。

数据库实例就是为了运行数据库，Oracle系统所运行的所有进程和分配内存结构的组合体。

32、 Oracle使用PL/SQL Developer导出数据的三种方式及区别？

1、导出为.dmp的文件格式，.dmp文件是二进制的，可以跨平台，还能包含权限，效率也很不错，用得最广

2、导出为.sql文件的，可用文本编辑器查看，通用性比较好，但效率不如第一种，适合小数据量导入导出。尤其注意的是表中不能有大字段（blob,clob），如果有，会提示不能导出，可以用第一种和第三种方式导出。

3、导出为.pde格式的，.pde为Pl/sql developer自有的文件格式，只能用Pl/sql developer自己导入导出；不能用编辑器查看

33、游标（CURSOR）的概念

游标是用来处理使用查询语句从数据库中检索到记录的工具，借助游标可以对一组记录逐个进行处理。每次处理一行。在进行游标提取时，单条记录使用fetch语句提取，当返回多条记录时需要使用循环语句提取结果集。

游标的分类

1）显示游标

返回多条记录时，使用显示游标逐行读取

2）隐式游标

PL/SQL自动为DML语句创建隐式游标，包含一条返回记录

游标的使用分为哪几个步骤？

声明游标
打开游标
提取游标
关闭游标

34、表分区的特点及实现方式

1）分区是指将表拆成几个部分，其特点是：

增强数据库的可用性，减少维护工作量，均衡I/O，提高查询速度，分区对用户保持透明

2）分区的实现方式

范围分区列表分区散列分区索引分区

35、 SYS和SYSTEM中，哪个用户权限更大？

SYS权限更大

SYS用户主要用来维护系统信息和管理实例，SYSTEM用户管理Oracle数据库的用户，权限和存储等。

36、 Oracle中用什么函数按字符串截取字段？

substr(string,a,b) 返回从a开始b个字符长度的字符串

如：substr(‘Hello,Oracle’,1,5) 输出：Hello

注意：oracle数据库中索引从1开始

37、 Oracle有哪些常用的函数？

1) 字符函数

a. lower(char)：将字符串转化为小写的格式。

b. upper(char)：将字符串转化为大写的格式。

c. length(char)：返回字符串的长度。

d. substr(char, m, n)：截取字符串的子串，n代表取n个字符的意思，不是代表取到第n个

2) 数学函数

a. round(n,[m]) 该函数用于执行四舍五入。如果省掉m，则四舍五入到整数。如果m是正数，则四舍五入到小数点的m位后。如果m是负数，则四舍五入到小数点的m位前。

b. .trunc(n,[m]) 该函数用于截取数字。如果省掉m，就截去小数部分，如果m是正数就截取到小数点的m位后，如果m是负数，则截取到小数点的前m位。

c. mod(m,n)取余函数。

d. floor(n) 返回小于或是等于n的最大整数

e. ceil(n) 返回大于或是等于n的最小整数

f. abs(n) 返回数字n的绝对值

3) 日期函数

a. sysdate 返回系统时间

b. add_months函数可以得到某一时间之前或之后n个月的间

c. last_day(d)：返回指定日期所在月份的最后一天

4) 转换函数

a. to_char()函数:

转换字符TO_CHAR(c):将nchar,nvarchar2,clob,nclo类型转换为char类型;

转换时间TO_CHAR(d[,fmt])：将指定的时间(data,timestamp,timestampwithtime zone)按照指定格式转换为varchar2类型；

转换数值TO_CHAR(n[,fmt])：将指定数值n按照指定格式fmt转换为varchar2类型并返回；

b. to_date()函数：用于将字符串转换成date类型的数据。

六、 XML部分

1、 Java解析XML有哪几种方法？并简述各自的优缺点(重复题个人觉得比较好)

解析方式有两种：

1) SAX：不用事先调入整个文档，占用资源较少，但是SAX不是持久的，如果事后没有保存

2) DOM：整个文档树在内存中,便于操作,支持删除、修改、重新排列等多种功能，缺点是：将整个文档调入内存(包括无用的节点),浪费时间和空间

常用的解析框架：

1) DOM4J：是一个非常非常优秀的xml解析工具包,具有性能优异、功能强大和极端易用使用的特点

2) JDOM：一个XML解析用的工具包，极大的减少了代码量

2、你在项目中用到了xml技术的哪些方面?如何实现的?

答:用到了数据存贮，信息配置两方面。

在做数据交换平台时，将数据源的数据组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再从XML文件中还原相关信息进行处理。

在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中。

3、 XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？

1): 两种形式 dtd schema。

2): 本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)。

3): 有DOM,SAX

DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问

SAX:不同于DOM,SAX是事件驱动型的XML解析方式。它是有序的读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问

4、如何使用DOM模式解析XML文档？

1.创建解析器工厂对象

2.由解析器工厂对象创建解析器对象

3.由解析器对象指定的XML文件进行解析，构建相应DOM树，创建Document对象

4.以Document对象为起点对DOM树的节点进行增删改查操作。

七、 Mybatis常见面试题

1、 #{}和${}的区别是什么？

答：${}是Properties文件中的变量占位符，它可以用于标签属性值和sql内部，属于静态文本替换，比如${driver}会被静态替换为com.mysql.jdbc.Driver。#{}是sql的参数占位符，Mybatis会将sql中的#{}替换为?号，在sql执行前会使用PreparedStatement的参数设置方法，按序给sql的?号占位符设置参数值，比如ps.setInt(0,parameterValue)，#{item.name}的取值方式为使用反射从参数对象中获取item对象的name属性值，相当于param.getItem().getName()。

2、 Xml映射文件中，除了常见的select|insert|updae|delete标签之外，还有哪些标签？

3、最佳实践中，通常一个Xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？

注：这道题也是京东面试官面试我时问的。

答：Dao接口，就是人们常说的Mapper接口，接口的全限名，就是映射文件中的namespace的值，接口的方法名，就是映射文件中MappedStatement的id值，接口方法内的参数，就是传递给sql的参数。Mapper接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为key值，可唯一定位一个MappedStatement，举例：com.mybatis3.mappers.StudentDao.findStudentById，可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面id= findStudentById的MappedStatement。在Mybatis中，每一个<select>、<insert>、<update>、<delete>标签，都会被解析为一个MappedStatement对象。

Dao接口里的方法，是不能重载的，因为是全限名+方法名的保存和寻找策略。

Dao接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象，代理对象proxy会拦截接口方法，转而执行MappedStatement所代表的sql，然后将sql执行结果返回。

4、 Mybatis是如何进行分页的？分页插件的原理是什么？

注：

答：Mybatis使用RowBounds对象进行分页，它是针对ResultSet结果集执行的内存分页，而非物理分页，可以在sql内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。

分页插件的基本原理是使用Mybatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的sql，然后重写sql，根据dialect方言，添加对应的物理分页语句和物理分页参数。

举例：select * from student，拦截sql后重写为：select t.* from （select * fromstudent）t limit 0，10

5、简述Mybatis的插件运行原理，以及如何编写一个插件。

答：Mybatis仅可以编写针对ParameterHandler、ResultSetHandler、StatementHandler、Executor这4种接口的插件，Mybatis使用JDK的动态代理，为需要拦截的接口生成代理对象以实现接口方法拦截功能，每当执行这4种接口对象的方法时，就会进入拦截方法，具体就是InvocationHandler的invoke()方法，当然，只会拦截那些你指定需要拦截的方法。

实现Mybatis的Interceptor接口并复写intercept()方法，然后在给插件编写注解，指定要拦截哪一个接口的哪些方法即可，记住，别忘了在配置文件中配置你编写的插件。

6、 Mybatis执行批量插入，能返回数据库主键列表吗？

答：能，JDBC都能，Mybatis当然也能。

7、 Mybatis动态sql是做什么的？都有哪些动态sql？能简述一下动态sql的执行原理不？

其执行原理为，使用OGNL从sql参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql的功能。

8、 Mybatis是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式？

答：第一种是使用<resultMap>标签，逐一定义列名和对象属性名之间的映射关系。第二种是使用sql列的别名功能，将列别名书写为对象属性名，比如T_NAME AS NAME，对象属性名一般是name，小写，但是列名不区分大小写，Mybatis会忽略列名大小写，智能找到与之对应对象属性名，你甚至可以写成T_NAME AS NaMe，Mybatis一样可以正常工作。

有了列名与属性名的映射关系后，Mybatis通过反射创建对象，同时使用反射给对象的属性逐一赋值并返回，那些找不到映射关系的属性，是无法完成赋值的。

9、 Mybatis能执行一对一、一对多的关联查询吗？都有哪些实现方式，以及它们之间的区别。

答：能，Mybatis不仅可以执行一对一、一对多的关联查询，还可以执行多对一，多对多的关联查询，多对一查询，其实就是一对一查询，只需要把selectOne()修改为selectList()即可；多对多查询，其实就是一对多查询，只需要把selectOne()修改为selectList()即可。

关联对象查询，有两种实现方式，一种是单独发送一个sql去查询关联对象，赋给主对象，然后返回主对象。另一种是使用嵌套查询，嵌套查询的含义为使用join查询，一部分列是A对象的属性值，另外一部分列是关联对象B的属性值，好处是只发一个sql查询，就可以把主对象和其关联对象查出来。

那么问题来了，join查询出来100条记录，如何确定主对象是5个，而不是100个？其去重复的原理是<resultMap>标签内的<id>子标签，指定了唯一确定一条记录的id列，Mybatis根据<id>列值来完成100条记录的去重复功能，<id>可以有多个，代表了联合主键的语意。

同样主对象的关联对象，也是根据这个原理去重复的，尽管一般情况下，只有主对象会有重复记录，关联对象一般不会重复。

举例：下面join查询出来6条记录，一、二列是Teacher对象列，第三列为Student对象列，Mybatis去重复处理后，结果为1个老师6个学生，而不是6个老师6个学生。

t_id t_name s_id

| 1 | teacher | 38 |
| 1 | teacher |    39 |
| 1 | teacher |    40 |
| 1 | teacher |    41 |
| 1 | teacher |    42 |
| 1 | teacher |    43 |

10、 Mybatis是否支持延迟加载？如果支持，它的实现原理是什么？

答：Mybatis仅支持association关联对象和collection关联集合对象的延迟加载，association指的就是一对一，collection指的就是一对多查询。在Mybatis配置文件中，可以配置是否启用延迟加载lazyLoadingEnabled=true|false。

它的原理是，使用CGLIB创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用a.getB().getName()，拦截器invoke()方法发现a.getB()是null值，那么就会单独发送事先保存好的查询关联B对象的sql，把B查询上来，然后调用a.setB(b)，于是a的对象b属性就有值了，接着完成a.getB().getName()方法的调用。这就是延迟加载的基本原理。

当然了，不光是Mybatis，几乎所有的包括Hibernate，支持延迟加载的原理都是一样的。

11、 Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？

答：不同的Xml映射文件，如果配置了namespace，那么id可以重复；如果没有配置namespace，那么id不能重复；毕竟namespace不是必须的，只是最佳实践而已。

原因就是namespace+id是作为Map<String, MappedStatement>的key使用的，如果没有namespace，就剩下id，那么，id重复会导致数据互相覆盖。有了namespace，自然id就可以重复，namespace不同，namespace+id自然也就不同。

12、 Mybatis中如何执行批处理？

答：使用BatchExecutor完成批处理。

13、 Mybatis都有哪些Executor执行器？它们之间的区别是什么？

答：Mybatis有三种基本的Executor执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。

SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。

ReuseExecutor：执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭Statement对象，而是放置于Map<String, Statement>内，供下一次使用。简言之，就是重复使用Statement对象。

BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。

作用范围：Executor的这些特点，都严格限制在SqlSession生命周期范围内。

14、 Mybatis中如何指定使用哪一种Executor执行器？

答：在Mybatis配置文件中，可以指定默认的ExecutorType执行器类型，也可以手动给DefaultSqlSessionFactory的创建SqlSession的方法传递ExecutorType类型参数。

15、 Mybatis是否可以映射Enum枚举类？

答：Mybatis可以映射枚举类，不单可以映射枚举类，Mybatis可以映射任何对象到表的一列上。映射方式为自定义一个TypeHandler，实现TypeHandler的setParameter()和getResult()接口方法。TypeHandler有两个作用，一是完成从javaType至jdbcType的转换，二是完成jdbcType至javaType的转换，体现为setParameter()和getResult()两个方法，分别代表设置sql问号占位符参数和获取列查询结果。

16、 Mybatis映射文件中，如果A标签通过include引用了B标签的内容，请问，B标签能否定义在A标签的后面，还是说必须定义在A标签的前面？

答：虽然Mybatis解析Xml映射文件是按照顺序解析的，但是，被引用的B标签依然可以定义在任何地方，Mybatis都可以正确识别。

原理是，Mybatis解析A标签，发现A标签引用了B标签，但是B标签尚未解析到，尚不存在，此时，Mybatis会将A标签标记为未解析状态，然后继续解析余下的标签，包含B标签，待所有标签解析完毕，Mybatis会重新解析那些被标记为未解析的标签，此时再解析A标签时，B标签已经存在，A标签也就可以正常解析完成了。

17、简述Mybatis的Xml映射文件和Mybatis内部数据结构之间的映射关系？

答：Mybatis将所有Xml配置信息都封装到All-In-One重量级对象Configuration内部。在Xml映射文件中，<parameterMap>标签会被解析为ParameterMap对象，其每个子元素会被解析为ParameterMapping对象。<resultMap>标签会被解析为ResultMap对象，其每个子元素会被解析为ResultMapping对象。每一个<select>、<insert>、<update>、<delete>标签均会被解析为MappedStatement对象，标签内的sql会被解析为BoundSql对象。

18、为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？

答：Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它是全自动的。而Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以，称之为半自动ORM映射工具。

19、要使用LIKE语句该怎么写?

2、有两种使用LIKE的方法。(推荐使用)第一种方法是,在Java代码中添加SQL通配符。

示例一:

01.String wildcardName ="%Smi%";

02.List<Name> names =mapper.selectLike(wildcardName);

01.<selectid="selectLike">

02. select * from foo where bar like #{value}

03.</select>

第二种方式是在SQL语句中拼接通配符。这种方法相对来说安全性要低一些,因为可能会被SQL注入攻击。

示例二:

01.String wildcardName ="Smi";

02.List<Name> names =mapper.selectLike(wildcardName);

01.<selectid="selectLike">

02. select * from foo where bar like '%' || '${value}' || '%'

03.</select>

重要提示: 请注意两种方式中 $ 和 # 的使用!

20、如何执行批量插入?

首先,创建一个简单的insert语句:

01.<insertid="insertName">

02. insert into names (name) values (#{value})

03.</insert>

然后在Java代码中像下面这样执行批处理插入:

01.List<String> names = newArrayList<String>();

02.names.add("Fred");

03.names.add("Barney");

04.names.add("Betty");

05.names.add("Wilma");

06.

07.// 注意这里 ExecutorType.BATCH

08.SqlSession sqlSession =sqlSessionFactory.openSession(ExecutorType.BATCH);

09.try {

10. NameMapper mapper = sqlSession.getMapper(NameMapper.class);

11. for (String name : names) {

12. mapper.insertName(name);

13. }

14. sqlSession.commit();

15.} finally {

16. sqlSession.close();

17.}

21、如何获取自动生成的(主)键值?

insert 方法总是返回一个int值 - 这个值代表的是插入的行数。而自动生成的键值在 insert 方法执行完后可以被设置到传入的参数对象中。

示例:

01.<insert id="insertName"useGeneratedKeys="true" keyProperty="id">

02. insert into names (name) values (#{name})

03.</insert>

01.Name name = new Name();

02.name.setName("Fred");

03.

04.int rows = mapper.insertName(name);

05.// 完成后,id已经被设置到对象中

06.System.out.println("rows inserted =" + rows);

07.System.out.println("generated keyvalue = " + name.getId());

22、在mapper中如何传递多个参数?

Java的反射机制并不能让框架获取到参数的名字(方法签名中只有参数类型,可以说是为了优化,也可以说设计就是如此,总之名字无意义), 所以MyBatis默认的命名为:param1,param2……

如果想给他们指定名称,可以使用 @param 注解:

01.importorg.apache.ibatis.annotations.Param;

02.public interface UserMapper {

03. User selectUser(@Param("username") String username,

04. @Param("hashedPassword")String hashedPassword);

05.}

然后,就可以在xml像下面这样使用(推荐封装为一个Map,作为单个参数传递给Mapper):

01.<select id=”selectUser”resultType=”User”>

02. select id, username, hashedPassword

03. from some_table

04. where username = #{username}

05. and hashedPassword = #{hashedPassword}

06.</select>

八、 Hibernate框架技术

1、为什么需要使用Hibernate？

选择一门新技术，首先要看这门技术是否能够满足目前应用的需求，我们承认任何事物都不会十分完美的同也在不断追求着能够为本身应用带来巨大价值的途径。

1)Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现，可以自动完成object和关系数据库之间的转换，提高开发效率。用Hibernate，通过面向对象的方式进行查询（对查询结果自动封装到实体，而不像jdbc那样手动封装）、轻量级封装jdbc操作是它最大的优势。

2)hibernate可以跨数据库。作为一个通用orm框架，首先必须兼容主流的数据库，如果hibernate只能在某一个数据库上跑。那它肯定不会有目前的成就。

3)结果这一点就变成了很多产品开发的基础，这些产品只需要关注自己的业务，不需要考虑在不同的数据库之间进行迁移了，一切底层都交给hibernate，只做好自己擅长的事情，花最少的时间获得最大的价值。

4)hibernate上面附着了一大堆的扩展，hibernate-validator可以做数据校验，hibernate-search可以玩全文检索，hibernate-shard可以做水平分表。

5)Hibernate的性能非常好，因为它是个轻量级框架，映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

2、 Hibernate使用步骤

1) 导入hibernate的jar文件和数据库的jar文件

2) 编写hibernate配置文件，hibernate.cfg.xml，默认放在src目录，此文件保存数据库的连接信息，hibernate全局属性信息，以及关联的实体映射文件。

3) 编写实体及实体映射文件。如果是在3.2以上版本，则可用注解的方式，可不需要编写.hbm.xml文件。

编写完了配置文件之后，具体的使用步骤如下：

1) 读取并解析配置文件

2) 读取并解析映射信息，创建SessionFactory

3) 打开Session

4) 创建事务Transaction

5) 持久化操作

6) 提交事务

7) 关闭Session

8) 关闭SessionFactory

上面这些步骤是在单独使用Hibernate的步骤，如果通过spring集成Hibernate，则代码更加的简单。例如使用Spring的AOP声明式事务，则不需要手工开启和关闭Session及提交或回滚事务。

3、谈谈你对Hibernate的理解。

1). 面向对象设计的软件内部运行过程可以理解成就是在不断创建各种新对象、建立对象之间的关系，调用对象的方法来改变各个对象的状态和对象消亡的过程，不管程序运行的过程和操作怎么样，本质上都是要得到一个结果，程序上一个时刻和下一个时刻的运行结果的差异就表现在内存中的对象状态发生了变化。

2).为了在关机和内存空间不够的状况下，保持程序的运行状态，需要将内存中的对象状态保存到持久化设备和从持久化设备中恢复出对象的状态，通常都是保存到关系数据库来保存大量对象信息。从Java程序的运行功能上来讲，保存对象状态的功能相比系统运行的其他功能来说，应该是一个很不起眼的附属功能，java采用jdbc来实现这个功能，这个不起眼的功能却要编写大量的代码，而做的事情仅仅是保存对象和恢复对象，并且那些大量的jdbc代码并没有什么技术含量，基本上是采用一套例行公事的标准代码模板来编写，是一种苦活和重复性的工作。

3).通过数据库保存java程序运行时产生的对象和恢复对象，其实就是实现了java对象与关系数据库记录的映射关系，称为ORM（即Object RelationMapping），人们可以通过封装JDBC代码来实现了这种功能，封装出来的产品称之为ORM框架，Hibernate就是其中的一种流行ORM框架。使用Hibernate框架，不用写JDBC代码，仅仅是调用一个save方法，就可以将对象保存到关系数据库中，仅仅是调用一个get方法，就可以从数据库中加载出一个对象。

4).使用Hibernate的基本流程是：配置Configuration对象、产生SessionFactory、创建session对象，启动事务，完成CRUD操作，提交事务，关闭session。

5).使用Hibernate时，先要配置hibernate.cfg.xml文件，其中配置数据库连接信息和方言等，还要为每个实体配置相应的hbm.xml文件，hibernate.cfg.xml文件中需要登记每个hbm.xml文件。

6).在应用Hibernate时，重点要了解Session的缓存原理，级联，延迟加载和hql查询。

4、 iBatis与Hibernate有什么不同?

相同点：屏蔽jdbc api的底层访问细节，使用我们不用与jdbc api打交道，就可以访问数据。

jdbc api编程流程固定，还将sql语句与java代码混杂在了一起，经常需要拼凑sql语句，细节很繁琐。

ibatis的好处：屏蔽jdbc api的底层访问细节；将sql语句与java代码进行分离;提供了将结果集自动封装称为实体对象和对象的集合的功能，queryForList返回对象集合，用queryForObject返回单个对象；提供了自动将实体对象的属性传递给sql语句的参数。

Hibernate是一个全自动的orm映射工具，它可以自动生成sql语句,ibatis需要我们自己在xml配置文件中写sql语句，hibernate要比ibatis功能负责和强大很多。因为hibernate自动生成sql语句，我们无法控制该语句，我们就无法去写特定的高效率的sql。对于一些不太复杂的sql查询，hibernate可以很好帮我们完成，但是，对于特别复杂的查询，hibernate就很难适应了，这时候用ibatis就是不错的选择，因为ibatis还是由我们自己写sql语句。

5、 Hibernate中实体对象的三种状态。

1) 瞬时状态

2) 持久状态

3) 游离状态

6、介绍一下Hibernate的二级缓存

按照以下思路来回答：

（1）首先说清楚什么是缓存，（2）再说有了hibernate的Session就是一级缓存，即有了一级缓存，为什么还要有二级缓存，（3）最后再说如何配置Hibernate的二级缓存。

1) 缓存就是把以前从数据库中查询出来和使用过的对象保存在内存中（一个数据结构中），这个数据结构通常是或类似Hashmap，当以后要使用某个对象时，先查询缓存中是否有这个对象，如果有则使用缓存中的对象，如果没有则去查询数据库，并将查询出来的对象保存在缓存中，以便下次使用。

2) Hibernate的Session就是一种缓存，我们通常将之称为Hibernate的一级缓存，当想使用session从数据库中查询出一个对象时，Session也是先从自己内部查看是否存在这个对象，存在则直接返回，不存在才去访问数据库，并将查询的结果保存在自己内部。由于Session代表一次会话过程，一个Session与一个数据库连接相关连，所以Session最好不要长时间保持打开，通常仅用于一个事务当中，在事务结束时就应关闭。并且Session是线程不安全的，被多个线程共享时容易出现问题。通常只有那种全局意义上的缓存才是真正的缓存应用，才有较大的缓存价值，因此，Hibernate的Session这一级缓存的缓存作用并不明显，应用价值不大。Hibernate的二级缓存就是要为Hibernate配置一种全局缓存，让多个线程和多个事务都可以共享这个缓存。我们希望的是一个人使用过，其他人也可以使用，session没有这种效果。

3) 二级缓存是独立于Hibernate的软件部件，属于第三方的产品，多个厂商和组织都提供有缓存产品，例如，EHCache和OSCache等等。在Hibernate中使用二级缓存，首先就要在hibernate.cfg.xml配置文件中配置使用哪个厂家的缓存产品，接着需要配置该缓存产品自己的配置文件，最后要配置Hibernate中的哪些实体对象要纳入到二级缓存的管理中。明白了二级缓存原理和有了这个思路后，很容易配置起Hibernate的二级缓存。扩展知识：一个SessionFactory可以关联一个二级缓存，也即一个二级缓存只能负责缓存一个数据库中的数据，当使用Hibernate 的二级缓存后，注意不要有其他的应用或SessionFactory来更改当前数据库中的数据，这样缓存的数据就会与数据库中的实际数据不一致。

7、 Hibernate的数据加载方式

1) 即时加载

2) 延迟加载

①　集合类型的延迟加载

②　实体对象的延迟加载

③　属性延迟加载

区别：

1) 即时加载，当实体加载完后，立即加载其关联数据。

2) 延迟加载就是当真正需要数据的时候，才真正执行数据加载操作。

8、 Hibernate如何延迟加载？

延迟加载机制是为了避免一些无谓的性能开销而提出来的，所谓延迟加载就是当在真正需要数据的时候，才真正执行数据加载操作。在Hibernate中提供了对实体对象的延迟加载以及对集合的延迟加载，另外在Hibernate3中还提供了对属性的延迟加载。下面我们就分别介绍这些种类的延迟加载的细节。

1) 实体对象的延迟加载：<classname=”com.neusoft.entity.User” table=”user” lazy=”true”></class>

2) 集合类型的延迟加载：<set name=”addresses”table=”address” lazy=”true” />

3) 属性延迟加载：<property name=”resume”type=”java.sql.Clob” column=”resume” lazy=”true”/>（需要对该实体类做字节码增强操作，否则无法生效）

4) 实体属性延时加载<many-to-one />

9、 Hibernate中怎样实现类之间的关系？（如：一对多、多对多关系）

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many。

最常用的关系是双向一对多关系，也即主从表之间的关系：

双向一对多关系中，在这表这边配置：

Set集合，one-to-many

在从表这边配置many-to-one

10、如何优化Hibernate？

1) 灵活使用单向一对多关联

2) 不用一对一、用多对一取代

3) 配置对象缓存，不使用集合缓存

4) 一对多集合使用Bag，多对多集合使用Set

5) 继承类使用显示多态

6) 表字段要少，表关联不要怕多，有二级缓存撑腰

7) 使用双向一对多关联，不是单向一对多

11、说下Hibernate缓存机制

内部缓存在Hibernate中又叫一级缓存，属于应用事务级缓存

二级缓存：

1) 应用级缓存

2) 分布式缓存

条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据

3) 第三方缓存的实现

12、 hibernate进行多表查询每个表中各取几个字段，也就是说查询出来的结果集没有一个实体类与之对应如何解决

1) 解决方案一，按照Object[]数据取出数据，然后自己组bean

解决方案二，对每个表的bean写构造函数，比如表一要查出field1,field2两个字段，那么有一个构造函数就是Bean(type1filed1,type2 field2) ，然后在hql里面就可以直接生成这个bean了。

13、 hibernate的工作原理

从以下四个方面来说明工作原理：

1) hibernate如何连接数据库？

配置文件Hibernate.cfg.xml文件中定义了和数据库进行连接的信息，包括数据库方言.jdbc驱动.用户名.密码和URL等。Configuration 类借助dom4j的xml解析器进行xml的解析设置环境，然后使用这些环境属性来生成sessionfactory。这样sessionfactory生成的session 就能够成功获得数据库的连接。

2) hibernate如何进行数据库写操作？

当保存一个pojo持久化对象时，触发Hibernate保存事件监听器进行处理。Hibernate通过映射文件获得对象对应的数据库。表名以及属性对应的数据库列名，然后通过反射机制获得持久化对象的各个属性，最终组织向数据库插入新对象的SQL的insert语句。调用session.save（）保存数据后这个对象会被标识为持久化状态放在session，当事务进行提交时才真正执行insert语句。

3) hibernate如何从数据中载入对象？

当需要读取读取文件时，Hibernate先尝试从session缓存中读取，如果session缓存数据不存在或是脏数据并且配置了二级缓存，Hibernate尝试从二级缓存中检索数据；否则Hibernate会根据对象类型·主键等信息组织select语句到数据库中读取，再把select结果组织成对象返回。

4) hibernate如何进行数据库查询操作？

Hibernate提供SQL、HQL、Criteria查询方式。HQL是其中运用最广泛的查询方式。用户使用session.createQuery（）函数以一条HQL语句为参数创建Query查询对象后，Hibernate会使用Anltr库把HQL语句解析成jdbc可以识别的sql语句。如果设置了查询缓存，那么执行Query.list（）时，Hibernate会先对查询缓存进行查询，如果查询缓存不存在，再使用select语句查询数据库。

14、 hibernate的 inverse属性的作用?

在hibernate的集合属性配置（即一对多或多对多关联）的时候，在set节点上可以配置inverse属性，该属性的主要作用是设置关联属性的控制权，主要是用来指定one方是否拥有对关联属性的控制权，inverse=true表明one方对关联属性字段进行控制。举例来说，班级和学生两个实体是一对多关系，当在班级实体的映射文件中设置集合属性的inverse节点为true，则意味着对班级实体做操作时，不会对关系造成影响。

15、 cascade属性和inverse属性的作用和区别？

1) Cascade指的是关联对象之间的级联操作

2) Inverse指的是关联关系的控制方向

16、为什么要用 ORM? 和 JDBC 有何不一样?

orm是一种思想，就是把object转变成数据库中的记录，或者把数据库中的记录转变成objecdt，我们可以用jdbc来实现这种思想，其实，如果我们的项目是严格按照oop方式编写的话，我们的jdbc程序不管是有意还是无意，就已经在实现orm的工作了。

现在有许多orm工具，它们底层调用jdbc来实现了orm工作，我们直接使用这些工具，就省去了直接使用jdbc的繁琐细节，提高了开发效率，现在用的较多的orm工具是hibernate。也听说一些其他orm工具，如toplink,ojb等。

17、 hibernate中get()与load()区别

　请注意如果没有匹配的数据库记录，load()方法可能抛出无法恢复的异常(unrecoverableexception)。如果类的映射使用了代理(proxy)，load()方法会返回一个未初始化的代理，直到你调用该代理的某方法时才会去访问数据库。若你希望在某对象中创建一个指向另一个对象的关联，又不想在从数据库中装载该对象时同时装载相关联的那个对象，那么这种操作方式就用得上的了。如果为相应类映射关系设置了batch-size，那么使用这种操作方式允许多个对象被一批装载（因为返回的是代理，无需从数据库中抓取所有对象的数据）。如果你不确定是否有匹配的行存在，应该使用get()方法，它会立刻访问数据库，如果没有对应的行，会返回null。

18、 Hiberane中Query对象的list()方法和iterate()方法的区别：

list()方法不在缓存中读取数据，它总是一次性的从数据库中直接查询所有符合条件的数据，同时将获取的数据写入缓存。

iterate()方法则是获取了符合条件的数据的id后，首先根据id在缓存中寻找符合条件的数据，若缓存中无符合条件的数据，再到数据库中查询。

19、 Hibernate支持两种查询方式：

1) HQL(Hibernate Query Languge)查询：是一种面向对象的查询语言。（应用较为广泛）

2) Criteria查询又称为“对象查询“：用面向对象的方式将构造查询的过程做了封装。

20、为什么使用HQL查询？

HQL是一种面向对象的查询语言，支持属性查询、参数查询、关联查询、分页查询等特性，还支持统计函数。还有如下优点：

1) 使用HQL可以避免使用JDBC查询的一些弊端。

2) 不需要在编写繁复的SQL语句，我们将针对实体类及其属性进行查询。

3) 查询结果是直接存放到List中的对象，不需要再次封装。

4) HQL还独立于数据库，对不同的数据库根据Hibernate dialect属性的配置自动生成不同的SQL语句执行

21、使用HQL步骤

1) 得到session

2) 编写HQL语句

3) 创建Query对象

4) 执行查询，得到结果

22、 HQL优化

1) 避免or操作

2) 避免使用not

3) 避免like的特殊形式

4) 避免having子句

5) 避免使用distinct

23、 HQL联接查询有几种方式？

1) 内联接

2) 迫切内联接

3) 左外联接

4) 迫切左外联接

5) 右外联接

九、 Struts框架技术

1、什么是设计模式模式？

设计模式是一套被反复使用、成功的代码设计经验。

作用：是为某一类问题提出的解决方案。

优点：设计模式简化了代码、容易理解、可靠性高。

2、什么是框架？

框架是提供了可重用的公共结构的一个半成品。

作用：充当应用程序的骨架，开发者可以再这个骨架上加上自己的东西，完成符合自己需要的应用程序。使用框架可以帮助我们更快的编写出优秀的，结构统一的程序，结构统一，便于学习和维护，开发时不用过多的考虑公共问题，可以专心于业务逻辑上，保证核心业务逻辑的开发质量

3、 Java领域中的主流框架有哪些？

MVC框架：Struts1,、Struts2、SpringMVC

ORM框架：Hibernate、TopLink、ibatis、MyBatis

Ajax框架：DWR、JQuery

其它框架：Spring、Xfire、SSH（spring，hibernate，struts三个框架的集成）

Hibernate:

是一个优秀的持久化框架,负责简化将对象数据保存到数据库中,或从数据库中读取数据并封装到对象的工作.

Struts2:

以webwork优秀的设计思想为核心,吸收了Struts1框架的部分优点,提供了一个更加整洁的MVC设计模式实现的Web应用程序框架;它引入了几个新的框架特性:从逻辑中分离出横切关注点的拦截器,减少或者消除配置文件,贯穿整个框架的强大表达式语言,支持可变更和可重用的基于MVC模式的标签API.

Spring:

Spring的出现改变了Java世界,它的目标是使现有的JavaEE技术更容易使用和促进良好的编程习惯.它是一个轻量级的框架,渗透了JavaEE技术的方方面面,它主要作为依赖注入容器和AOP实现存在.还提供了声明式事务,对DAO层的支持等简化开发的功能.Spring还可以很方便的与Struts2.hibernate等框架集成.

4、如何实现自定义MVC框架？

MVC是一种流行的软件设计模式，代表一种多层的应用程序实现方式，MVC模式将应用程序实现分为三个不同的基本部分：模型层M、视图层V、控制器C

自定义MVC的主要实现核心就是：定义一个Servlet来控制模型层M和视图层V的相互调用

实现思路：
例子：如果我们做一个登录请求http://localhost:8080:projectName/login.action

1、 )先服务器发送这样的一个登录请求时 servlet主控制器就会对请求的url进行解析

得到客户端请求的Action：“login”

2、 servlet主控制器就根据解析得到的login反射实例化对应的LoginAction子控制器

3、 LoginAction在执行其execute方法后返回对应的导航信息result

4、 Servlet主控制器根据result中的信息转发或重定向到对应的视图（JSP）

实现流程：

1、编写对应的XML配置文件,文件名可以自定义，配置内容包括：

a) Action的名称ActionName和Action类的全限定名ActionClassName

b) Action对应的result信息，包括是转发还是重定向和对应的视图组件（jsp）路径

2、在Web.xml中配置主控制器（ActionServlet），对应的拦截路径为*.action，并把配置文件的位置用初始化参数配置给Servlet主控制器

3、初始化主控制器Servlet，解析MyMVC.xml配置文件,把配置文件中的信息保存到ActionMapping对象中

4、创建一个Action接口，在Action接口中定义一个execute()方法。让所有的Action实现这个接口

5、谈谈你对Struts 1.x的理解。

1. struts是一个按MVC模式设计的Web层框架，其提供的主控制器就是一个Servlet，这个Servlet名为ActionServlet，或是ActionServlet的子类。我们可以在web.xml文件中将符合某种特征的所有请求（例如所有的以.do结尾的请求）交给这个Servlet处理，这个Servlet再参照一个配置文件（通常为/WEB-INF/struts-config.xml）将各个请求分别分配给不同的action去处理。（扩展知识点：struts的配置文件可以有多个，可以按模块配置各自的配置文件，这样可以防止配置文件的过度膨胀）

2. ActionServlet把请求交给action去处理之前，会将请求参数封装成一个formbean对象（就是一个java类，这个类中的每个属性对应一个请求参数），封装成一个什么样的formbean对象呢？看配置文件。

3.要说明的是， ActionServlet把formbean对象传递给action的execute方法之前，可能会调用formbean的validate方法进行校验，只有校验通过后才将这个formbean对象传递给action的execute方法，否则，它将返回一个错误页面，这个错误页面由input属性指定，（看配置文件）。

4.action执行完后要返回显示的结果视图，这个结果视图是用一个ActionForward对象来表示的，actionforward对象通过struts-config.xml配置文件中的配置关联到某个jsp页面，因为程序中使用的是在struts-config.xml配置文件为jsp页面设置的逻辑名，这样可以实现action程序代码与返回的jsp页面名称的解耦。

你对struts可能还有自己的应用方面的经验，那也要一并说出来。

6、 Struts1.x的工作机制？

注意：此处是Struts1的工作机制不是Struts2.

1) 检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息。

2) 如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中。

3) 根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;

4) 如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功。

5) ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法。

6) Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件。

7) ActionForward对象指向JSP组件生成动态网页,返回给客户。

7、 Struts1.x优缺点

优点：
1. 实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现.

2．有丰富的tag(标签)可以用，Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率

3. 页面导航，使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。

4. 提供Exception处理机制 .

5. 数据库链接池管理

6. 支持I18N

缺点

1、转到展示层时，需要配置forward，如果有十个展示层的jsp，需要配置十次，而且还不包括有时候目录、文件变更，需要重新修改forward，注意，每次修改配置之后，要求重新部署整个项目，而tomcate这样的服务器，还必须重新启动服务器

2、 Struts 的Action必需是线程安全（thread－safe）方式，它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。

3、测试不方便. Struts的每个Action都同Web层耦合在一起，这样它的测试依赖于Web容器，单元测试也很难实现。不过有一个Junit的扩展工具Struts TestCase可以实现它的单元测试。

4、类型的转换. Struts的FormBean把所有的数据都作为String类型，它可以使用工具Commons-Beanutils进行类型转化。但它的转化都是在Class级别，而且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是非常困难的。

5、对Servlet的依赖性过强. Struts处理Action时必需要依赖ServletRequest 和ServletResponse，所有它摆脱不了Servlet容器。

6、前端表达式语言方面.Struts集成了JSTL，所以它主要使用JSTL的表达式语言来获取数据。可是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。

7、对Action执行的控制困难. Struts创建一个Action，如果想控制它的执行顺序将会非常困难。甚至你要重新去写Servlet来实现你的这个功能需求。

8、对Action 执行前和后的处理. Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操作。

9、对事件支持不够. 在struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能对应一个事件，struts这种事件方式称为application event，application event和component event相比是一种粗粒度的事件

8、说说struts1与struts2的区别。

1.两个框架都是MVC的WEB框架,

2.struts1是老牌框架，应用很广泛，有很好的群众基础，使用它开发风险很小，成本低,Struts2核心设计思想主要源自Webwork，实现更优雅，更容易扩展

3.Struts2修改和完善了struts1中的一些缺陷，struts1中一些悬而未决问题在struts2得到了解决。

4.struts1的前端控制器是一个Servlet，名称为ActionServlet，struts2的前端控制器是一个filter，在struts2.0中叫FilterDispatcher，在struts2.1中叫StrutsPrepareAndExecuteFilter。

5.struts1的action需要继承Action类，struts2的action可以不继承任何类；struts1对同一个路径的所有请求共享一个Action实例，struts2对同一个路径的每个请求分别使用一个独立Action实例对象，所有对于struts2的Action不用考虑线程安全问题。

6.在struts1中使用formbean封装请求参数，在struts2中直接使用action的属性来封装请求参数。

7.struts1中的多个业务方法放在一个Action中时（即继承DispatchAction时），要么都校验，要么都不校验；对于struts2，可以指定只对某个方法进行校验，当一个Action继承了ActionSupport且在这个类中只编写了validateXxx()方法，那么则只对Xxx()方法进行校验。

8.与Struts1不同，Struts2对用户的每一次请求都会创建一个Action，所以Struts2中的Action是线程安全的。

9.Struts2的Action比较容易进行单元测试，Struts1则需要一些特殊的支持才可以进行测试Struts 1有哪些核心组件？Struts 2结构体系的运行原理（重点）

9、 Struts 1有哪些核心组件？

1、控制器：ActionServlet类是Struts的核心控制器，是Struts的入口点；ActionServlet的主要功能：将一个来自客户端的请求映射到相应的Action，如果该Action配置了指定的ActionForm，那么就在request中抓去数据填充这个Actionform，然后调用Action的execute方法执行完成后，ActionServlet将接收包含有下一个资源信息的ActionFoward对象，并将请求转至下一个资源。

2、模型：可以使用javabean和EJB来充当模型对象

3、视图：视图组件包括JSP页面、ActionForm和Struts标签。

10、 Struts 2中如何解决中文乱码问题？

注意：只能解决post请求的乱码问题，针对get请求的乱码和jsp中的处理方式一致。

11、 Struts2配置文件中的package元素与Java中的包有什么异同之处？

答：相同点：都是基于方便管理的理念，Struts2配置文件中的package为了更好的管理Action配置项, 例如区分不同模块中定义的同名的Action配置，Java中的包用于更好的管理类，例如不同包中定义的同名的类

不同点：

1) package是用于管理Action，而Java中的包用于管理class类；

package可以被继承，其实就是减少XML中的冗余配置，而Java中的包没有继承的概念；

12、 Struts2开发Action有几种模式，Action的作用是什么？

有三种模式：

1）实现Action接口

2）继承ActionSupport类

3）普通的Java类（体现Struts2的设计理念：表示action是非侵入设计，我的Acton不需要框架的支持，与框架减耦，可以脱离框架而存在（Struts2的设计理念））

Action的作用：

1）封装工作单元

2）数据转移的场所

3）返回相应视图结果的字符串

13、 Struts 2结构体系的运行原理（重点）

1) 由容器创建HttpServlet请求，这个请求经过一系列的过滤器，最终到Struts2的核心过滤器（FilterDispatcher）；

8) 核心过滤器解析请求的URL获得一个ActionMapper实例，如果不存在，就抛出请求路径无效异常；

9) 核心过滤器根据ActionMapper生成一个ActionProxy（Action代理类）

10) ActionProxy从配置管理ConfigurationManager获取struts.xml的配置（struts.xml中配置了每个Action所需通过的拦截器）

11) ActionProxy根据struts.xm的配置生成一个ActionIncocation（action调度者）

12) ActionIncocation就会以递归的方式顺序调用配置中的Interceptor（拦截器），执行顺序（1、2、3）

13) ActionIncocation调用完所有的拦截器后就进入我们的Action

14) Action执行完后返回一个result

15) 使用result的信息生成对应的Template视图（jsp、FreeMarKey、Velocity等）

16) ActionIncocation再次反向调用所有配置的Interceptor（拦截器），执行顺序（3、2、1）

17) 执行完所有的interceptor后就会生成HttpServletResponse

18) HttpServletResponse再通过过滤器显示给客户端

14、 Struts 2核心接口和类

ActionMapper

ActionMapper提供了在请求和Action调用请求之间的映射。ActionMapper根据请求的URI来查找是否存在对应的Action调用请求，如果有则返回一个描述Action映射的ActionMapping对象；没有找到匹配的Action调用返回null。

ActionMapping

ActionMapping本质上是一个数据传输对象。它保存了调用Action的映射信息，其中必须保存Action的命名空间的信息和name属性信息

ActionProxy

ActionProxy在XWork和真正的Action之间充当代理，在执行Action的过程中，因为使用代理而非直接操纵对象，所以可以在Action执行前后执行额外的操作。

ActionProxy创建了ActionInvocation对象

ActionInvocation

ActionInvocation表示Action的执行状态，它保存拦截器（按配置顺序），Action的实例。ActionInvocation是由ActionProxy创建，通过调用invoke() 方法开始Action的执行，执行的顺序为按配置顺序执行拦截器，拦截器执行完毕后执行Action，Action执行结束返回结果字符串，匹配相应的Result后，再一次执行拦截器。

Inserceptor（拦截器）

拦截器是一种可以在请求处理前或者之后执行的Struts2组件。拦截器是Struts2的重要特性，Struts2框架的绝大多数功能都是通过拦截器来完成的

15、说说对Struts 2拦截器的理解？

Struts2拦截器是在访问某个Action或Action的某个方法，字段之前或之后实施拦截，并且Struts2拦截器是可插拔的，拦截器是ＡＯＰ的一种实现。Struts2拦截器栈就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，Struts2拦截器链中的拦截器就会按其之前定义的顺序被调用。

16、拦截器工作原理

拦截器的工作原理:

Struts2拦截器是一种AOP设计思想的体现,以链式执行,对真正要执行的方法(execute)进行拦截,首先按照Action配置的拦截器顺序依次执行相应的拦截器,调用完后再执行Action及result跳转,然后再次执行拦截器(与先前调用相反的顺序),在此链式的执行过程中,任何一个拦截器都可以直接返回,从而终止余下的拦截器或Action及reuslt的执行.

17、为什么要用拦截器？

对于任意一个优秀的MVC框架，都会提供一些通用的操作，如请求数据的封装、类型转换、数据验证、解析上传的文件、防止表单多次提交等。早期的MVC框架是将这些操作都写死在核心控制器中，而这些通用操作又不是所有请求都需要实现的，这导致框架的灵活性不足，可扩展性降低.

1) Struts 2将它的核心功能放到拦截器中实现而不是集中在核心控制器中实现，把大部分控制器需要完成的工作按功能分开定义，每个拦截器完成一个功能，而完成这些功能的拦截器可以自由选择、灵活组合，需要哪些拦截器，只需要在struts.xml中指定，从而增强了框架灵活性。

19) 拦截器的使用有利于系统的解耦；

20) 从结构上看，拦截器栈相当于多个拦截器组合，从功能上看，拦截器栈也是拦截器，同样可以和其他的拦截器（或拦截器栈）一起组成更大粒度的拦截器栈。

21) 通过组合不同的拦截器，我们能够以自己需要的方式组合Struts 2框架的各种功能，可以”无限”扩展Struts 2框架。

18、 Struts2内置的拦截器

Params拦截器

Params拦截器提供了框架必不可少的功能，将请求中的数据设置到Action中的属性上

staticParams拦截器

staticParams拦截器是将在配置文件中通过action元素的子元素param设置的参数设置到对应的Action的属性中

servletConfig拦截器

servletConfig拦截器提供了一种将源于Servlet API的各种对象注入到Action当中的简洁方法。Action必须实现对应的接口。servletConfig拦截器才能将对应的Servlet对象注入到Action中

fileUpdload拦截器

fileUpload拦截器将文件和元数据从多重请求（multipart/form-date）转换为常规的请求数据，以便能将他们设置在对应的Action属性上

validation拦截器

validation拦截器执行数据验证

workflow拦截器

workflow拦截器提供当数据验证错误时终止执行流程的功能

exception拦截器

exception拦截器捕获异常，并且能够根据类型将捕获的异常映射到用户自定义的错误页面。该拦截器应该位于所定义的所有拦截器的第一位。

19、 Struts2自定义拦截器？

1)实现接口com.opensymphony.xwork2.interceptor.Interceptor。该接口提供了三个方法，如下所示：

Ø init()：该拦截器被初始化之后，在该拦截器执行拦截之前，系统回调该方法，对于每个拦截器而言，此方法只执行一次。

Ø destroy()：该方法跟init()方法对应。在拦截器实例被销毁之前，系统将回调该方法

Ø intercept(Actioninvocationinvocation) throws Exception：该方法是用户需要实现的拦截动作。该方法会返回一个字符串作为逻辑视图

2)继承com.opensymphony.xwork2.interceptor.AbstractInterceptor类是更简单的一种实现拦截器的方式，Abstractinterceptor类提供了init()和destroy()方法的空实现，这样，我们只要实现intercept()方法，就可以创建自己的拦截器

20、拦截器和拦截器栈有什么异同？

从结构上看，拦截器栈相当于多个拦截器的组合

在功能上看，拦截器栈也是拦截器

21、 Struts 2 表单标签和普通HTML表单标签有什么不同之处？

1、语法不同

2、 Struts2的标签有主题，会自动生成一定的标签和样式

3、需要指定导入标签库

4、会保存表单的数据（Struts特有的OGNL表达式的原因）

22、 Struts 2中自定义类型转换器

创建自定义类型转换器

Struts 2提供了开发人员编写自定义类型转换器时可以使用的基类，org.apache.struts2.util.StrutsTypeConverter.这是个抽象类，定义了两个抽象方法，用于不同的转换方向，分别为：

public ObjectconvertFromString(Map context,String [] values,Class toType):将一个或多个字符串值转换为指定的类型。

public StringconvertToString(Map context,Object object):将指定对象转化为字符串。

23、为什么要进行类型转换？

1) 在基于HTTP协议的Web应用中，客户端请求的所有内容都以文本编码方式传输到服务器端，服务器端的编程语言却有着丰富的数据类型，当页面表单数据提交到服务器时，就需要将这些jsp中扁平状（文本类型）的数据类型转换成java中的各种类型的数据，从而需要类型转换。

2) 通常不使用框架开发时，类型转换工作由开发者自己完成

3) Struts 2提供了多种内置类型转换器，自动对客户端传来的数据进行类型转换，另外开发者可以开发自定义类型转换器

24、国际化、本地化的含义是什么？

国际化（Internationalization：I18N）

使程序在不做任何修改的情况下，可以在不同国家或地区和不同语言环境下，按照当地的语言和格式习惯显示字符

本地化（Localization：L10N）

一个国际化的程序，当它运行在本地机器时，能够根据本地机器的语言和地区设置显示相应字符

25、 Struts2国际化资源文件的范围

1、全局资源文件

所有包的所有Action类都可以访问

导致资源文件变得非常庞大臃肿，不便于维护

2、包范围资源文件

对应包下创建package_language_country.properties

处于该包及子包下的action才可以访问该文件

3、Action范围资源文件

命名格式ActionClassName_language_country.properties

只有单个Action可以访问

26、 Struts2的配置文件介绍

Struts 2 的核心配置文件就是struts.xml 配置文件，包含 action 、result 、等的配置。主要负责管理Struts 2 框架的业务控制器Action。

Struts.xml 文件通常放在WEB-INF/classes 目录下，在该目录下的Struts.xml 文件可以被Struts 2 框架自动加载。文件实例：

<?xmlversion="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTDStruts Configuration 2.1//EN""http://struts.apache.org/dtds/struts-2.1.dtd">

<constantname="" value="">

</action>

</package>

</struts>

Constant 元素

配置 Constant 元素，可以改变 Struts 2 框架的一些行为。Constant元素包含两种属性，name 属性表示常量的名称，value属性表示常量的值。

在处理中文乱码问题时，可以在Struts.xml 中设置常量的方式解决。

<constant name=”struts.i18n.encoding”value=”UTF-8”。

Package 元素

Struts2框架把action、result 等组织在一个名为package(包) 的逻辑单元中，从而简化维护工作，提高重用性，每一个包都包含了将要用到的action、result等的定义。

Struts 2 的包很像Java的包，但是Java包不同的是，Struts2中的包可以“继承” 已有定义好的包，从而继承原有包的所有定义（包括Action、result等的配置），并且可以加自己包的配置。

Package 元素包含多种属性，其中:

name 属性为必须的并且是唯一的，用来指定包的名称（被其它包引用）。

extends 属性类似Java 的extends 关键字，指定要扩展的包。

namespace 是一个可选属性，该属性定义该包中action的命名空间。默认的命名空间用” ” 表示，以”/” 表示根命名空间。

action 元素

开发完成一个Action 类后，就需要在Struts.xml 中配置action 了。

name属性为必须的并且是唯一的，用来指定Action的名称.

class 属性表示引用哪一个Action类

method 为使用同一个Action 处理不同的请求，我们可以在struts.xml 中，为同一个Action 配置不同的名称，并使用method 属性指定执行的方法。

result元素

Result 元素的作用是调度视图，并决定视图以哪种形式体现给客户端。Result 元素的name属性表示result的逻辑名，用于与Action返回的字符串进行匹配，result 元素的值用来指定这个结果对应实际资源的位置。

name 属性为必须的并且是唯一的，用来指定result的名称,常用的有 success、error、input 也可以自定义。默认为 success。

type 属性决定用什么方法处理请求，常用的结果类型有 dispatcher、redirect、redirectAction.

dispatcher 是最常用的，也是默认的结果类型。Struts 2 在后台使用Servlet API的RequestDispatcher来转发请求。

redirect 类型在后台使用HttpResponse 对象的sendRedirect() 方法将请求重定向至指定的URl.

redirectAction 类型与redirect 类型相似，都是使用HttpResponse 对象的sendRedirect() 方法将请求重定向至指定的URl.。但redirectAction 类型主要用于重定向到Action。

27、什么是OGNL

Object Graph Navigation Language对象图导航语言，开源项目，取代页面中Java脚本，简化数据访问，和EL同属于表达式语言，但功能更为强大

28、 OGNL和EL有什么异同？

相同点：OGNL和EL都是表达式语言，用来获取相应对象或其属性的值

差异点：

1、在获取集合中对象的方式不同：

EL表达式是jsp规范的标准，可以直接在jsp页面上使用

OGNL是Strut2框架用来解决视图输出内容而集成的技术，在页面上只能使用Struts2标签输出内容，不能直接使用

2、 是否可以调用方法：OGNL可以直接调用对象中的方法，EL表达式只能输出对象的属性（其实是调用对象提供的getter方法）

3、 取值的方式不同：EL表达式使用${XXXX}方式取值

ONGL取值的方式是:

如果是根元素：<s:property value="user.name"/>

如果非根元素: <s:property value="#request.user.naem" />

还有就是：<s:propertyvalue="%{#session.user.name}" />

29、 OGNL中访问根元素和非根元素有什么区别？

区别：访问根对象，直接书写对象的属性，访问其他非根对象必须使用“#”前缀

Struts2中集成的OGNL可以直接访问Action对象中的属性的原因是：Action做为了ValueStack的栈顶，ValueStack是OGNL的根元素，而ValueSatck的栈顶元素享有了其根元素的所有特性。

30、 OGNL在Struts 2中的作用

1、表达式语言

将表单或Struts 2标签与特定的Java数据绑定起来，用来将数据移入、移出框架

2、类型转换

数据进入和流出框架，页面中数据的字符串版本和Java数据类型之间都发生转换

十、 Spring框架

1、什么是依赖，什么是依赖注入？

依赖：两个元素中一个定义发生改变则会引起另一个元素发生改变，则称这两个元素之间存在依赖关系。

控制反转(IoC)：在传统的程序设计过程中，都是在应用内部创建及维护依赖的对象。控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的。这样控制权就由应用转移到外部容器，控制权的转移就是控制反转。

依赖注入：是指在运行期，由外部容器动态地将依赖对象注入到组件中。

依赖注入让Bean与Bean之间以配置文件组织在一起，而不是以硬编码的方式耦合在一起。

2、 Spring依赖检查机制

Spring的依赖检查能够帮助检查在一个Bean上的所有特定类型属性是否都已经设置依赖注入。只要在dependency-check的属性中指定依赖检查模式就可以了。

依赖检查的几种模式：

1）none：不执行任何依赖检查。任何属性都可以保持未设置状态，为默认；

2）simple：检查任意简单类型（原始（例如int、double等，还包括String类型）和集合类型）的属性是否设置，未设置将抛出UnsatisfiedDependencyexception异常；

3）objects：检查任意对象类型属性是否设置，未设置将抛出UnsatisfiedDependencyexception异常；

4）all：检查任意类型的属性是否设置，未设置将抛出UnsatisfiedDependencyexception异常。

3、 SpringMVC工作机制？

1) spring mvc请所有的请求都提交给DispatcherServlet，它会委托给应用系统的其他模块负责对请求进行真正的处理工作。

22) DispatcherServlet查询一个或多个HandleMapping，找到处理请求的Controller

23) DispatchServlet请求提交到目标Controller

24) Controller进行业务逻辑处理后，会返回一个ModelAndView

25) Dispatcher查询一个或多个ViewResolver视图解析器，找到ModelAndView对象指定的视图对象

26) 视图对象负责渲染返回给客户端。

4、 Spring是什么？

Spring 是一个开源的控制反转（Inversion of Control，IoC）和面向切面（AOP）的容器框架。它的主要目的是使现有技术更加易用，推荐编码最佳实现，从而简化企业开发。

Spring 目前已经发展为一个功能丰富而易用的集成框架，其核心是一个完整的控制反转（IoC）的轻量级容器，用户可以使用他建立自己的应用程序。在容器上，Spring提供了大量实用的服务。将很多高质量的开源项目集成到统一的框架上。

Spring致力于Java EE 应用的各种解决方案，而不是仅仅专注于某一层面的方案。可以说，Spring是企业应用开发的“一站式”选择，Spring贯穿表示层、业务层、持久层。然而，Spring并不想取代那些已有的框架，而以高度的开发性与他们无缝整合。

5、为什么要使用Spring框架?

AOP让开发人员可以进行创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用AOP后，公共服务（比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。

IOC允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词倒置所表现的，IOC就像反过来的JNDI。没有使用一堆抽象工厂、服务器定位、单元素(singleton)和直接构造(straightconstrution)，每一个对象都是用其协作对象构造的。因此是由管理容器的协作对象（collaborator）。

Spring既是AOP框架，也是一个IOC容器。Spring最好的地方就是它有助于您替换对象。有了Spring，只要用JavaBean属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。

6、 Spring主要包含哪些模块?

Spring是一个分层架构，由7个定义良好的模块组成。Spring模块构建在核心容器之上，核心容器定义了创建、配置和管理bean的方式，如图1所示。

组成Spring框架的每个模块（或组件）可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

☆ 核心容器：核心容器提供Spring框架的基本功能。核心容器的主要组件式BeanFactory，它是工厂模式的实现。BeanFactory使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际应用程序代码分开。

☆ Spring上下文：Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校检和调度功能。

☆ Spring AOP：通过配置管理特性，Spring AOP模块直接将面向方面的编程功能集成到了Spring框架中。所以，可以很容易地使Spring框架管理的任何对象支持AOP。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖EJB组件，就可以声明性事务管理集成到应用程序中。

☆ Spring DAO：JDBC DAO抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次机构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO的面向JDBC的异常遵从通用的DAO异常层次结构。

☆ Spring ORM：Spring 框架插入了若干个ORM框架，从而提供了ORM的对象关系工具，其中包括JDO、Hibernate和iBatis SQL Map。所欲这些都遵从Spring的通用事务和DAO异常层次结构。

☆ Spring Web模块：Web上下文模块建立在应用程序上下文模块之上，为基于Web的应用程序提供了上下文。所以，Spring框架支持与Jakarta Struts的集成。Web模块还简化了处理多部分请求参数绑定到域对象的工作。

☆ Spring MVC框架：MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的,MVC容纳了大量视图技术,其中包括JSP、Velocity、Titles、iText和POI。

Spring框架的功能可以用在任何任何J2EE服务器中，大多数功能也适用于不受管理的环境。Spring的核心要点是：支持不绑定到特定J2EE服务器的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同J2EE环境（Web或EJB）、独立应用程序、测试环境之间重用。

7、 Spring的自动装配机制？

SpringIoC容器可以自动装配（autowire）相互协作bean之间的关联关系。因此，如果可能的话，可以自动让Spring通过检查BeanFactory中的内容，来替我们指定bean的协作者（其他被依赖的bean）。autowire一共有五种类型。由于autowire可以针对单个bean进行设置，因此可以让有些bean使用autowire，有些bean不采用。autowire的方便之处在减少或者消除属性或构造器参数的设置。在xml配置文件中，可以在<bean/>元素中使用autowire属性指定。

autowire属性取值：

1) no : 不启用自动装配。Autowire默认的值

2) byName: 根据属性名自动装配。此选项将检查容器并根据名字查找与属性完全一致的bean，并将其与属性自动装配。例如，在bean定义中将autowire设置为byname，而该bean包含master属性（同时提供setMaster(..)方法），Spring就会查找名为master的bean定义，并用它来装配给master属性。

3) byType: 通过属性的类型查找JavaBean依赖的对象并为其注入。如果容器中存在一个与指定属性类型相同的bean，那么将与该属性自动装配。如果存在多个该类型的bean，那么将会抛出异常，并指出不能使用byType方式进行自动装配。若没有找到相匹配的bean，则什么事都不发生，属性也不会被设置。如果你不希望这样，那么可以通过设置dependency-check="objects"让Spring抛出异常。

4) constructor: 与byType的方式类似，与byType的区别在于它不是使用Seter方法注入，而是使用构造子注入。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。

5) autodetect: 通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。

注意：

1)如果直接使用property和constructor-arg注入依赖的话，那么将总是覆盖自动装配。而且目前也不支持简单类型的自动装配，这里所说的简单类型包括基本类型、String、Class以及简单类型的数组。

2)当按Bean名称自动装配类型存在错误装配JavaBean的可能。如果配置文件中定义了与需要自动装配的JavaBean的名称相同而类型不同的JavaBean，那么它会错误地注入不同类型的JavaBean。

3)自动装配类型也会出无法自动装配的情况。例如，在配置文件中再次添加一个JavaBean类的实现对象，byType自动装配类型会因为无法自动识别装配哪个JavaBean而抛出org.springframework.beans.factory.UnsatisfiedDependecyException异常。要解决这个问题，只能通过混合使用手动装配来拼写装配哪个JavaBean。

8、 Spring自动装配的优缺点

优点：

1)自动装配能显著减少配置的数量。不过，采用bean模板（见这里）也可以达到同样的目的。

2)自动装配可以使配置与java代码同步更新。例如，如果你需要给一个java类增加一个依赖，那么该依赖将被自动实现而不需要修改配置。因此强烈推荐在开发过程中采用自动装配，而在系统趋于稳定的时候改为显式装配的方式。

缺点：

1)尽管自动装配比显式装配更神奇，但是，正如上面所提到的，Spring会尽量避免在装配不明确的时候进行猜测，因为装配不明确可能出现难以预料的结果，而且Spring所管理的对象之间的关联关系也不再能清晰的进行文档化。

2)对于那些根据Spring配置文件生成文档的工具来说，自动装配将会使这些工具没法生成依赖信息。

9、 Spring如何实现IOC容器功能

Spring设计的核心是org.springframework.beans包，它的设计目标是与JavaBean组件一起使用。这个包通常不是由用户直接使用，而是由服务器将其作其他多数底层中介。下一个最高级抽象是BeanFactory接口，它是工厂设计模式的实现，允许通过名称创建和检索对象。BeanFactory也可以管理对象之间的关系。

BeanFactory支持两种对象模型

1）单态模型提供了具有特定名的对象的共享实例，可以在查询时对其进行检索。Singleton是默认的也是最常用的对象模型。对于无状态服务对象很理想。

2）原型模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，原型模型最适合。

bean工厂的概念是Spring作为IOC容器的基础。IOC将处理事情的责任从应用程序转移到框架。Spring框架使用JavaBean属性和配置数据来指定必须设置的依赖关系。

10、 Spring如何与Struts 2集成？

1、先给程序搭建Struts2框架

2、加入Struts2-Spring-plugin.jar 集成插件

3、加入Spring框架jar包

4、在web.xml下配置Spring监听器contextConfigLocation指定配置文件

5、创建Model 都使用依赖注入

6、在Struts2的配置中的Action配置成由Spring创建的Action类的Bean的id属性值

生成action对象的工厂交给spring来创建

Spring 集成Struts2的核心：通过Struts2提供的插件，把对Action的控制权交给Spring容器来管理。因此在Struts2的配置中直接应用Spring容器中配置的Action类对应的Bean元素

11、什么是声明式事务。

用在Spring配置文件中声明式的处理事务来代替硬代码式的处理事务。这样的好处是，事务管理不侵入开发的组件，具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策略的话，也只需要在定义文件（即配置文件）中重新配置即可;在不需要事务管理的时候，只要在设定文件上修改一下，即可移去事务管理服务，无需改变代码重新编译，这样维护起来极其方便。

12、 Spring如何使用声明式事务管理Hibernate的事务

1）配置Hibernate的事务管理器。

2）定义事务通知，需要指定一个事务管理器

3）使用AOP,定义哪些方法应用这些规则

13、 AOP核心概念

1、Aspect（切面）

切面，是对交叉业务逻辑的统称。

2、Joinpoint（连接点）

连接点，指切面可以织入到目标对象的位置（方法，属性等）。

3、Advice（通知）

通知，指切面的具体实现。

4、Pointcut（切入点）

切入点，指通知应用到哪些类的哪些方法或属性之上的规则。

5、Introduction（引入）

引入，指动态地给一个对象增加方法或属性的一种特殊的通知。

6、Weaving（织入）

织入，指将通知插入到目标对象。

7、Target（目标对象）

目标对象，指需要织入切面的对象。

8、Proxy（代理对象）

代理对象，指切面织入目标对象之后形成的对象。

14、什么是AOP(Aspect-oriented programming面向方面编程)

面向方面编程也叫面向切面编程，即AOP，是一种编程技术，它允许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化。AOP的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中。

AOP和IOC是补充性的技术，它们都是运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象的开发方式中，可能要将日志记录语句放在所有方法和Java类中才能实现日志功能。在AOP方式中，，可以反过来将日志服务模块化，并以声明的方式将它们应用到需要的日志组件上。当然，优势就是Java类不需要知道日志服务的存在，也不需要知道日志服务的存在，也不需要考虑相关的代码。所以，用Spring AOP编写的应用程序代码是松散耦合的。

AOP的功能完全集成到了Spring 事务管理、日志和其他各种特性的上下文中。

15、 Spring AOP原理

Spring采用JDK动态代理模式来实现AOP机制。

Spring AOP采用动态代理的过程：

(1) 将切面使用动态代理的方式动态织入到目标对象（被代理类），形成一个代理对象；

(2) 目标对象如果没有实现代理接口，那么Spring会采用CGLib来生成代理对象，该代理对象是目标对象的子类；

(3) 目标对象如果是final类，并且也没实现代理接口，就不能运用AOP。

16、 Spring中的通知类型？

(1) MethodBeforeAdvice-前置通知

类全名：org.springframework.aop.MethodBeforeAdvice

在方法调用之前，做处理。

不能够改变返回值

不能够改变目标方法的流程，也不能中断流程的处理过程（除非抛出异常）

(2) AfterReturningAdvice-后置通知

类全名：org.springframework.aop.AfterReturningAdvice

在方法调用之后，做处理。

不能够改变返回值

不能够改变目标方法的流程，也不能中断流程的处理过程（除非抛出异常）

(3) MethodInterceptor-环绕通知

类全名：org.aopalliance.intercept.MethodInterceptor

在方法调用之前以及之后，做处理。

可以改变返回值，也可以改变流程。

(4) ThrowsAdvice-异常通知

类全名：org.springframework.aop.ThrowsAdvice

在方法抛出异常后，做处理。当该通知处理完异常后，会简单地将异常再次抛出给目标调用方法。

(5) Introduction-引入通知

Introduction和前面的四个advice是有很大的区别的，introduction用于给target引入新的接口（例如锁，状态等功能），生成一个mix-in的接口。而普通的advice只是在原有接口基础上增加附加内容

17、 Spring对持久层的支持：

① JDBC，② O/R Mapping（Hibernate，TopLink等）

Spring对持久层支持采用的策略：

1、Spring对持久层“不发明重复的轮子”，即没有重新实现新的持久层方案，对现有持久层方案做封装，更利于使用。

2、采用DAO模式

3、提供了大量的模板类来简化编程（HibernateDaoSupport，JdbcTemplate等）

4、重新设计了一套完善的异常体系结构

① 类型丰富，细化异常类型

② 全都是运行时异常（RuntimeException）

18、 Spring的事务机制

Spring支持声明式事务。声明式事务管理采用非侵入式的设计，可以分离业务逻辑和事务管理逻辑，具有良好的适应性。

Spring使用事务服务代理和事务管理器（如HibernateTransactionManager）来支持事务服务。

相对于EJB规范，Spring对事务的边界多了一种嵌套事务（PROPAGATION_NESTED）。

PROPAGATION_NESTED含义：

如果客户端启动了事务T1，那么Bean启动一个嵌套在T1中的子事务T2；

如果客户端没有启动事务，那么Bean会启动一个新的事务，类似于REQUIRED_NEW

19、数据库并发操作存在的异常情况？

1. 更新丢失（Lost update）：两个事务都同时更新一行数据但是第二个事务却中途失败退出导致对数据两个修改都失效了，这是系统没有执行任何锁操作，因此并发事务并没有被隔离开来

2. 脏读取（Dirty Reads）：一个事务开始读取了某行数据但是另外一个事务已经更新了此数据但没有能够及时提交。这是相当危险很可能所有操作都被回滚

3. 不可重复读取（Non-repeatable Reads）：一个事务对同一行数据重复读取两次但是却得到了不同结果。例如在两次读取中途有另外一个事务对该行数据进行了修改并提交

4. 两次更新问题（Second lost updates problem）：无法重复读取特例，有两个并发事务同时读取同一行数据然后其中一个对它进行修改提交而另一个也进行了修改提交这就会造成第一次写操作失效

5. 幻读（Phantom Reads）：也称为幻像（幻影）。事务在操作过程中进行两次查询，第二次查询结果包含了第一次查询中未出现的数据（这里并不要求两次查询SQL语句相同）这是因为在两次查询过程中有另外一个事务插入数据造成的

20、事务隔离级别

一个事务必须与其它事务进行隔离的程度。较低的隔离级别可以增加并发，但代价是降低数据的正确性。相反，较高的隔离级别可以确保数据的正确性，但可能对并发产生负面影响。

为了避免出现更新丢失、脏读取、不可重复读取、两次更新问题、幻读等这几种数据库并发操作中的异常情况，在标准SQL规范中定义了4个事务隔离级别，不同隔离级别对事务处理不同。

1.未授权读取（Read Uncommitted）：也称未提交读。允许脏读取但不允许更新丢失，如果一个事务已经开始写数据则另外一个数据则不允许同时进行写操作但允许其他事务读此行数据。该隔离级别可以通过“排他写锁”实现。事务隔离的最低级别，仅可保证不读取物理损坏的数据。与READ COMMITTED 隔离级相反，它允许读取已经被其它用户修改但尚未提交确定的数据。

2. 授权读取（Read Committed）：也称提交读。允许不可重复读取但不允许脏读取。这可以通过“瞬间共享读锁”和“排他写锁”实现，读取数据的事务允许其他事务继续访问该行数据，但是未提交写事务将会禁止其他事务访问该行。SQL Server 默认的级别。在此隔离级下，SELECT 命令不会返回尚未提交（Committed）的数据，也不能返回脏数据。

3. 可重复读取（Repeatable Read）：禁止不可重复读取和脏读取。但是有时可能出现幻影数据，这可以通过“共享读锁”和“排他写锁”实现，读取数据事务将会禁止写事务（但允许读事务），写事务则禁止任何其他事务。在此隔离级下，用SELECT 命令读取的数据在整个命令执行过程中不会被更改。此选项会影响系统的效能，非必要情况最好不用此隔离级。

4. 串行（Serializable）：也称可串行读。提供严格的事务隔离，它要求事务序列化执行，事务只能一个接着一个地执行，但不能并发执行。如果仅仅通过 “行级锁”是无法实现事务序列化的，必须通过其他机制保证新插入的数据不会被刚执行查询操作事务访问到。事务隔离的最高级别，事务之间完全隔离。如果事务在可串行读隔离级别上运行，则可以保证任何并发重叠事务均是串行的。

参看下表记忆，隔离级别可以解决的问题：

隔离级别	更新丢失	脏读取	重复读取	幻读
未授权读取	N	Y	Y	Y
授权读取	N	N	Y	Y
可重复读取	N	N	N	Y
串行	N	N	N	N

21、数据库锁概念

在数据库中有两种基本的锁类型：排它锁（Exclusive Locks，即X锁）和共享锁（Share Locks，即S锁）。当数据对象被加上排它锁时，其他的事务不能对它读取和修改。加了共享锁的数据对象可以被其他事务读取，但不能修改。数据库利用这两种基本的锁类型来对数据库的事务进行并发控制。

从程序员的角度看,锁分为以下两种类型：

1.乐观锁（Optimistic Lock）

乐观锁假定在处理数据时，不需要在应用程序的代码中做任何事情就可以直接在记录上加锁、即完全依靠数据库来管理锁的工作。一般情况下，当执行事务处理时SQL Server会自动对事务处理范围内更新到的表做锁定。

2.悲观锁（Pessimistic Lock）

悲观锁对数据库系统的自动管理不感冒，需要程序员直接管理数据或对象上的加锁处理，并负责获取、共享和放弃正在使用的数据上的任何锁。

22、关于Spring与EJB

1、Spring与EJB3.0的对比

Spring与EJB3.0之间的关系是竞争关系。

① Spring是一个开源的框架，而EJB3.0是一个标准（标准意味着将得到广泛的支持以及良好的兼容性），并且，采用EJB3.0，项目的后期维护得到了保证。

② Spring是一个轻量级框架，EJB3.0是一个重量级框架（完整的容器，包含所有的服务）。

③ Spring的IoC，AOP集成了大量的开源框架，可扩展性良好。EJB3.0的可扩展性则完全依赖于新的容器。

④ Spring对事务支持不如EJB3.0成熟，Spring对集群的兼容也不够。

⑤ Spring与EJB3.0都是一个企业级开发框架，都支持声明式事务。

2、Spring的优势与劣势

Spring的优势：

① 简化了企业级开发（对企业级服务进行了进一步的封装）

② 采用Spring框架的程序意味着良好的分层结构设计，并保证是面向接口编程的

③ 用IoC，AOP容器，模块是可配置的，松耦合的，方便了后期维护

Spring的劣势：

① 配置复杂，不方便维护

② 容器大量使用反射等机制装配对象，影响性能，对于高并发的大型应用无能为力，针对分布式的企业应用支持不够。

23、在Tomcat 上配置 https 协议有哪些主要的步骤：

1、生成数字证书（使用Java_HOME/bin目录下keytool命令生成证书）

2、打开Tomcat目录下的server.xml文件并找到关于SSL的相关联

3、重启Tomcat，可以使用HTTPS访问Tomcat中部署的网站程序。

4、强制客户端采用HTTPS访问

24、实际开发过程中为什么拆分Spring配置文件？

1）、当项目规模大的时候，配置文件可读性、可维护性差，庞大的Spring配置文件难以阅读。

2）、团队开发时，多人修改同一配置文件容易发生冲突，降低开发效率。

25、采用何种策略拆分Spring配置文件？

1）、如每个开发人员负责一模块采用公用配置（包含数据源、事务等）+每个系统模块一个单独配置文件（包含dao、service及action）形式

2）、如采用分层负责或者DAO配置代码由代码生成工具生成时，我们采用公用配置（包含数据源、事务等）+DAO Bean配置 + 业务逻辑Bean配置 +Action Bean配置形式

十一、软件工程与设计模式

1、 UML方面

标准建模语言UML。用例图,静态图(包括类图、对象图和包图),行为图,交互图(顺序图,合作图),实现图。

2、 JavaEE常用的设计模式？

总共23种，分为三大类：创建型，结构型，行为型

我只记得其中常用的6、7种，分别是：

创建型（工厂、工厂方法、抽象工厂、单例）

结构型（包装、适配器，组合，代理）

行为（观察者，模版，策略）

然后再针对你熟悉的模式谈谈你的理解即可。

Java中的23种设计模式：

Factory（工厂模式）， Builder（建造模式）， Factory Method（工厂方法模式），

Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），

Adapter（适配器模式）， Bridge（桥梁模式）， Composite（合成模式），

Decorator（装饰模式）， Flyweight（享元模式）， Proxy（代理模式），

Command（命令模式）， Interpreter（解释器模式）， Visitor（访问者模式），

Iterator（迭代子模式）， Mediator（调停者模式）， Memento（备忘录模式），

Observer（观察者模式）， State（状态模式）， Strategy（策略模式），

Template Method（模板方法模式）， Chain OfResponsibleity（责任链模式）

3、常用的设计模式分类

创建型模式主要包含5种设计模式：工厂模式、抽象工厂模式、建造者模式、原型模式、单例模式

结构型模式主要包含7种设计模式：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式

行为型模式主要包含11种设计模式：责任链模式、命令模式、解释器模式、迭代器模式、介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板模式、访问者模式

4、单例模式的优点

主要优点：

1) 提供了对唯一实例的受控访问。

2) 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。

3) 允许可变数目的实例。

4) 有很多时候必须要创建一个对象，并且不能创建多个，用单例就为了防止创建多个对象。

5) 比方说一个学校只有一个校长，不能有两个，有两个也出问题了，像校长这个类就必须做成单例的。

6) 单例可以节省不必要的内存开销，屏蔽对象创建的复杂性，如果你知道spring并且知道bean默认是单例的。

5、什么是工厂模式？

工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

6、开发中都用到了那些设计模式?用在什么场合?

每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。

项目开发中使用到了以下设计模式：

1）MVC设计模式,用于WEB项目开发。

2）单例模式：用于加载配置文件

3）模板方法模式：Servlet中就是模板模式的经典示例

4）工厂模式：spring框架对Bean的管理就使用了工厂模式

5）代理模式：spring的Aop实现就使用了jdk的动态代理模式

6）装饰模式：Java中的流中就是装饰模式的经典示例。

十二、 JAVAEE部分

1、 JNDI是什么？

全称Java Naming and Directory Interface（java命名和目录接口）是一个应用程序设计的API, 为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口。简单来说可以理解为是一种将对象和名字绑定的技术。

2、说出数据连接池的工作机制是什么?

数据库连接是一种关键的有限的昂贵的资源，这一点企业级应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

具体工作机制如下：

数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。

数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：

1) 最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；

2) 最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。

3) 如果最小连接数与最大连接数相差太大，那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。

3、 B/S与C/S的联系与区别。

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

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

C/S 与 B/S 区别：

１．硬件环境不同:

　　C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务.

　　B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行

２．对安全要求不同

　　C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息.

　　B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。

３．对程序架构不同

　　C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑.

　　B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk 2000Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean 构件技术等,使 B/S更加成熟.

４．软件重用不同

　　C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好.

　　B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子

５．系统维护不同

　　C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统

　　B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实现升级.

６．处理问题不同

　　C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统

　　B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小.

７．用户接口不同

　　C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高

　　B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本.

８．信息流不同

　　C/S 程序一般是典型的中央集权的机械式处理, 交互性相对低

　　B/S 信息流向可变化, B-B B-C B-G等信息、流向的变化, 更像交易中心。

十三、 WebService部分

1、什么是Web服务（web service）

Web服务是一种可以用来解决跨网络应用集成问题的开发模式，是基于网络的、分布式的模块化组件，它执行特定的任务遵守具体的技术规范，这些规范使得Web Service能与其他兼容的组件进行互操作。设计WEB服务时应该把握的几个关键性原则：松散耦合、定义良好的接口、合适的粒度。web服务体系结构的三种角色是：服务提供者、服务代理机构、服务使用者

2、 Web服务的优点有哪些？

1) 封装性：

Web服务是一种部署在Web应用上的组件，具备良好的封装性。对使用者而言，仅看到服务描述，而该服务的具体实现、运行平台都是透明的，调用者无须关心，也无法关心。Web服务作为整体提供服务。

2) 松散耦合：

当Web服务的实现方式发生改变时，调用者是无法感受到这种改变的。对调用者而言，只要服务实现的接口不发生变化，具体实现的改变时完全透明的。

使用标准协议：

Web服务所有的公共协议都是用标准协议描述、传输和交换。这些标准协议在各种平台上完全相同。

3) 高度整合的能力：

由于Web服务采用简单、易理解的标准Web协议作为通信协议，完全屏蔽了不同平台的差异，无论是CORBA、DOM还是EJB，都可以通过这种标准协议进行互操作，实现系统的最高可整合性。

4) 高度的开放性：

Web服务可以与其他的Web服务进行交互，具有语言和平台型，支持CORBA，EJB，DCOM等多种组件标准，支持各种通讯协议，如HTTP、SMTP和RMI等。

3、 XFire框架如何创建和发布Web服务？

1) 添加XFire库。

2) 添加Xfire-1.2.6.jar包

3) 创建服务接口和实现类

4) 配置Web.xml与Services.xml文件

5) 发布Web服务

6) 创建客户端程序访问Web服务

4、 XFire框架如何调用Web服务？

1）创建服务接口模板

2）创建代理工厂

3）定义Web服务地址

4）根据接口模板和Web服务地址返回服务类

5）根据调用方法，并返回结果

5、 Web Service名词解释。JSWDL开发包的介绍。JAXP、JAXM的解释。SOAP、UDDI,WSDL解释。

Web Service是基于网络的、分布式的模块化组件，它执行特定的任务遵守具体的技术规范，这些规范使得Web Service能与其他兼容的组件进行互操作。

JAXP(Java API for XML Parsing) 定义了在Java中使用DOM, SAX, XSLT的通用的接口。这样在你的程序中你只要使用这些通用的接口，当你需要改变具体的实现时候也不需要修改代码。

JAXM(Java API for XML Messaging) 是为SOAP通信提供访问方法和传输机制的API。

WSDL是一种 XML 格式，用于将网络服务描述为一组端点，这些端点对包含面向文档信息或面向过程信息的消息进行操作。这种格式首先对操作和消息进行抽象描述，然后将其绑定到具体的网络协议和消息格式上以定义端点。相关的具体端点即组合成为抽象端点（服务）。

SOAP即简单对象访问协议(Simple ObjectAccess Protocol)，它是用于交换XML编码信息的轻量级协议。

UDDI 的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。

6、什么是SOA?

SOA(Service-OrientedArchitecture)即：面向服务架构，是一种软件体系架构，提供了一种架构设计平台，目的是让IT变得更有弹性。主要特点是：

1.业务驱动，SOA是面向业务的，要设计面向服务的架构；

2.松散耦合，服务是相互独立、自包含的，具有灵活性。

3.明确定义的接口，使用明确的标准服务描述语言定义接口；

4.遵循开放标准和协议的远程调用，远程调用是分布式服务调用的关键技术，遵循标准可以实现平台、程序的无关性；5.大数据量低频率访问，SOA模式下消息传递采用文本方式，响应速度和效率会有所损失，所以要采取大数量方式一次通信。