java开发工程师面试题

JDK和 JRE 有什么区别？

JDK：提供了 Java 的开发环境和运行环境。
JRE：Java运行环境，为 Java 的运行提供了所需环境。
JDK 其实包含了 JRE

==和 equals 的区别是什么？

总结 ：== 对于基本类型来说是值比较是否相同，对于引用类型来说是比较的是引用是否相同；
而 equals 默认情况下是引用比较，只是很多类重写了 equals 方法，把它变成了值比较是否相等

两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？

散列表中，hashCode() 相等即两个键值对的哈希值相等，然而哈希值相等，
并不一定能得出键值对相等。

final在 Java 中有什么作用？

final 修饰的类叫最终类，该类不能被继承。
final 修饰的方法不能被重写。
final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。

String属于基础的数据类型吗？

String 不属于基础类型，基础类型有 8 种：byte、char、short、int、long、
float、double，boolean、而 String 属于对象。

String、StringBuffer、StringBuilder区别？

String：字符串常量，创建之后不能更改，底层被final修饰的数组
StringBuffer、StringBuilder： 字符串缓冲区，提高字符串的操作效率，底层是数组，
没有被final修饰，可以改变字符串长度
StringBuffer 和 StringBuilder 最大的区别在于：
StringBuffer是线程安全的，而 StringBuilder 是非线程安全的

String str="i"与 String str=new String(“i”)一样吗？

不一样，因为内存的分配方式不一样。String str="i"的方式，Java 虚拟机会将其分配到常量池中；
而 String str=new String("i") 则会被分到堆内存中。

Java语言的跨平台特性

JVM解释器在运行Java应用时根据当前平台进行解释，解释成符合当前平台规范的机器码，
所以可以实现同样的应用在不同平台上都能运行。 

构造方法的作用和特征

构造方法的作用是用来创建对象，使用new关键字调用。构造方法的名字必须与类的名字相同，
同时构造方法不能声明返回值类型，可以使用任意一种访问修饰符，
但是不能使用其他修饰符进行修饰，如static、final、abstract等修饰符都可以修饰构造方法。 

重写（Override）和重载（Overload）？

重载：方法的名称【一样】，参数列表【不一样】
方法名字相同，而参数不同。返回类型可以相同也可以不同
重写：方法的名称【一样】，参数列表【也一样】。覆盖、覆写，外壳不变，核心重写

请说明Java语言中的值传递规则

基本数据类型传递的是值，引用类型传递的是引用，即虚地址。 

使用static修饰属性或方法后，属性和方法有什么特征？

共享资源，在类加载时就被初始化。直接使用类名调用，而不用先实例化对象再调用。 

break语句能在什么场景使用。 .for循环中的break语句和continue语句的使用。

break语句可以再循环体中使用，也可以在switch的case语句中使用。 
break可以用来中断循环，continue可以用来继续下一次循环。 

说明Arrays类的作用。

Arrays类是java.util包中的一个类，类中所有的方法都是static方法，
这些方法都是数组对象的工具方法，能够对数组进行处理，如sort方法可以对数组元素进行排序 

请说明什么是抽象类？抽象类有什么作用？

抽象类是不能实例化的类，使用abstract修饰。抽象类往往用来做父类使用，
定义一些子类的共同属性或行为。

Object类中的toString方法有什么用？

toString方法可以把对象作为字符串返回。 

接口有什么特点，与抽象类有什么区别？

接口的特点成员变量只能是 public static final 类型，而且所有方法都是抽象方法。
而抽象类成员变量可以是各种类型的，也不强制必须有抽象方法。 
一个类只能继承一个抽象类，而一个类却可以实现多个接口。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，
而抽象类是可以有静态代码块和静态方法。

什么是异常？异常和错误有什么区别？

异常是一些不正常的事件，能够中断程序的正常执行。
和错误不同，异常是可以被处理的，而错误往往是不能够处理的 

nullPointException是什么异常？什么情况发生该异常？

NullPointerExcepiton是空指针异常，当一个引用没被赋值，null

说明try/catch/finally语句块的作用

try语句块用来包含可能发生异常的语句，catch块用来捕获异常，finally用来包含必须执行的语句。 

Collection接口和Map接口分别定义了什么集合类型？有什么区别？

Collection接口是传统的集合接口，可以把单个对象存储进来。
而Map接口是映射接口，存储的是键值对。

List和Set集合有什么区别？

List中的元素是有序（ordered）的，允许有重复的元素，有索引，可以使用普通的for循环遍历。
而Set实现了不允许重复元素集合，没有索引。 

List接口有哪几个实现类？分别说明其特征

List接口中有以下几个常用实现
1 ArrayList：实现了动态数组的特征。
2 LinkedList： 实现了链表的数据结构，LinkedList也可以用作栈或者队列。
3 Vector：向量。
4 ArrayList Vector类的功能 ArrayList都可以实现，区别在于Vector是现行同步的。 

Collectioin 和Collections有什么区别？

Collection是一个接口的名字，定义了集合类型的共同特征。
而Collections是集合类型的工具类，类中定义了大量的静态方法

集合的作用？

集合是可以存储一批类型不同的对象

HashMap和TreeMap在性能上有什么样的差别呢？你比较倾向于使用哪一个?

一个平衡树的性能是O(logn)。Java里的TreeMap用一个红黑树来保证key/value的排序。
红黑树是平衡二叉树。保证二叉树的平衡性，使得插入，删除和查找都比较快，
时间复杂度都是O(log n)。不过它没有HashMap快，HashMap的时间复杂度是O(1)，
但是TreeMap的优点在于它里面键值是排过序的，这样就提供了一些其他的很有用的功能。

HashSet 和TreeSet 有什么区别？

HashSet 是由一个hash 表来实现的，因此，它的元素是无序的。add()，remove()，
contains()方法的时间复杂度是O(1)。
另一方面，TreeSet 是由一个树形的结构来实现的，它里面的元素是有序的。因此，
add()，remove()，contains()方法的时间复杂度是O(logn)。

什么是HaspMap和Map？

Map是接口，Java 集合框架中一部分，用于存储键值对，HashMap是用哈希算法实现Map的类

ArrayList和Vector的区别

同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，
不是同步的 .数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

ArrayList、Vector、LinkedList的区别？

ArrayList、Vector:以线性表的方式存储,查、改快，增删慢  Vector:是线程安全,方法是同步方法  。 
 ArrayList:是线程不安全，方法是非同步方法 。
LinkedList:单链表，查、改慢，增删快

关键字synchronized有什么作用？

进行线程同步，被同步的代码块在一个时刻只能被一个线程访问，只有当前线程处理结束后，
方能被其他线程访问

线程之间通信的方法有哪几个？分别起到什么作用？

线程通信的方法有三个①wait方法：使得线程进入等待状态。②notify 方法：
随意通知等待池中的某一个线程。③notifyAll 方法：通知等待池中所有线程。 

什么是泛型？泛型有什么作用？

使用未知的类型,在创建对象时，确定为具体的类型，实现参数的“任意化”。提高代码的重用率。

什么是自动装箱／拆箱？使用该特征有哪些注意事项？

自动装箱指的是可以直接将基本数据类型转换为包装器类型，
自动拆箱指的是可以直接将包装器类型转换为基本数据类型，
不要在没有必要的时候，频繁使用装箱拆箱，会降低性能

什么是可变参数？

可变参数是指参数个数不确定的参数

是否可以继承String类

String类是final类故不可以继承 

ArrayList 和 Vector 的区别,HashMap 和Hashtable的区别

就ArrayList与Vector主要从二方面来说.
一.同步性:Vector 是线程安全的，也就是说是同步的，而 ArrayList 是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一培，而 ArrayList却是原来的一半
就HashMap与 HashTable主要从三方面来说。
一.历史原因:Hashtable 是基于陈旧的Dictionary 类的，HashMap是Java 1.2引进的 Map接口的一个实现
二.同步性:Hashtable 是线程安全的，也就是说是同步的，而 HashMap 是线程序不安全的，
不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value 

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

ArrayList和Vector 都是使用数组方式存储数据，
此数组元素数大于实际存储的数据以便增加和插入元素，
它们都允许 直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，
所以索引数据快而插入数据慢，Vector 由于使用了 synchronized方法（线程安全），
通常性能上较 ArrayList差，而LinkedList使用双向链表实现存储，
按序号索引数据需要 进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，
所以插入速度较快。 

排序都有哪几种方法？

插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序） 

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

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

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

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

xml有哪些解析技术?区别是什么?

有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由 DOM的树结构所造成的，这种结构占用的内存较多，而且 DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取 XML 文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问 STAX:Streaming API for XML (StAX) 

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

用到了数据存贮，信息配置两方面。在做数据交换平台时，将不能数据源的数据组装成XML文件，然后将XML文件压缩 打包加密后通过网络传送给接收者，接收解密与解压缩后再同 XML 文件中还原相关信息进行处理。在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中。 

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

a: 两种形式 dtd schema，b: 本质区别:schema本身是xml的，可以被XML 解析器解析(这也是从DTD上发展 schema的根本目的)，c:有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由 DOM的树结构所造成的，这种
结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对 XML 的随机访问
SAX:不现于DOM,SAX 是事件驱动型的 XML 解析方式。它顺序读取XML 文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件， 适合对XML 的顺序访问STAX:Streaming API for XML (StAX) EJB 方面 

MVC的各个部分都有那些技术来实现?如何实现?

MVC 是 Model－View－Controller 的简写。”Model” 代表的是应用的业务逻辑（通过JavaBean，EJB 组件实现），”View” 是应用的表示面（由 JSP页面产生），”Controller” 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。 

J2EE 是什么？

Je22 是Sun公司提出的多层(multi-diered),分布式(distributed),基于组件(component-base)的企业级应用模型(enterpriese application model).在这样的一个应用系统中，可按照功能划分为不同的组件，这些组件又可在不同计算机上，并且处于相应的层次(tier)中。所属层次包括客户层(clietn tier)组件,web 层和组件,Business层和组件,企业信息系统(EIS)层。 

final,finally,finallize区别(简答)；

final：修饰符（关键字）；如果一个类被声明为 final，意味着它不能再 派生出新的子类，
不能作为父类被继承，因此一个类不能既被声明为 abstract 的，又被声明为 final 的；
将变量或方法声明为 final，可以保证它们在使用中 不被改变；
被声明为 final 的变量必须在声明时给定初值，而在以后的引用中只 能读取，不可修改；
被声明为 final 的方法也同样只能使用，不能重载。
 finally：再异常处理时提供 finally 块来执行任何清除操作；如果抛出一 个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如 果有的话）。 
 finalize：方法名；Java 技术允许使用 finalize() 方法在垃圾收集器将 对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定 这个对象没有被引用时对这个对象调用的。
 它是在 Object 类中定义的，因此所 有的类都继承了它。
 子类覆盖 finalize() 方法以整理系统资源或者执行其他清 理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

数组(Array)和列表(ArrayList)有什么区别？什么时候应该使用Array 而不是
ArrayList？

1.Array 可以包含基本类型和对象类型，ArrayList 只能包含对象类型。
2.Array 大小是固定的，ArrayList 的大小是动态变化的。
3.ArrayList 提供了更多的方法和特性，比如：addAll()，removeAll()，
iterator()等等。
4.对于基本类型数据，集合使用自动装箱来减少编码工作量。

Comparable 和Comparator 接口是干什么的？列出它们的区别。

compareTo()对象排序。
Comparable:自己(this)和别人(参数)比较(自然排序),自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:相当于找一个第三方的裁判,比较两个       

数据库连接池是什么意思？

在应用服务器启动的时候建立很多个
数据库连接并维护在一个池中。连接请求由池中的连接提供。在连接使用完毕以后，把连接
归还到池中，以用于满足将来更多的请求。

什么是Servlet？

Servlet 是用来处理客户端请求并产生动态网页内容的Java 类。Servlet 主要是用来处
理或者是存储HTML 表单提交的数据，产生动态内容，在无状态的HTTP 协议下管理状态信息。

说一下Servlet 的体系结构。

所有的Servlet 都必须要实现的核心的接口是javax.servlet.Servlet。每一个Servlet
都必须要直接或者是间接实现这个接口，或者是继承javax.servlet.GenericServlet 或者
javax.servlet.http.HTTPServlet。最后，Servlet 使用多线程可以并行的为多个请求服
务。

Applet 和Servlet 有什么区别？

Applet 是运行在客户端主机的浏览器上的客户端Java 程序。而Servlet 是运行在web
服务器上的服务端的组件。applet 可以使用用户界面类，而Servlet 没有用户界面，相反，
Servlet 是等待客户端的HTTP 请求，然后为请求产生响应。

GenericServlet 和HttpServlet 有什么区别？

GenericServlet 是一个通用的协议无关的Servlet，它实现了Servlet 和
ServletConfig 接口。继承自GenericServlet 的Servlet 应该要覆盖service()方法。最
后，为了开发一个能用在网页上服务于使用HTTP 协议请求的Servlet，你的Servlet 必须
要继承自HttpServlet。

解释下Servlet 的生命周期。

对每一个客户端的请求，Servlet 引擎载入Servlet，调用它的init()方法，完成Servlet
的初始化。然后，Servlet 对象通过为每一个请求单独调用service()方法来处理所有随后
来自客户端的请求，最后，调用Servlet(译者注：这里应该是Servlet 而不是server)的
destroy()方法把Servlet 删除掉。

doGet()方法和doPost()方法有什么区别？

doGet：GET 方法会把名值对追加在请求的URL 后面。因为URL 对字符数目有限制，进
而限制了用在客户端请求的参数值的数目。并且请求中的参数值是可见的，因此，敏感信息
不能用这种方式传递。
doPOST：POST 方法通过把请求参数值放在请求体中来克服GET 方法的限制，因此，可
以发送的参数的数目是没有限制的。最后，通过POST 请求传递的敏感信息对外部客户端是
不可见的。

什么是Servlet 链(Servlet Chaining)？

Servlet 链是把一个Servlet 的输出发送给另一个Servlet 的方法。第二个Servlet 的
输出可以发送给第三个Servlet，依次类推。链条上最后一个Servlet 负责把响应发送给客
户端。

如何知道是哪一个客户端的机器正在请求你的Servlet？

ServletRequest 类可以找出客户端机器的IP 地址或者是主机名。getRemoteAddr()方
法获取客户端主机的IP 地址，getRemoteHost()可以获取主机名。看下这里的例子。

HTTP 响应的结构是怎么样的？

HTTP 响应由三个部分组成：
状态码(Status Code)：描述了响应的状态。可以用来检查是否成功的完成了请求。请
求失败的情况下，状态码可用来找出失败的原因。如果Servlet 没有返回状态码，默认会返
回成功的状态码HttpServletResponse.SC_OK。
HTTP 头部(HTTP Header)：它们包含了更多关于响应的信息。比如：头部可以指定认为
响应过期的过期日期，或者是指定用来给用户安全的传输实体内容的编码格式。如何在
Serlet 中检索HTTP 的头部看这里。
主体(Body)：它包含了响应的内容。它可以包含HTML 代码，图片，等等。主体是由传
输在HTTP 消息中紧跟在头部后面的数据字节组成的。
102.什么是cookie？session 和cookie 有什么区别？
cookie 是Web 服务器发送给浏览器的一块信息。浏览器会在本地文件中给每一个Web
服务器存储cookie。以后浏览器在给特定的Web 服务器发请求的时候，同时会发送所有为
该服务器存储的cookie。下面列出了session 和cookie 的区别：
 无论客户端浏览器做怎么样的设置，session 都应该能正常工作。客户端可以
选择禁用cookie，但是，session 仍然是能够工作的，因为客户端无法禁用服务端的
session。
 在存储的数据量方面session 和cookies 也是不一样的。session 能够存储任
意的Java 对象，cookie 只能存储String 类型的对象。

浏览器和Servlet 通信使用的是什么协议？

浏览器和Servlet 通信使用的是HTTP 协议。

sendRedirect()和forward()方法有什么区别？

sendRedirect()方法会创建一个新的请求，而forward()方法只是把请求转发到一个新
的目标上。重定向(redirect)以后，之前请求作用域范围以内的对象就失效了，因为会产
生一个新的请求，而转发(forwarding)以后，之前请求作用域范围以内的对象还是能访问的。
一般认为sendRedirect()比forward()要慢。

什么是URL 编码和URL 解码？

URL 编码是负责把URL 里面的空格和其他的特殊字符替换成对应的十六进制表示，反之
就是解码。

JSP 请求是如何被处理的？

浏览器首先要请求一个以.jsp 扩展名结尾的页面，发起JSP 请求，然后，Web 服务器读
取这个请求，使用JSP 编译器把JSP 页面转化成一个Servlet 类。需要注意的是，只有当
第一次请求页面或者是JSP 文件发生改变的时候JSP 文件才会被编译，然后服务器调用
servlet 类，处理浏览器的请求。一旦请求执行结束，servlet 会把响应发送给客户端。

JSP 有什么优点？

 JSP 页面是被动态编译成Servlet 的，因此，开发者可以很容易的更新展现代
码。
 JSP 页面可以被预编译。
 JSP 页面可以很容易的和静态模板结合，包括：HTML 或者XML，也可以很容易
的和产生动态内容的代码结合起来。
 开发者可以提供让页面设计者以类XML 格式来访问的自定义的JSP 标签库。
 开发者可以在组件层做逻辑上的改变，而不需要编辑单独使用了应用层逻辑的
页面。

线程如何同步和通讯？

同学回答说synchronized 方法或代码块！面试官似乎不太满意！
只有多个synchronized 代码块使用的是同一个监视器对象，这些synchronized 代码块之间才
具有线程互斥的效果，假如a 代码块用obj1 作为监视器对象，假如b 代码块用obj2 作为监
视器对象，那么，两个并发的线程可以同时分别进入这两个代码块中。…这里还可以分析
一下同步的原理。
对于同步方法的分析，所用的同步监视器对象是this
接着对于静态同步方法的分析，所用的同步监视器对象是该类的Class 对象
接着对如何实现代码块与方法的同步进行分析。

分层设计的好处？

把各个功能按调用流程进行了模块化，模块化带来的好处就是可以随意组合，举例说明：如
果要注册一个用户，流程为显示界面并通过界面接收用户的输入，接着进行业务逻辑处理，
在处理业务逻辑又访问数据库，如果我们将这些步骤全部按流水帐的方式放在一个方法中编
写，这也是可以的，但这其中的坏处就是，当界面要修改时，由于代码全在一个方法内，可
能会碰坏业务逻辑和数据库访问的码，同样，当修改业务逻辑或数据库访问的代码时，也会
碰坏其他部分的代码。分层就是要把界面部分、业务逻辑部分、数据库访问部分的代码放在
各自独立的方法或类中编写，这样就不会出现牵一发而动全身的问题了。这样分层后，还可
以方便切换各层，譬如原来的界面是Swing，现在要改成BS 界面，如果最初是按分层设计
的，这时候不需要涉及业务和数据访问的代码，只需编写一条web 界面就可以了。
下面的仅供参考，不建议照搬照套，一定要改成自己的语言，发现内心的感受：
分层的好处：1.实现了软件之间的解耦；2.便于进行分工；3.便于维护；4.提高软件组件的重
用；5.便于替换某种产品，比如持久层用的是hibernate,需要更换产品用toplink，就不用其他
业务代码，直接把配置一改；6.便于产品功能的扩展；7.便于适用用户需求的不断变化

序列化接口的id 有什么用？

对象经常要通过IO 进行传送，让你写程序传递对象，你会怎么做？把对象的状态数据用某
种格式写入到硬盘，Person->“zxx,male,28,30000”Person，既然大家都要这么干，并且没
北京市昌平区建材城西路金燕龙办公楼一层电话：400-618-9090
有个统一的干法，于是，sun 公司就提出一种统一的解决方案，它会把对象变成某个格式进
行输入和输出，这种格式对程序员来说是透明（transparent）的，但是，我们的某个类要想
能被sun 的这种方案处理，必须实现Serializable 接口。
ObjectOutputStream.writeObject(obj);
Object obj = ObjectInputStream.readObject();
假设两年前我保存了某个类的一个对象，这两年来，我修改该类，删除了某个属性和增加了
另外一个属性，两年后，我又去读取那个保存的对象，或有什么结果？未知！sun 的jdk 就
会蒙了。为此，一个解决办法就是在类中增加版本后，每一次类的属性修改，都应该把版本
号升级一下，这样，在读取时，比较存储对象时的版本号与当前类的版本号，如果不一致，
则直接报版本号不同的错!

什么是AOP（注：会用，但感觉说不清楚）

AOP: 面向切面编程：Aspect Oriented Programming
AOP 是OOP 的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面编程。
主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务
逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一
添加功能的一种技术。AOP 实际是GoF 设计模式的延续，设计模式孜孜不倦追求的是调用
者和被调用者之间的解耦，AOP 可以说也是这种目标的一种实现。
在Spring 中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务
（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它
们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关
注点，例如日志或事务支持。

构造器Constructor 是否可被override?

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

谈谈你对面向对象的理解

面向对象是一种程序的设计方法，或者说它是一种程序设计范型，其基本思想是使用对象，
类，继承，封装，消息等基本概念来进行程序设计。
它是从现实世界中客观存在的事物（即对象）出发来构造软件系统，并在系统构造中尽可能
运用人类的自然思维方式，强调直接以问题域（现实世界）中的事物为中心来思考问题，认
识问题，并根据这些事物的本质特点，把它们抽象地表示为系统中的对象，作为系统的基本
构成单位（而不是用一些与现实世界中的事物相关比较远，并且没有对应关系的其它概念来
构造系统）。这可以使系统直接地映射问题域，保持问题域中事物及其相互关系的本来面貌。
它可以有不同层次的理解：
从世界观的角度可以认为：面向对象的基本哲学是认为世界是由各种各样具有自己的运动规
律和内部状态的对象所组成的；不同对象之间的相互作用和通讯构成了完整的现实世界。因
此，人们应当按照现实世界这个本来面貌来理解世界，直接通过对象及其相互关系来反映世
界。这样建立起来的系统才能符合现实世界的本来面目。
从方法学的角度可以认为：面向对象的方法是面向对象的世界观在开发方法中的直接运用。
它强调系统的结构应该直接与现实世界的结构相对应，应该围绕现实世界中的对象来构造系
统，而不是围绕功能来构造系统。
从程序设计的角度来看，面向对象的程序设计语言必须有描述对象及其相互之间关系的语言
成分。这些程序设计语言可以归纳为以下几类：系统中一切皆为对象；对象是属性及其操作
的封装体；对象可按其性质划分为类，对象成为类的实例；实例关系和继承关系是对象之间
的静态关系；消息传递是对象之间动态联系的唯一形式，也是计算的唯一形式；方法是消息
的序列。

面向对象的特征有哪些方面？

面向对象的编程语言有封装、继承、抽象、多态等4 个主要的特征。

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

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数
据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方
法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

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

启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程
必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。

简述synchronized 和java.util.concurrent.locks.Lock 的异同？

主要相同点：Lock 能完成synchronized 所实现的所有功能
主要不同点：Lock 有比synchronized 更精确的线程语义和更好的性能。synchronized 会自动
释放锁，而Lock 一定要求程序员手工释放，并且必须在finally 从句中释放。Lock 还有更强
大的功能，例如，它的tryLock 方法可以非阻塞方式去拿锁。

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

这样的题属于随意发挥题：这样的题比较考水平，两个方面的水平：一是要真正明白这些内
容，二是要有较强的总结和表述能力。如果你明白，但表述不清楚，在别人那里则等同于不
明白。
首先，List 与Set 具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接
口，叫Collection。Set 里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不
是仅仅是相同）的对象，即假设Set 集合中有了一个A 对象，现在我要向Set 集合再存入
一个B 对象，但B 对象与A 对象equals 相等，则B 对象存储不进去，所以，Set 集合的add
方法有一个boolean 的返回值，当集合中没有某个元素，此时add 方法可成功加入该元素时，
则返回true，当集合含有与某个元素equals 相等的元素时，此时add 方法无法加入该元素，
返回结果为false。Set 取元素时，没法说取第几个，只能以Iterator 接口取得所有的元素，
再逐一遍历各个元素。
List 表示有先后顺序的集合， 注意，不是那种按年龄、按大小、按价格之类的排序。当我
们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前对
象在集合中的存放位置。一个对象可以被反复存储进List 中，每调用一次add 方法，这个对
象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用
一个索引变量指向这个对象，当这个对象被add 多次时，即相当于集合中有多个索引指向了
这个对象，如图x 所示。List 除了可以以Iterator 接口取得所有的元素，再逐一遍历各个元
素之外，还可以调用get(index i)来明确说明取第几个。
Map 与List 和Set 不同，它是双列的集合，其中有put 方法，定义如下：put(obj key,obj value)，
每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals
比较相等。取则可以根据key 获得相应的value，即get(Object key)返回值为key 所对应的
value。另外，也可以获得所有的key 的结合，还可以获得所有的value 的结合，还可以获得
key 和value 组合成的Map.Entry 对象的集合。
List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存
key-value 值，value 可多值。
HashSet 按照hashcode 值的某种运算方式进行存储，而不是直接按hashCode 值的大小进行
存储。例如，"abc" ---> 78，"def" ---> 62，"xyz" ---> 65 在hashSet 中的存储顺序不是62,65,78，
LinkedHashSet 按插入的顺序存储，那被存储对象的hashcode 方法还有什么作用呢？我们想
想!hashset 集合比较两个对象是否相等，首先看hashcode 方法是否相等，然后看equals 方法
是否相等。new 两个Student 插入到HashSet 中，看HashSet 的size，实现hashcode 和equals
方法后再看size。
同一个对象可以在Vector 中加入多次。往集合里面加元素，相当于集合里用一根绳子连接
到了目标对象。往HashSet 中却加不了多次的。

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

Set 里的元素是不能重复的，元素重复与否是使用equals()方法进行判断的。
equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分
离的对象的内容和类型相配的话，返回真值。

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

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

heap 和stack 有什么区别。

java 的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，会
为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结
束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。
堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用new
创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使用final
修饰后，放在堆中，而不是栈中。

说说你用过那些ajax 技术和框架，说说它们的区别

去掉对web.xml 的监视，把jsp 提前编辑成Servlet。有富余物理内存的情况，加大tomcat 使用的jvm 的内存

Tomcat 的优化经验

答:去掉对web.xml 的监视，把jsp 提前编辑成Servlet。
有富余物理内存的情况，加大tomcat 使用的jvm 的内存

HTTP 请求的GET 与POST 方式的区别

答：Form 中的get 和post 方法，在数据传输过程中分别对应了HTTP 协议中的GET 和POST
方法。二者主要区别如下：
1）Get 是用来从服务器上获得数据，而Post 是用来向服务器上传递数据；
2）Get 将表单中数据按照variable=value 的形式，添加到action 所指向的URL 后面，
并且两者使用“?”连接，而各个变量之间使用“&”连接；Post 是将表单中的数据放在form
的数据体中，按照变量和值相对应的方式，传递到action 所指向URL；
3）Get 是不安全的，因为在传输过程，数据被放在请求的URL 中；Post 的所有操作对
用户来说都是不可见的；
4）Get 传输的数据量小，这主要是因为受URL 长度限制；而Post 可以传输大量的数据，
所以在上传文件只能使用Post；
5）Get 限制Form 表单的数据集必须为ASCII 字符，而Post 支持整个ISO10646 字符集；
6）Get 是Form 的默认方法。

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

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

cookie 和session 的区别？

注意cookie 有时候禁不掉
Cookie session
存储在客户端存储在服务器端
两种类型
有声明周期
无声明周期
两种实现方式
依赖于cookie
url 重写
父路径不能访问子路径的cookie 同一个session 的窗口共享一个session
典型应用：
3 个月不用再登陆
购物车（http://www.china-pub.com/）
典型应用：
用户登陆
购物车也可以用session 实现。·
不可靠可靠

forward 和redirect 的区别

forward 是服务器请求资源，服务器直接访问目标地址的URL，把那个URL 的响应内容读
取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，
所以它的地址栏中还是原来的地址。
redirect 就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏
览器会用刚才请求的所有参数重新请求，所以session,request 参数都可以获取。

过滤器有哪些作用？

答：可以验证客户是否来自可信的网络，可以对客户提交的数据进行重新编码，可以从系统
里获得配置的信息，可以过滤掉客户的某些不应该出现的词汇，可以验证用户是否登录，可
以验证客户的浏览器是否支持当前的应用，可以记录系统的日志等等。

详细描述MVC。

答：基于Java 的Web 应用系统采用MVC 架构模式，即model（模型）、view（视图）、control
（控制）分离设计；这是目前WEB 应用服务系统的主流设计方向。
Model：即处理业务逻辑的模块，每一种处理一个模块；
View：负责页面显示，显示MODEL 处理结果给用户，主要实现数据到页面转换过程；
Control：负责每个请求的分发，把FORM 数据传递给MODEL 处理，把处理结果的数
据传递给VIEW 显示。

javascript 的优缺点和内置对象。

答：1）优点：简单易用，与Java 有类似的语法，可以使用任何文本编辑工具编写，只需要
浏览器就可执行程序，并且事先不用编译，逐行执行，无需进行严格的变量声明，而且内置
大量现成对象，编写少量程序可以完成目标；
2）缺点：不适合开发大型应用程序；
3）Javascript 有11 种内置对象： Array、String、Date、Math、Boolean、Number、
Function、Global、Error、RegExp、Object。

事务是什么？

事务是作为一个逻辑单元执行的一系列操作，一个逻辑工作单元必须有四个属性，称为
ACID（原子性、一致性、隔离性和持久性）属性，只有这样才能成为一个事务：
原子性：事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。
一致性：事务在完成时，必须使所有的数据都保持一致状态。在相关数据库中，所有规则都
必须应用于事务的修改，以保持所有数据的完整性。事务结束时，所有的内部数据结构（如
B 树索引或双向链表）都必须是正确的。
隔离性：由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。事务查看数据时
数据所处的状态，要么是另一并发事务修改它之前的状态，要么是另一事务修改它之后的状
态，事务不会查看中间状态的数据。这称为可串行性，因为它能够重新装载起始数据，并且
重播一系列事务，以使数据结束时的状态与原始事务执行的状态相同。
持久性：事务完成之后，它对于系统的影响是永久性的。该修改即使出现系统故障也将一直
保持。

存储过程，触发器，范式，事务的概念及作用？

存储过程：是数据库管理系统里的一个很重要的对象。用它可以封装一些功能。把多个SQL
语句封装到存储过程里面。起到封装功能的作用。类似面向对象里，封装对象的一个功能一
样。几乎任何可写成批处理的Transact-SQL 代码都可用于创建存储过程。
触发器：触发器是在用户进行某项操作的时候，会触发触发器的执行。它类似于JAVA 中图
形截面编程里的事件操作一样，是触发执行。和存储过程的主要区别在于：存储过程类似
JAVA 里面的对象一样，进行功能的封装（方法）。在调用的时候才会执行。而触发器只能
在别的操作执行的时候才会触发触发器的执行。
事务：类似于JAVA 里面线程的同步一样，作为一个单元执行。它有四大特性：原子性，隔
离性，一致性，持久性。在SQL SERVER 2000 里面还支持存储点的用法。大家都知道，事
务是做为一个单元运行，要么全部执行，要么全部不执行。但是有时候我们可以保证事务的
一部分可能正确执行，并且这些执行可以直接刷新到数据库里面。那么我们就可以在这个事
务的中间部分设置一个或者多个存储点。这样在这个事务大单元里就分成了几个小部分。如
果上面的部分执行正确，下面的部分执行错误，那么就没必要回滚整个事务，只需要回滚到
存储点的地方就可以了
范式：目地：规范化目的是使结构更合理，消除存储异常，使数据冗余尽量小，便于插入、
删除和更新
原则：遵从概念单一化"一事一地"原则，即一个关系模式描述一个实体或实体间的一种联
系。规范的实质就是概念的单一化。
方法：将关系模式投影分解成两个或两个以上的关系模式。
要求：分解后的关系模式集合应当与原关系模式"等价"，即经过自然联接可以恢复原关系而
不丢失信息，并保持属性间合理联系。

数据库三范式是什么?

第一范式（1NF）：字段具有原子性,不可再分。所有关系型数据库系统都满足第一范式）
数据库表中的字段都是单一属性的，不可再分。例如，姓名字段，其中的姓和名必须作为一
个整体，无法区分哪部分是姓，哪部分是名，如果要区分出姓和名，必须设计成两个独立的
字段。
第二范式（2NF）：第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足
第二范式（2NF）必须先满足第一范式（1NF）。要求数据库表中的每个实例或行必须可以
被惟一地区分。通常需要为表加上一个列，以存储各个实例的惟一标识。这个惟一属性列被
称为主关键字或主键。第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依
赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一
部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通
常需要为表加上一个列，以存储各个实例的惟一标识。简而言之，第二范式就是非主属性非
部分依赖于主关键字。
第三范式的要求如下： 满足第三范式（3NF）必须先满足第二范式（2NF）。简而言之，第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息。所以
第三范式具有如下特征：
1，每一列只有一个值。2，每一行都能区分。3，每一个表都不包含其他表已经包含
的非主关键字信息。
例如，帖子表中只能出现发帖人的id，而不能出现发帖人的id，还同时出现发帖人姓名，
否则，只要出现同一发帖人id 的所有记录，它们中的姓名部分都必须严格保持一致，这就
是数据冗余。

说出一些数据库优化方面的经验?

用PreparedStatement 一般来说比Statement 性能高：一个sql 发给服务器执行，步骤：语法
检查、语义分析， 编译，缓存
“inert into user values(1,1,1)”-二进制
“inert into user values(2,2,2)”-二进制
“inert into user values(?,?,?)”-二进制
有外键约束会影响插入和删除性能，如果程序能够保证数据的完整性，那在设计数据库时就
去掉外键。（比喻：就好比免检产品，就是为了提高效率，充分相信产品的制造商）
（对于hibernate 来说，就应该有一个变化：empleyee->Deptment 对象，现在设计时就成了
employeedeptid）
看mysql 帮助文档子查询章节的最后部分，例如，根据扫描的原理，下面的子查询语句要比
第二条关联查询的效率高：
1. select e.name,e.salary where e.managerid=(select id from employee where name='zxx');
2. select e.name,e.salary,m.name,m.salary from employees e,employees m where
e.managerid = m.id and m.name='zxx';
表中允许适当冗余，譬如，主题帖的回复数量和最后回复时间等
将姓名和密码单独从用户表中独立出来。这可以是非常好的一对一的案例哟！
sql 语句全部大写，特别是列名和表名都大写。特别是sql 命令的缓存功能，更加需要统一
大小写，sql 语句发给oracle 服务器语法检查和编译成为内部指令缓存和执行指令。
根据缓存的特点，不要拼凑条件，而是用?和PreparedStatment
还有索引对查询性能的改进也是值得关注的。
备注：下面是关于性能的讨论举例
4 航班3 个城市
m*n
select * from flight,city where flight.startcityid=city.cityid and city.name='beijing';
m + n
select * from flight where startcityid = (select cityid from city where cityname='beijing');
select flight.id,'beijing',flight.flightTime from flight where startcityid = (select cityid from city
where cityname='beijing')

union 和union all 有什么不同?

行排序运算，删除重复的记录再返回结果。实际大部分应用中是不会产生重复的记录，最常
见的是过程表与历史表UNION。如：
select * from gc_dfys
union
select * from ls_jg_dfys
这个SQL 在运行时先取出两个表的结果，再用排序空间进行排序删除重复的记录，最后
返回结果集，如果表数据量大的话可能会导致用磁盘进行排序。
而UNION ALL 只是简单的将两个结果合并后就返回。这样，如果返回的两个结果集中有
重复的数据，那么返回的结果集就会包含重复的数据了。从效率上说，UNION ALL 要比UNION 快很多，所以，如果可以确认合并的两个结果集
中不包含重复的数据的话，那么就使用UNION ALL，

谈谈你对Struts 的理解。

1. struts 是一个按MVC 模式设计的Web 层框架，其实它就是一个大大的servlet，这个Servlet
名为ActionServlet，或是ActionServlet 的子类。我们可以在web.xml 文件中将符合某种特征
的所有请求交给这个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 属性指定，（看配
置文件）作者为什么将这里命名为input 属性，而不是error 属性，我们后面结合实际的运行
效果进行分析。
4.action 执行完后要返回显示的结果视图，这个结果视图是用一个ActionForward 对象来表示
的，actionforward 对象通过struts-config.xml 配置文件中的配置关联到某个jsp 页面，因为程
序中使用的是在struts-config.xml 配置文件为jsp 页面设置的逻辑名，这样可以实现action
程序代码与返回的jsp 页面名称的解耦。
你对struts 可能还有自己的应用方面的经验，那也要一并说出来。

谈谈你对Hibernate 的理解。

1. 面向对象设计的软件内部运行过程可以理解成就是在不断创建各种新对象、建立对象之
间的关系，调用对象的方法来改变各个对象的状态和对象消亡的过程，不管程序运行的过程
和操作怎么样，本质上都是要得到一个结果，程序上一个时刻和下一个时刻的运行结果的差
异就表现在内存中的对象状态发生了变化。
2.为了在关机和内存空间不够的状况下，保持程序的运行状态，需要将内存中的对象状态保
存到持久化设备和从持久化设备中恢复出对象的状态，通常都是保存到关系数据库来保存大
量对象信息。从Java 程序的运行功能上来讲，保存对象状态的功能相比系统运行的其他功
能来说，应该是一个很不起眼的附属功能，java 采用jdbc 来实现这个功能，这个不起眼的
功能却要编写大量的代码，而做的事情仅仅是保存对象和恢复对象，并且那些大量的jdbc
代码并没有什么技术含量，基本上是采用一套例行公事的标准代码模板来编写，是一种苦活
和重复性的工作。
3.通过数据库保存java 程序运行时产生的对象和恢复对象，其实就是实现了java 对象与关
系数据库记录的映射关系，称为ORM（即Object Relation Mapping），人们可以通过封装
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 查询。

AOP 的作用。

面向切面编程（AOP）提供另外一种角度来思考程序结构，通过这种方式弥补了面向对象编
程（OOP）的不足
除了类（classes）以外，AOP 提供了切面。切面对关注点进行模块化，例如横切多个类型和
对象的事务管理
Spring 的一个关键的组件就是AOP 框架，可以自由选择是否使用AOP 提供声明式企业服务，
特别是为了替代EJB 声明式服务。最重要的服务是声明性事务管理，这个服务建立在Spring
的抽象事物管理之上
允许用户实现自定义切面，用AOP 来完善OOP 的使用.可以把Spring AOP 看作是对Spring
的一种增强

你对Spring 的理解。

1.Spring 实现了工厂模式的工厂类（在这里有必要解释清楚什么是工厂模式），这个类名为
BeanFactory（实际上是一个接口），在程序中通常BeanFactory 的子类ApplicationContext。
Spring 相当于一个大的工厂类，在其配置文件中通过<bean>元素配置用于创建实例对象的类
名和实例对象的属性。
2. Spring 提供了对IOC 良好支持，IOC 是一种编程思想，是一种架构艺术，利用这种思想
可以很好地实现模块之间的解耦。IOC 也称为DI（Depency Injection），什么叫依赖注入呢？
譬如，Class Programmer{
Computer computer = null;
public void code(){
//Computer computer = new IBMComputer();
//Computer computer = beanfacotry.getComputer();
computer.write();
}
public void setComputer(Computer computer){
this.computer = computer;
}
}
另外两种方式都由依赖，第一个直接依赖于目标类，第二个把依赖转移到工厂上，第三个彻
底与目标和工厂解耦了。在spring 的配置文件中配置片段如下：
<bean id=”computer” class=”cn.itcast.interview.Computer”>
</bean>
<bean id=”programmer” class=”cn.itcast.interview.Programmer”>
<property name=”computer” ref=”computer”></property>
</bean>
3. Spring 提供了对AOP 技术的良好封装， AOP 称为面向切面编程，就是系统中有很多各
不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，例如，加入日志，加入
权限判断，加入异常处理，这种应用称为AOP。实现AOP 功能采用的是代理技术，客户端
程序不再调用目标，而调用代理类，代理类与目标类对外具有相同的方法声明，有两种方式
可以实现相同的方法声明，一是实现相同的接口，二是作为目标的子类在，JDK 中采用Proxy
类产生动态代理的方式为某个接口生成实现类，如果要为某个类生成子类，则可以用CGLI
B。在生成的代理类的方法中加入系统功能和调用目标类的相应方法，系统功能的代理以
Advice 对象进行提供，显然要创建出代理对象，至少需要目标类和Advice 类。spring 提供
了这种支持，只需要在spring 配置文件中配置这两个元素即可实现代理和aop 功能，例如，
<bean id=”proxy” type=”org.spring.framework.aop.ProxyBeanFactory”>
<property name=”target” ref=””></property>
<property name=”advisor” ref=””></property>
</bean>

Struts 优缺点

优点:1. 实现MVC 模式，结构清晰,使开发者只关注业务逻辑的实现.
2．有丰富的tag 可以用,Struts 的标记库(Taglib)，如能灵活动用，能大大提高开发效率
3. 页面导航使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的
联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优
势体现得更加明显。
4. 提供Exception 处理机制.
5. 数据库链接池管理
6. 支持I18N
缺点:
转到展示层时，需要配置forward，如果有十个展示层的jsp，需要配置十次struts，而且还
不包括有时候目录、文件变更，需要重新修改forward，注意，每次修改配置之后，要求重
新部署整个项目，而tomcate 这样的服务器，还必须重新启动服务器
二、Struts 的Action 必需是thread－safe 方式，它仅仅允许一个实例去处理所有的请求。
所以action 用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。
测试不方便. Struts 的每个Action 都同Web 层耦合在一起，这样它的测试依赖于Web 容器，单元测试也很难实现。不过有一个Junit 的扩展工具Struts TestCase 可以实现它的单元测试。
类型的转换. Struts 的FormBean 把所有的数据都作为String 类型， 它可以使用工具
Commons-Beanutils 进行类型转化。但它的转化都是在Class 级别，而且转化的类型是不可
配置的。类型转化时的错误信息返回给用户也是非常困难的。
对Servlet 的依赖性过强. Struts 处理Action 时必需要依赖ServletRequest 和ServletResponse，
所有它摆脱不了Servlet 容器。
前端表达式语言方面.Struts 集成了JSTL，所以它主要使用JSTL 的表达式语言来获取数据。
可是JSTL 的表达式语言在Collection 和索引属性方面处理显得很弱。
对Action 执行的控制困难. Struts 创建一个Action，如果想控制它的执行顺序将会非常困难。
甚至你要重新去写Servlet 来实现你的这个功能需求。
对Action 执行前和后的处理. Struts 处理Action 的时候是基于class 的hierarchies，很难在
action 处理前和后进行操作。
对事件支持不够. 在struts 中，实际是一个表单Form 对应一个Action 类(或DispatchAction)，
换一句话说：在Struts 中实际是一个表单只能对应一个事件，struts 这种事件方式称为
application event，application event 和component event 相比是一种粗粒度的事件.

说说struts1 与struts2 的区别。

1.都是MVC 的WEB 框架,
2.struts1 的老牌框架，应用很广泛，有很好的群众基础，使用它开发风险很小，成本更低！
struts2 虽然基于这个框架，但是应用群众并多，相对不成熟，未知的风险和变化很多，开发
人员相对不好招，使用它开发项目的风险系数更大，用人成本更高！
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()方法进行校验。
（一个请求来了的执行流程进行分析，struts2 是自动支持分模块开发，并可以不同模块设置
不同的url 前缀，这是通过package 的namespace 来实现的；struts2 是支持多种类型的视图；
struts2 的视图地址可以是动态的，即视图的名称是支持变量方式的，举例，论坛发帖失败后
回来还要传递boardid。视图内容显示方面：它的标签用ognl，要el 强大很多，在国际化方面支持分模块管理，两个模块用到同样的key，对应不同的消息；）
与Struts1 不同，Struts2 对用户的每一次请求都会创建一个Action，所以Struts2 中的Action
是线程安全的。
我印象最深刻的是：struts 配置文件中的redirect 视图的url 不能接受参数，而struts2 配置文
件中的redirect 视图可以接受参数。

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 语句。

什么是ORM？

答：对象关系映射（Object—Relational Mapping，简称ORM）是一种为了解决面向对象与
面向关系数据库存在的互不匹配的现象的技术；简单的说，ORM 是通过使用描述对象和数
据库之间映射的元数据，将java 程序中的对象自动持久化到关系数据库中；本质上就是将
数据从一种形式转换到另外一种形式

hibernate 的inverse 属性的作用?

解决方案一，按照Object[]数据取出数据，然后自己组bean
解决方案二，对每个表的bean 写构造函数，比如表一要查出field1,field2 两个字段，那么有
一个构造函数就是Bean(type1 filed1,type2
field2) ，然后在hql 里面就可以直接生成这个bean 了。