标签：数据文件 链表实现 ORC 定义 element 超链接 next 数据库 分布式系统
1. J2EE 是什么？它包括哪些技术？
解答：从整体上讲，J2EE 是使用 Java 技术开发企业级应用的工业标准，它是 Java 技术不断适应和促进企业级应用过程中的产物.适用于企业级应用的 J2EE,提供一个平台独立的、可移植的、多用户的、安全的和基于标准的企业级平台，从而简化企业应用的开发、管理和部署。J2EE 是一个标准，而不是一个现成的产品。
主要包括以下这些技术：
1) Servlet
Servlet 是 Java 平台上的 CGI 技术。Servlet 在服务器端运行，动态地生成 Web 页面。与传统的 CGI和许多其它类似 CGI 的技术相比，Java Servlet 具有更高的效率并更容易使用。对于 Servlet，重复的请求不会导致同一程序的多次转载，它是依靠线程的方式来支持并发访问的。
2)JSP
JSP(Java Server Page)是一种实现普通静态 HTML 和动态页面输出混合编码的技术。从这一点来看，非常类似 MicrosoftASP、PHP 等技术。借助形式上的内容和外观表现的分离，Web 页面制作的任务可以比较方便地划分给页面设计人员和程序员，并方便地通过JSP 来合成。在运行时态，JSP 将会被首先转换成 Servlet，并以 Servlet 的形态编译运行，因此它的效率和功能与 Servlet 相比没有差别，一样具有很高的效率。
3) EJB
EJB 定义了一组可重用的组件：Enterprise Beans。开发人员可以利用这些组件，像搭积木一样建立分布式应用。
4)JDBC
JDBC(Java Database Connectivity ， Java 数据库连接)API 是 一 个 标 准 SQL(Structured QueryLanguage，结构化查询语言)数据库访问接口，它使数据库开发人员能够用标准 Java API 编写数据库应用程序。JDBC API 主要用来连接数据库和直接调用 SQL 命令执行各种 SQL 语句。利用 JDBC API 可以执行一般的 SQL 语句、 动态 SQL 语句及带 IN 和 OUT 参数的存储过程。 Java 中的 JDBC 相当于 Microsoft平台中的 ODBC(Open DatabaseConnectivity)。
2.测试生命周期、测试过程分为几个阶段，以及各阶段的含义？
解答：软件测试生命周期一般包括 6 个阶段：
1）计划
2）分析，
3）设计，
4）构建，
5）测试周期，
6）最后测试和实施，
1） 计划：产品定义阶段
2). 分析:外部文档阶段
3). 设计:文档架构阶段
4). 构建:单元测试阶段
5). 测试周期:错误修正,重复系统测试阶段
6). 最后的测试和实施:代码冻结阶段
4. 什么是 Web 容器?
解答：容器就是一种服务程序，在服务器一个端口就有一个提供相应服务的程序，而这个程序就是处理从客户端发出的请求，如 JAVA 中的 Tomcat 容器，ASP 的 IIS 或 PWS 都是这样的容器。
5. 运行时异常与一般异常有何异同？
解答：异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java 编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
9.试述数据库完整保护的主要任务和措施。
解答：数据库的完整性保护也就是数据库中数据正确性的维护。数据库完整性包括三个内容：实体完整性规则，参照物完整性规则以及用户定义完整性规则。前两个是有 DBMS 自动处理。实体完整性规则是说针对于基表中的关键字中属性值不能为空值，是数据库完整性的基本要求，主关键字和元组的唯一性对应。参照物完整性规则是不允许引用不存在的元组：即基表中的外关键字要么为空，要么关联基表中必存在元组。用户定义完整性规则针对具体的数据环境由用户具体设置的规则，它反应了具体应用中的语义要求。一个完整性规则一般由下面三部分组成:完整性约束条件设置,完整性约束条件的检查以及完整性约束条件的处理.后两部分在数据库中一般有相应的模块处理。另外触发器也可以做完整性的保护，但触发器大量用于主动性领域。
12. 类有哪三个基本特性？各特性的优点？
解答：类具有封装性、继承性和多态性。
封装性：类的封装性为类的成员提供公有、缺省、保护和私有等多级访问权限，目的是隐藏类中的私有变量和类中方法的实现细节。
继承性：类的继承性提供从已存在的类创建新类的机制，继承（inheritance）使一个新类自动拥有被继承类（父类）的全部可继承的成员。
多态性：类的多态性提供类中方法执行的多样性，多态性有两种表现形式：重载和覆盖。
13.谈谈对 XML 的理解？说明 Web 应用中 Web.xml 文件的作用？
解答：XML（Extensible Markup Language）即可扩展标记语言，它与 HTML 一样，都是 SGML(Standard GeneralizedMarkup Language,标准通用标记语言)。Xml 是 Internet 环境中跨平台的，依赖于内容的技术，是当前处理结构化文档信息的有力工具。扩展标记语言 XML 是一种简单的数据存储语言，使用一系列简单的标记描述数据，而这些标记可以用方便的方式建立，虽然 XML 占用的空间比二进制数据要占用更多的空间，但 XML 极其简单易于掌握和使用。web.xml的作用是配置欢迎页，servlet，filter，listener 等的。
14.jsp 有哪些内置对象？作用分别是什么？（至少三个）
解答：
1）request 表示 HttpServletRequest 对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header 和 session 数据的有用的方法。
2）response 表示 HttpServletResponse 对象，并提供了几个用于设置送回浏览器的响应的方法（如cookies,头信息等）。
3） out 对象是javax.jsp.JspWriter 的一个实例， 并提供了几个方法使你能用于向浏览器回送输出结果。
4） pageContext 表示一个 javax.servlet.jsp.PageContext 对象。它是用于方便存取各种范围的名字空间、servlet 相关的对象的 API，并且包装了通用的servlet 相关功能的方法。
5）session 表示一个请求的 javax.servlet.http.HttpSession 对象。Session 可以存贮用户的状态信息。
6）application 表示一个 javax.servle.ServletContext 对象。这有助于查找有关 servlet 引擎和servlet 环境的信息。
7）config 表示一个 javax.servlet.ServletConfig 对象。该对象用于存取 servlet 实例的初始化参数。
8）page 表示从该页面产生的一个servlet 实例。9）exception 针对错误网页，未捕捉的例外
15.事务是什么？有哪些属性，并简要说明这些属性的含义。
解答：事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言（如 SQL，C++或 Java）书写的用户程序的执行所引起，并用形如 begin transaction 和 end transaction 语句（或函数调用）来界定。事务由事务开始(begintransaction)和事务结束(end transaction)之间执行的全体操作组成。事务应该具有 4 个属性：原子性、一致性、隔离性、持续性。这四个属性通常称为 ACID 特性。
原子性（atomicity） ：一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。
一致性（consistency）：事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
隔离性（isolation）：一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
持久性（durability）：持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。
19、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 的一个实现。最大的不同是，Hastable 的方法是 synchronize 的，而 HashMap 不是，在多个线程访问 Hashtable 时，不需要自己为s它的方法实现同步，而 HashMap 就必须为之提供同步。
20.请说出 ArrayList,Vector, LinkedList 的存储性能和特性
解答： ArrayList 和 Vector 都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector 由于使用了 synchronized 方法（线程安全），通常性能上较ArrayList 差，而 LinkedList 使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
21. 描述 J2EE 框架的多层结构，并简要说明各层的作用。
解答：
1)Presentation layer（表示层）a. 表示逻辑（生成界面代码）b. 接收请求 c. 处理业务层抛出的异常 d. 负责规则验证（数据格式，数据非空等）e. 流程控制
2)Service layer（服务层/业务层）a.封装业务逻辑处理，并且对外暴露接口b.负责事务，安全等服务
3)Persistence layer（持久层） a 封装数据访问的逻辑，暴露接口 b.提供方便的数据访问的方案（查询语言，API，映射机制等）
4)Domain layer（域层） a. 业务对象以及业务关系的表示b. 处理简单的业务逻辑c. 域层的对象可以穿越表示层，业务层，持久层软件分层结构使得代码维护非常方便，设计明确，各层独立，专注自己擅长的领域。
23.简要描述如何结合 struts、hibernate、spring 开发 Web 应用？
解答：
Struts 可以将 jsp 页面的表单关联起来,就是把 JSP 页面的表单数据封装成 javaBean,这样的话,在 action 中你再也不需要使用传统的 request.getParameter("name");还有 struts 有一个控制器,你在 struts 编程中的控制器(XxxAction)都是继承总的 ActionServlet,它能集中处理请求,然后转到相关的页面。还有 struts 的表单验证组件,不用你写 js 验证了,只需要你配置一下文件就可以了。另外 struts 的令牌机制可以防表单重复提交。
Spring 是一个轻量级容器,非侵入性.包含依赖注入,AOP 等。它是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为J2EE 应用程序开发提供集成的框架。
Hibernate:它可以让我们以 OO 的方式操作数据库，这让我们看到了 hibernate 的强大之处，体验到操作数据的方便。但 hibernate 最耀眼之处是 hibernate 的缓存机制，而不是以 OO 的方式操作数据库。Hibernate 的缓存机制不外乎是一级缓存 session，二级缓存 sessionFactory，和第三方缓存 如 ehcache 。 也就 是 hibernate 的 最 强大 的地 方 是 它的 缓存 ， 理解了 这 个 才能 真正 的 理解hibernate,Hibernate 的命名查询/命名参数查询， 就是将 hql 语句放在一个单独的 xml 文件之中， 它仍然让人们以面向对象的方式去操纵数据，而不用在以 OO 的方式写着代码的同时，然后再转变思维，用面向关系的方式去写那些 sql 语句。但 hibernate不仅做了这些，它的native sql 查询方式，完
全满足 sql 语句的偏爱者，它像 ibatis 一样，将 sql 语句放在配置文件之中
27.列出自己常用的 jdk 包.
解答：JDK 常用的 package
java.lang：这个是系统的基础类，比如 String 等都是这里面的，这个 package 是唯一一个可以不用 import 就可以使用的 Package
java.io: 这里面是所有输入输出有关的类，比如文件操作等
java.net: 这里面是与网络有关的类，比如 URL,URLConnection 等。
java.util : 这个是系统辅助类，特别是集合类 Collection,List,Map 等。
java.sql: 这个是数据库操作的类，Connection, Statememt，ResultSet 等
28.列出自己常用的 jdk 中的数据结构
解答：线性表，链表，哈希表是常用的数据结构。
32、abstract class 和 interface 有什么区别?
解答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建 abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。接口（interface）是抽象类的变体。新型多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，所有成员变量都是 public static final 的。一个类可以实现多个接口，当类实现接口时，必须实现接口的所有方法。抽象类在 Java 语言中表示的是一种单继承的关系，对于 interface 来说则不然，并不要求 interface 的实现者和 interface 定义在概念本质上是一致的，仅仅是实现了interface 定义的契约而已；抽象类中可以定义自己的成员变量，也可以包含非抽象的方法，而在接口中只能有静态的常量，所有方法必须是抽象的；实现抽象类时可以只实现其中的部分方法，而要是实现一个接口的话就必须实现这个接口中的所有抽象方法
35.JSP 页面之间传递参数的方法有哪些？
解答：
1）request
2）session
3）application
4）提交表单
5）超链接
36.fowrard 和 redirect 的区别
1、转发与重定向的区别
1)地址
转发的地址必须是同一个应用内部的各个组件。重定向的地址没有限制。
2)能否共享request
转发可以 重定向不行
3)浏览器地址栏的地址是否变化
转发不变 重定向会变
4)事件是否处理完毕
转发是一件事未做完 重定向是一件事已经做完
forward 是容器中控制权的转向，是服务器请求资源，服务器直接访问目标地址的 URL，把那个 URL 的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。 redirect 就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，并且从浏览器的地址栏中可以看到跳转后的链接地址。前者更加高效， 在前者可以满足需要时，尽量使用 forward()方法，并且，这样也有助于隐藏实际的链接；在有些情况下比如，需要跳转到一个其它服务器上的资源，则必须使用 sendRedirect()方法。
37.Java 反射机制的作用？
解答：Java 反射机制的作用是：
1）在运行时判断任意一个对象所属的类。
2）在运行时构造任意一个类的对象。
3）在运行时判断任意一个类所具有的成员变量和方法。
4）在运行时调用任意一个对象的方法
38．你是怎么理解 java 的泛型的？
解答： 在1.5 之前，没有泛型的情况的下，通过对类型 Object 的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型是 Java SE 1.5 的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。
40．在一个千万级的数据库查寻中，如何提高查询效率？分别说出在数据库设计、SQL 语句、java 等
1）数据库设计方面：
a. 对查询进行优化，应尽量避免全表扫描，首先应考虑在 where 及 order by 涉及的列上建立索引。b. 应尽量避免在 where 子句中对字段进行 null 值判断，否则将导致引擎放弃使用索引而进行全表扫描，如：select idfrom t where num is null可以在 num 上设置默认值 0，确保表中 num 列没有 null 值，然后这样查询：select id from t wherenum=0
c. 并不是所有索引对查询都有效，SQL 是根据表中数据来进行查询优化的 当索引列有大量数据重复时,查询可能不会去利用索引，如一表中有字段 sex，male、female 几乎各一半，那么即使在 sex 上建了索引也对查询效率起不了作用。
d. 索引并不是越多越好，索引固然可以提高相应的 select 的效率，但同时也降低了 insert 及update 的效率，因为 insert 或 update 时有可能会重建索引，所以怎样建索引需要慎重考虑，视具体情况而定。一个表的索引数最好不要超过 6 个，若太多则应考虑一些不常使用到的列上建的索引是否有必要。
3)java 方面：
a.尽可能的少造对象。b.合理摆正系统设计的位置。大量数据操作，和少量数据操作一定是分开的。大量的数据操作，肯定不是 ORM 框架搞定的。，
c.使用 jDBC 链接数据库操作数据d.控制好内存，让数据流起来，而不是全部读到内存再处理，而是边读取边处理；e.合理利用内存，有的数据要缓存
43.请写出一个超链接，点击链接后可以向 zhangsan@d-heaven.com 发送电子邮件。
<a href=”mailto: zhangsan@d-heaven.com”>发邮件</a>
44.请说明 meta 标签的作用。
解答：meta 是用来在 HTML 文档中模拟 HTTP 协议的响应头报文。meta 标签用于网页的＜head＞与＜/head＞中，meta 标签的用处很多。meta 的属性有两种：name 和 http-equiv。name 属性主要用于描述网页，对应于 content（网页内容），以便于搜索引擎机器人查找、分类（目前几乎所索引擎都使用网上机器人自动查找 meta 值来给网页分类） 。这其中最重要的是 description（站点在搜索引擎上的描述）和 keywords（分类关键词） ，所以应该给每页加一个 meta 值。比较常用的有以下几个：
name 属性
1)．＜meta name="Generator" contect=""＞用以说明生成工具（如 Microsoft FrontPage 4.0）
2)．＜meta name="KEYWords" contect=""＞向搜索引擎说明你的网页的关键词；
3)．＜meta name="DEscription" contect=""＞告诉搜索引擎你的站点的主要内容；
4).＜meta name="Author" contect="你的姓名"＞告诉搜索引擎你的站点的制作的作者；
5).＜meta name="Robots" contect= "all|none|index|noindex|follow|nofollow"＞
其中的属性说明如下：
设定为 all：文件将被检索，且页面上的链接可以被查询；设定为 none：文件将不被检索，且页面上的链接不可以被查询； 设定为 index：文件将被检索；设定为follow：页面上的链接可以被查询；设定为 noindex：文件将不被检索，但页面上的链接可以被查询设定为 nofollow：文件将不被检索，页面上的链接可以被查询。
6).http-equiv 属性
a、＜meta http-equiv="Content-Type"contect="text/html";charset=gbk"＞
和 ＜meta http-equiv="Content-Language"contect="zh-CN"＞用以说明主页制作所使用的文字以及语言；
b、＜metahttp-equiv="Refresh" contect="n;url=http://yourlink"＞定时让网页在指定的时
间 n 内，跳转到页面 http;//yourlink；
c、＜metahttp-equiv="Expires" contect="Mon,12 May 2001 00:20:00 GMT"＞可以用于设定网页的到期时间，一旦过期则必须到服务器上重新调用。需要注意的是必须使用 GMT 时间格式；
d、＜meta http-equiv="Pragma"contect="no-cache"＞是用于设定禁止浏览器从本地机的缓存中调阅页面内容，设定后一旦离开网页就无法从 Cache 中再调出；
e、＜metahttp-equiv="set-cookie" contect="Mon,12 May 2001 00:20:00GMT"＞cookie 设定，如果网页过期，存盘的 cookie 将被删除。需要注意的也是必须使用 GMT 时间格式；
f、＜metahttp-equiv="Pics-label" contect=""＞网页等级评定，在 IE 的 internet 选项中有一项内容设置，可以防止浏览一些受限制的网站，而网站的限制级别就是通过 meta 属性来设置的；
g、＜metahttp-equiv="windows-Target" contect="_top"＞强制页面在当前窗口中以独立页面显示，可以防止自己的网页被别人当作一个frame 页调用；
h、＜metahttp-equiv="Page-Enter"contect="revealTrans(duration=10,transtion=
50)"＞和＜metahttp-equiv="Page-Exit" contect="revealTrans(duration=20，transtion
=6)"＞设定进入和离开页面时的特殊效果，这个功能即 FrontPage 中的“格式/网页过渡”，不过所加的页面不能够是一个 frame 页面。
48．请写出一段 JavaScript 代码，要求页面有一个按钮，点击按钮弹出确认框。程序可以判断出用户点击的是“确认”还是“取消” 。
解答：
<HTML>
<HEAD>
<TITLE>click</TITLE>
<Script >
function validateForm()
{
if(confirm("你确认提交这个表单么？"))
{
alert(“确定”);
}else{
alert(“取消”);
}
}
</Script>
</HEAD>
<BODY>
<FORM NAME="TEST"action="FirstJS.htm">
<INPUT TYPE="button"NAME="SUB" VALUE="提交"onClick="JavaScript:validateForm()">
</FORM>
</BODY>
</HTML>
51.JavaScript 能否操作 cookie 和 session？
解答：JavaScript 可以操作 cookie，但是不能操作 session
52.请写出如下正则表达式的含义；
com︱cn︱net
^http://www.d-heaven.com/$
^http://www.sina.com.cn/new/newid=\d+
解答：com︱cn︱net 表示匹配 com 或是 cn 或是 net 中一个
^http://www.d-heaven.com/$ 表示匹配：http://www.d-heaven.com/
^http://www.sina.com.cn/new/newid=\d+
表示匹配http://www.sina.com.cn/new/newid=其后可以出现 1 到多个数字
53.请用正则表达式匹配出 QQ 号（假设 QQ 号码为 5—10 位)
解答： ^\d{5,10}$
54. String, StringBuffer StringBuilder 的区别。
解答：String 的长度是不可变的；StringBuffer 的长度是可变的，如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用 StringBuffer，如果最后需要 String，那么使用 StringBuffer 的 toString()方法；线程安全；
StringBuilder 是从 JDK 5 开始，为 StringBuffer 该类补充了一个单个线程使用的等价类；通常应该优先使用StringBuilder 类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。
55.请写出 5 种常见到的 runtimeexception。
解答：NullPointerException：当操作一个空引用时会出现此错误。
NumberFormatException：数据格式转换出现问题时出现此异常。
ClassCastException：强制类型转换类型不匹配时出现此异常。
ArrayIndexOutOfBoundsException：数组下标越界，当使用一个不存在的数组下标时出现此异常。ArithmeticException：数学运行错误时出现此异常
57.请写出一个单例模式。
解答：单例模式（Singletonpattern）:确保一个类只有一个实例，并提供一个全局的访问点
public class EagerSingleton
{
private static final EagerSingletonm_instance =
new EagerSingleton();
/**
* 私有的默认构造子
*/
private EagerSingleton() { }
/**
* 静态工厂方法
*/
public static EagerSingleton getInstance()
{
return m_instance;
}
}
58.在 java 中，List 是个接口，那实现 List 接口的类有哪些，有什么区别？
解答： ArrayList 是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，LinkedList 使用双向链表实现存储按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
64.Java 异常处理中，try {}里有一个 return 语句，那么紧跟在这个 try 后的 finally {}里的 code会不会被执行，什么时候被执行，在 return 前还是后?
解答：会执行，在return 前执行。
66.Class.forName（String className）这个方法的作用
解答：通过类的全名获得该类的类对象
67.你认为在表上建立索引可以提高数据库系统的效率吗，为什么？
解答：不一定建立太多的索引将会影响更新和插入的速度，因为它需要同样更新每个索引文件。对于一个经常需要更新和插入的表格，就没有必要为一个很少使用的 where 子句单独建立索引了，对于比较小的表，排序的开销不会很大，也没有必要建立另外的索引。
68.hibernate 中的 java 对象有几种状态，其相互关系如何（区别和相互转换） 。
解答：在 Hibernate中，对象有三种状态：临时状态、持久状态和游离状态。
临时状态：当 new 一个实体对象后，这个对象处于临时状态，即这个对象只是一个保存临时数据的内存区域，如果没有变量引用这个对象，则会被 jre 垃圾回收机制回收。这个对象所保存的数据与数据库没有任何关系，除非通过 Session 的 save 或者SaveOrUpdate 把临时对象与数据库关联，并把数据插入或者更新到数据库，这个对象才转换为持久对象；
持久状态:持久化对象的实例在数据库中有对应的记录，并拥有一个持久化表示（ID）。对持久化对象进行 delete 操作后，数据库中对应的记录将被删除，那么持久化对象与数据库记录不再存在对应关系，持久化对象变成临时状态。持久化对象被修改变更后，不会马上同步到数据库，直到数据库事务提交。在同步之前，持久化对象是脏的（Dirty） 。
游离状态：当 Session进行了 Close、Clear 或者 evict 后，持久化对象虽然拥有持久化标识符和与数据库对应记录一致的值 但是因为会话已经消失 对象不在持久化管理之内， 所以处于游离状态（也叫：脱管状态）。游离状态的对象与临时状态对象是十分相似的，只是它还含有持久化标识。
69.对 hibernate 的延迟加载如何理解，在实际应用中，延迟加载与 session 关闭的矛盾是如何处理
的？
解答： 延迟加载就是并不是在读取的时候就把数据加载进来而是等到使用时再加载。那么 Hibernate是怎么知识用户在什么时候使用数据了呢？又是如何加载数据呢？其实很简单，它使用了代理机制。返回给用户的并不是实体本身，而是实体对象的代理。代理对象在用户调用 getter 方法时就会去数据库加载数据。但加载数据就需要数据库连接。而当我们把会话关闭时，数据库连接就同时关闭了。这种情况就叫做未初始化的关系。
延迟加载与 session 关闭的矛盾一般可以这样处理：
1)、关闭延迟加载特性。
操作起来比较简单，因为hibernate 的延迟加载特性是在 hbm 配置里面可控制的。 默认 lazy="true"，具体配置可以查看一下相关文档，就不详细叙述了。但使用这个解决办法带来的隐患是十分大的。首先，出现 no session or session was closed 就证明了您已经在使用外键关联表，如果去掉延迟加载的话，则表示每次查询的开销都会变得十分的大，如果关联表越多，后果也可以想象得到。所以不建议使用这个方法解决。
2)、在 session 关闭之前把我们想要查询的数据先获取了。
首先需要了解一下session 什么时候关闭，也就是它的生命周期。通常情况下 hibernate 会在查询数据关闭 session， 而使用 getHibernateTemplate().get 方法查询后会延迟关闭的时间。 会在事务结束后才关闭。使用拦截器(Interceptor)或过滤器(Filter)控制 session。
spring 为解决 hibernate 这一特性提供的解决方案，可以有效的控制 session 生命周期。
70.什么是 AOP 和 OOP，IOC 和 DI 有什么不同?
解答：
1）面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。AOP 是 OOP 的延续，是 Aspect Oriented Programming 的缩写，意思是面向方面编程。 将通用需求功能从不相关类之中分离出来；同时，能够使得很多类共享一个行为，一旦行为发生变化，不必修改很多类，只要修改这个行为就可以。AOP 就是这种实现分散关注的编程方法，它将“关注”封装在“方面”中
2）控制反转 IOC(Inversion of Control) 控制指的就是程序相关类之间的依赖关系.传统观念设计中,通常由调用者来创建被调用者的实例, 在 Spring 里,创建被调用者的工作不再由调用者来完成,而是由 Spring 容器完成，依赖关系被反转了，称为控制反转，目的是为了获得更好的扩展性和良好的可维护性。依赖注入(Dependency injection)创建被调用者的工作由 Spring 容器完成，然后注入调用者，因此也称依赖注入。控制反转和依赖注入是同一个概念。
71.Struts1 中 actionform 和 action 属于 MVC 哪一层，为什么？
解答：actionform 和 action 属于 MVC 的 Model 层，Action 用来处理业务逻辑，actionform 保存用户表单数据以便于在不同页面间传递。而 MVC 中的 model 层就是业务逻辑层，该层用于实现具体的业务逻辑、状态维护及管理。
73.error 和 exception 有什么区别?
解答：error 表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；exception 表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。
74.Log4J 是 Apache 组织的开源一个开源项目，通过 Log4J，可以指定日志信息输出的目的地，如console、file 等。Log4J 采用日志级别机制，请按照输出级别由低到高的顺序写出日志输出级别。
解答：Log4J 分 为 OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL 或者您定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是 ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了 INFO 级别， 则应用程序中所有 DEBUG 级别的日志信息将不被打印出来。
75.说出几个与 spring 同类型的开源框架，说出几个与 hibernate 同类型的开源框架,说出几个与struts 同类型的开源框架
解答：
1）与 spring 同类型的开源框架：JUIDE、EJB3.0、picoContainer
2）与 hibernate 同类型的开源框架 ：ibatis，jdo，JPA
3）几个与 struts 同类型的开源框架：webwork，tapestry，JSF
76、Struts2 包含哪些标签？
解答：
A：
<s:ahref=""></s:a>-----超链接，类似于 html 里的<a></a>
<s:actionname=""></s:action>-----执行一个 view 里面的一个 action
<s:actionerror/>-----如果 action 的 errors 有值那么显示出来
<s:actionmessage/>-----如果 action 的 message 有值那么显示出来
<s:append></s:append>-----添加一个值到 list，类似于 list.add();
<s:autocompleter></s:autocompleter>-----自动完成<s:combobox>标签的内容，这个是 ajax
B：
<s:beanname=""></s:bean>-----类似于 struts1.x 中的，JavaBean 的值
C：
<s:checkbox></s:checkbox>-----复选框
<s:checkboxlistlist=""></s:checkboxlist>-----多选框
<s:comboboxlist=""></s:combobox>-----下拉框
<s:component></s:component>-----图像符号
D：
<s:date/>-----获取日期格式
<s:datetimepicker></s:datetimepicker>-----日期输入框
<s:debug></s:debug>-----显示错误信息
<s:div></s:div>-----表示一个块，类似于 html 的<div></div>
<s:doubleselect list=""doubleName="" doubleList=""></s:doubleselect>-----双下拉框
E：
<s:if test=""></s:if>
<s:elseiftest=""></s:elseif>
<s:else></s:else>-----这 3 个标签一起使用，表示条件判断
F：
<s:fielderror></s:fielderror>-----显示文件错误信息
<s:file></s:file>-----文件上传
<s:formaction=""></s:form>-----获取相应 form 的值
G：
<s:generator separator=""val=""></s:generator>----和<s:iterator>标签一起使用
H：
<s:head/>-----在<head></head>里使用，表示头文件结束
<s:hidden></s:hidden>-----隐藏值
I：
<s:i18nname=""></s:i18n>-----加载资源包到值堆栈
<s:includevalue=""></s:include>-----包含一个输出，servlet 或 jsp 页面
<s:inputtransferselectlist=""></s:inputtransferselect>-----获取 form 的一个输入
<s:iterator></s:iterator>-----用于遍历集合
L：
<s:label></s:label>-----只读的标签
M：
<s:merge></s:merge>-----合并遍历集合出来的值
O：
<s:optgroup></s:optgroup>-----获取标签组
<s:optiontransferselect doubleList="" list=""
doubleName=""></s:optiontransferselect>-----左右选择框
P：
<s:param></s:param>-----为其他标签提供参数
<s:password></s:password>-----密码输入框
<s:property/>-----得到‘value‘的属性
<s:pushvalue=""></s:push>-----value 的值 push 到栈中,从而使 property 标签的能够获取 value
的属性
R：
<s:radiolist=""></s:radio>-----单选按钮
<s:reset></s:reset>-----重置按钮
S：
<s:selectlist=""></s:select>-----单选框
<s:setname=""></s:set>-----赋予变量一个特定范围内的值
<s:sortcomparator=""></s:sort>-----通过属性给 list 分类
<s:submit></s:submit>-----提交按钮
<s:subset></s:subset>-----为遍历集合输出子集
T：
<s:tabbedPanelid=""></s:tabbedPanel>-----表格框
<s:table></s:table>-----表格
<s:textname=""></s:text>-----I18n 文本信息
<s:textarea></s:textarea>-----文本域输入框
<s:textfield></s:textfield>-----文本输入框
<s:token></s:token>-----拦截器
<s:tree></s:tree>-----树
<s:treenodelabel=""></s:treenode>-----树的结构
U：
<s:updownselectlist=""></s:updownselect>-----多选择框
<s:url></s:url>-----创建 url
77、struts2 中，OGNL 访问值栈的时候查找的顺序是什么？请排序：模型对象、临时对象、固定名称的对象、Action 对象
解答：struts2 的值栈排列顺序为：1）.临时对象；2）.模型对象；3）.Action 对象；4）.固定名称对象（如#application, #session,#request 等对象）
78、struts2 中，Action 通过什么方式获得用户从页面输入的数据，又是通过什么方式把其自身的数据传给视图的？
解答：1）可以直接通过与表单元素相同名称的数据成员（需要存在符合命名规范 set和 get 方法）获取页面表单数据。
2）会把处理好的数据成员放入值栈中，到页面可以使用 struts2 标签取值就可以了。
79.常用的设计模式有哪些？说明工厂模式。
解答：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 Of Responsibleity（责任链模式）
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
80.什么是数据库的参照完整性？
解答：数据库的参照完整性是指表与表之间的一种对应关系，通常情况下可以通过设置两表之间的主键、外键关系，或者编写两表的触发器来实现。有对应参照完整性的两张表格，在对他们进行数据插入、更新、删除的过程中，系统都会将被修改表格与另一张对应表格进行对照，从而阻止一些不正确的数据的操作。
81.如何优化数据库，如何提高数据库的性能?
解答：
1）硬件调整性能
最有可能影响性能的是磁盘和网络吞吐量,解决办法扩大虚拟内存，并保证有足够可以扩充的空间；
把数据库服务器上的不必要服务关闭掉；把数据库服务器和主域服务器分开；把 SQL 数据库服务器的
吞吐量调为最大；在具有一个以上处理器的机器上运行 SQL。
2）调整数据库
若对该表的查询频率比较高，则建立索引；建立索引时，想尽对该表的所有查询搜索操作， 按照
where 选择条件建立索引，尽量为整型键建立为有且只有一个簇集索引，数据在物理上按顺序在数据
页上，缩短查找范围，为在查询经常使用的全部列建立非簇集索引，能最大地覆盖查询；但是索引不
可太多，执行 UPDATEDELETE INSERT 语句需要用于维护这些索引的开销量急剧增加；避免在索引中
有太多的索引键；避免使用大型数据类型的列为索引；保证每个索引键值有少数行。
3）使用存储过程
应用程序的实现过程中，能够采用存储过程实现的对数据库的操作尽量通过存储过程来实现，因为存
储过程是存放在数据库服务器上的一次性被设计、编码、测试，并被再次使用，需要执行该任务的应
用可以简单地执行存储过程，并且只返回结果集或者数值，这样不仅可以使程序模块化，同时提高响
应速度，减少网络流量，并且通过输入参数接受输入，使得在应用中完成逻辑的一致性实现。
4）应用程序结构和算法
建立查询条件索引仅仅是提高速度的前提条件，响应速度的提高还依赖于对索引的使用。因为人们在使用 SQL 时往往会陷入一个误区，即太关注于所得的结果是否正确，特别是对数据量不是特别大的数据库操作时，是否建立索引和使用索引的好坏对程序的响应速度并不大，因此程序员在书写程序时就忽略了不同的实现方法之间可能存在的性能差异，这种性能差异在数据量特别大时或者大型的或是复杂的数据库环境中（如联机事务处理 OLTP 或决策支持系统 DSS）中表现得尤为明显。在工作实践中发现，不良的 SQL 往往来自于不恰当的索引设计、不充份的连接条件和不可优化的 where 子句。在对它们进行适当的优化后，其运行速度有了明显地提高！
82.JS 中的三种弹出式消息提醒(警告窗口、确认窗口、信息输入窗口)的命令是什么？
解答：alert confirm prompt
83.描述 JSP 和 Servlet 的区别、共同点、各自应用的范围
解答：JSP 在本质上就是 SERVLET,但是两者的创建方式不一样.Servlet 完全是 JAVA 程序代码构成，擅长于流程控制和事务处理，通过 Servlet 来生成动态网页很不直观.JSP 由 HTML 代码和 JSP 标签构成，可以方便地编写动态网页.因此在实际应用中采用 Servlet 来控制业务流程，而采用 JSP 来生成动态网页.
84.在 java 语言中 int 和 Integer 有什么区别
解答：int 是基本数据类型，Integer 是 int 的包装类，属于引用类型
85.如何获得<div id=”div1”>This isfirst layer</div>中的值？
解答：<script>
var div1=Document.getElementById(“div1”);
alert(div1.innerHTML)
</script>
86.JDK1.5 中支持的 for 循环的语法
解答：for(typeelement : array) {
System.out.println(element)
}
type 集合(不仅仅指Collection，也包含普通的数组)中元素的数据类型
element遍历到 的元素array 集合对象本身(当然不只是 Collection)
87.简述 synchronized 和 java.util.concurrent.locks.Lock 的异同？
解答：主要相同点：Lock 能完成 synchronized 所实现的所有功能
主要不同点Lock 有比 synchronized 更精确的线程语义和更好的性能。 synchronized 会自动释放锁，而 Lock 一定要求程序员手工释放，并且必须在 finally 从句中释放
88.如何格式化日期
解答：
Date now=new Date();
SimpleDateFormat sdf=newSimpleDateFormat(“yyyy-MM-dd hh:mm:ss”);
String formatNow=sdf.format(now);
变量 formatNow 就是格式化好的日期。
89.将字符“12345”转换成 long 型
解答： Strings="12345";
longnum=Long.valueOf(s).longValue();
90.struts 中如何实现国际化，涉及哪些文件？
解答：“国际化”是指一个应用程序在运行时能够根据客户端请求所来自的国家/地区、语言的不同而显示不同的用户界面。 Struts 框架通过使用<bean:message>标记以及使用 java.util 数据包中定义的 Locale 和 ResourceBundle 类来支持国际化。java.text.MessageFormat 类定义的技术可以支持消息的格式。利用此功能，开发人员不需了解这些类的细节就可进行国际化和设置消息的格式。会涉及到资源文件，不需了解这些类的细节就可进行国际化和设置消息的格式。会涉及到资源文件，struts-config.xml 配置文件,web.xml 配置文件。
91.例举在诊断 Oracle 性能问题时，常用的工具、方法
解答：
1）简单一点的可以用 toad 及 dbartisan 这样的工具。
2）纯做性能监测，比较出色的有 spolight 和 emc 的 I3，这两个软件都比较贵。
3）一些网管系统这方面也不错，如 hp 的 openview。不过定制起来不太容易，且很贵。
4）不用花钱又好用的就是 Oracle 的 statpack 了。
5）再有就是自己写脚本了，大多数有经验的 DBA 都喜欢这样的方式。优点是实用灵活。缺点是如果想出一个性能变化的曲线图等图表，且做的美观就需要些 delphi,c++builder 或是 pb 的开发功底了。
92.Oracle 启动中，startup nomount、 startup mount 有什么差别？
解答：startup nomount：启动实例，读取参数文件，分配内存空间，启动后台进程，打开跟踪文件和报警文件。startup mount：装载数据库，打开控制文件。nomount 方式下还没有读取控制文件，该选项用于在数据库的控制文件全部损坏，需要重新创建数据库控制文件或创建一个新的数据库时使用。mount 选项下并没有打开数据文件，该选项可以用来修改数据库的运行模式或进行数据库恢复。
93.Oracle 启动中，spfile.ora、init<SID>.ora、spfile<SID>.ora 这三个文件正确的先后顺序是
什么？
解答：启动数据库，使用startup 命令，Oralce 将会按照以下顺序在缺省目录中搜索参数文件：spfile<SID>.ora, spfile.ora ,init<SID>.ora a
94.说明 Oracle 数据库逻辑备份和物理备份的方式。
解答：Oracle 备份包括逻辑备份和物理备份。
1)逻辑备份
数据库的逻辑备份包含读一个数据库记录集和将记录集写入文件。
a.输出（Export）输出可以是整个数据库、指定用户或指定表。
b.输入（Import）输入将输出建立的二进制转储文件读入并执行其命令。
2)物理备份
物理备份包含拷贝构成数据库的文件而不管其逻辑内容。
Oracle 支持两种不同类型的物理文件备份脱机备份 （offline backup）和联机备份（online b。a.脱机备份: 脱机备份用在当数据库已正常关闭，数据库处于"offline"时，要备份下列文件：所有数据文件所有控制文件所有联机日志init.ora（可选的）
b 联机备份:联机备份可用来备份任何运作在ARCHIVELOG 方式下的数据库。在这种方式下，联机日志被归档，在数据库内部建立一个所有作业的完整记录。联机备份过程具备强有力的功能。第一，提供了完全的时间点（point-in-time）恢复。第二，在文件系统备份时允许数据库保持打开状态。
102、查看下面的代码，写出可以使程序正常执行的修改方法
1.public class MyClass {
2.static String s1;
3. String s2;
4. public static void main(String args[]) {
5. String s3;
6. System.out.println("s1 =" + s1);
7. System.out.println("s2 =" + s2);
8. System.out.println("s3 =" + s3);
9. }
10.}
解答：删除第 8 行或者将第 6 行改为 String s3 = "";
103、为了显示 myStr = 23 这样的结果，写出在控制台输入的命令
public class MyClass {
public static void main(String args[]) {
String s1 = args[0];
String s2 = args[1];
String myStr = args[2];
System.out.printin("myStr =" + s2 + myStr);
}
}
解答：javaMyClass 1 2 3 4
104、写出下面代码的执行结果
public class MyClass {
static void aMethod(StringBuffer sf1, StringBuffer sf2) {
sf1.append(sf2);
sf2 = sf1;
}
public static void main(String[] args){
StringBuffer sf1 = new StringBuffer("A");
StringBuffer sf2 = new StringBuffer("B");
aMethod(sf1,sf2);
System.out .println(sf1+ ":"+sf2);
}
}
解答：AB:B
105、第 3 行中生成的 object 在第几行执行后成为 garbage collection 的对象？
1.public class MyClass {
2. public StringBuffer aMethod() {
3. StringBuffer sf = new StringBuffer("Hello");
4. StringBuffer[] sf_arr = new StringBuffer[1];
5. sf_arr[0] = sf;
6. sf = null;
7. sf_arr[0] = null;
8. return sf;
9. }
10.}
解答：第 7 行
106、写出执行下面的代码后的结果
public class MyClass {
public static void main(String args[]) {
java.util.Vector v1 = new java.util.Vector();
v1.addElement("Hello");
v1.addElement(new Float(3.14f));
v1.addElement(10);
System.out.println(v1.elementAt(0) + ":" + v1.elementAt(1) +":"+ v1.elementAt(2));
}
}
解答：Hello :3.14 : 10
107、写出执行下面代码后的正确结果
interface MyDB {
public void getConnection();
}
class MyDBDriver implements MyDB {
public void getConnection() {
System.out.println("getConnection()");
}
}
public class MyClass {
public static void aMethod(MyDB db) {
db.getConnection();
}
public static void main(String args[]) {
MyDBDriver db_driver = new MyDBDriver();
aMethod(db_driver);
}
}
解答：getConnection()
108、下列程序运行的结果是
class A {
class Dog {
private String name;
private int age;
private int step;
Dog(String s, int a) {
name = s;
age = a;
step = 0;
}
public void run(Dog fast) {
fast.step++;
}
}
public static void main(String args[]) {
A a = new A();
Dog d = a.new Dog("Tom", 3);
d.step = 25;
d.run(d);
System.out.println(d.step);
}
}
解答：26
109、请看下列程序，运行结果是
class Super{
int i=10;
Super(){
print();
i=20;
}
void print(){
System.out.print(i);
}
}
public class Sub extends Super{
int j=30;
Sub(){
print();
j=40;
}
void print(){
System.out.print(j);
}
public static void main(String[] args){
System.out.print(new Sub().j);
}
}
解答：03040
110、getSomething ()执行时发生 IllegalArgumentException 会出现什么样的结果？
void makeConnection(String url) {
try {
getSomething();
}catch(NullPointerException e) {
System.out.printin("Invalid URL") ;
return;
}catch(Exception e) {
System.out.println("Exception");
}
}
解答：Exception
111.Tomcat 服务器的默认端口是多少？怎样修改 tomcat 的端口？
解答：默认端口为 8080，可以通过 service.xml 的 Connector 元素的 port 属性来修改端口。
112.多线程有几种实现方法,都是什么?同步的方法有几种，都是什么？
解答：多线程有两种实现方法：继承 Thread 类或者实现 Runnable 接口。
实现同步也有两种方法：一种是同步方法，另一种是同步代码块。
同步方法是在方法返回类型前面加上 synchronized 关键字
同步代码块是synchronized (这里写需要同步的对象){...}
113.谈一下聚簇索引和非聚簇索引的区别以及各自的优缺点。
解答：
聚集索引,表中存储的数据按照索引的顺序存储,检索效率比普通索引高,但对数据新增/修改/删除的
影响比较大
非聚集索引,不影响表中的数据存储顺序,检索效率比聚集索引低,对数据新增/修改/删除的影响很小
114. 死锁的必要条件？怎么克服？
解答：产生死锁的四个必要条件：
互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。这四个条件是死锁的必要条件只要系统发生死锁，这些条件必然成立，
而只要上述条件之一不满足，就不会发生死锁。
死锁的解决方法:
a 撤消陷于死锁的全部进程
b 逐个撤消陷于死锁的进程，直到死锁不存在；
c 从陷于死锁的进程中逐个强迫放弃所占用的资源，直至死锁消失。
d 从另外一些进程那里强行剥夺足够数量的资源
分配给死锁进程，以解除死锁状态
115.描述重做与回滚的认识;
解答：重做日志生成日志文件,是为将来恢复数据库使用的.
回滚段保存未提交数据,是为支持事务而起作用的。
116.索引组织表,聚蔟表的用途;
解答：
索引组织表：数据按主码存储和排序，同索引结构一样，不过数据直接存储于主码后面。适用于信息.检索、空间和 OLAP 程序。索引组织表的适用情况：
a.代码查找表。b.经常通过主码访问的表。c.构建自己的索引结构。d.加强数据的共同定位，要数据按特定顺序物理存储。e.经常用 between„and„对主码或唯一码进行查询。数据物理上分类查询。如一张订单表，按日期装载数据，想查单个客户不同时期的订货和统计情况。
索引聚簇表：索引聚簇表是表相关的表共享同一数据块中的相同列，并把相关数据存储中同一个数据块上。创建索引聚簇表中最重要的是对 SIZE 参数有很好的估量，否则聚簇将会降低空间利用，降低效率。
使用索引聚簇表的注意点：
a 如果表中数据有大量 DML 操作的话，那么聚簇将不适用，因为会消极地影响到 DML 性能。b 聚簇中，全表扫描将受到影响。这是因为将扫描聚簇中不同表的数据，额外增加很多无用的数据。c 如果经常 TRUNCATE 表和装载表的话，聚簇将不适用。聚簇中的表无法被 TRUNCATE 的，这是因为每个块中不只是存储一张表的数据。
SQL> truncate table emp;
truncate table empERROR at line 1:
ORA-03292: Table to be truncated is part ofa cluster
d 如果大部分是读取操作，且通过聚簇码索引或聚簇表中其他索引来读取的话，聚簇将会比较适用。
117.消耗资源的 SQL 的定位方法;
解答：select sql_text
from v$sql
where disk_reads > 1000 or (executions> 0 and buffer_gets/executions > 30000);
SELECT * FROM (
SELECT sql_text,buffer_gets,disk_reads FROMv$sql
ORDER BY buffer_gets,disk_reads DESC)
WHERE ROWNUM<=10;
118.对触发器的认识;
解答：触发器是表上的程序,主要提供数据添加、修改与删除后的程序处理方法，可以用来检查数据及进行数据更新，也可以分担一些前端应用程序撰写的逻辑规则。用场景: 触发器可以查询其他表，而且可以包含复杂的 SQL 语句。它们主要用于强制复杂的业务规则或要求。触发器的主要应用场合概括起来讲有以下几种：
1).当向一张表中添加或删除记录时，需要在相关表中进行同步操作。比如，当为应用系统添加一个系统用户时，需要同时向权限表中添加该用户的缺省权限，此时就编写系统用户表的触发器在添加记录动作时触发。
2).当表上某列数据的值与其他表中的数据有联系时。比如，当某客户进行欠款消费，可以在生成订单时通过设计触发器判断该客户的累计欠款是否超出了最大限度。
3).当需要对某张表进行跟踪时。比如，当人事表中有人离职时，第一时间通知或更改相关表的值。
119.对 ORA-01555 错误的认识;
解 答： ORA-01555 错 误 产 生 的 原 因 ： 一 致 性 读 (Consistent Get) 和 延 迟 块 清 除 (Delayed Block
Cleanout)。
120.将 ORACLE 数据库更改为归档模式；写出步骤
解答：具体步骤如下：
1)，以 exp 方式在线备份数据库到指定位置；2)，观察当前数据库是以服务器参数文件(spfile)方式启动还是以参数文件(pfile)方式启动：SQL> show parameter spfile;
NAME TYPE
VALUE
----------------------------------------------- ------------------------------
spfile string /ho
me/db/oracle/10g/dbs/spfile
XXXX.oravalue 后有内容，说明数据库以服务器参数文件方式启动，这里的 spfile 文件对应的裸设备为/dev/vgdata/rspfile（通过查看/home/db/oracle/10g/dbs/initSID.ora 文件内容获得） ；
3)，关闭所有实例（shutdown immediate） ；
4)，任意选取一个实例，创建参数文件到指定路径：
SQL>createpfile=‘/home/db/oracle/pfile.ora‘ from spfile;
5)，修改 pfile.ora 文件，添加参数 cluster_database=false；
6)，以修改之后的参数文件按 nomount 方式启动数据库：
SQL>startup nomountpfile=‘/home/db/oracle/pfile.ora‘;
7)，使数据库以 exclusive 方式启动：
SQL>alter database mount exclusive;
8)，改变归档模式：
SQL>alter database archivelog;
9)，将 pfile 参数中的 cluster_database 重新更改为“true”；
10)，更新服务器参数文件：
SQL>create spfile frompfile=‘/home/db/oracle/pfile.ora‘;
11)，关闭数据库实例；
SQL>shutdowm immediate;
12)，分别在两个节点上启动数据库：
SQL>startup;
13)，在两个节点上分别检查归档模式是否更改成功：
SQL>archive log list;
Database log mode Archive Mode
Automatic archival Enabled
Archive destination /home/db/oracle/10g/dbs/arch
Oldest online log sequence 489
Next log sequence to archive 491
Current log sequence 491
完成。
121.把表 A 从表空间 TSP1 更改成表空间 TSP2 的方法
解答：alter tableA move tablespace TSP2
122.删除表的列；
解答：alert table表名 drop 列名
123.删除表空间的数据文件？
解答：用 SQLPLUS 命令: drop tablespace tablename including contents
就可以把所有相关的数据删除
124.如何用 ALTER 命令把表数据加到缓存表里，清除呢？
解答：添加：alert table 表名 cache
清除：alert table表名 nocache
125．数据的复制实现办法？
解答：数据复制，就是将数据库中的数据拷贝到另外一个或多个不同的物理站点上，从而保持源数据
库与目标数据库中指定数据的一致性。
数据复制的实现方法：在具体的实现之前，首先要做好设计与规划。这就需要细致分析具体的业务情
况，设计出一套能够满足业务需要的方案。通常在设计过程中，需要确定出要建立的数据库站点，各
站点的类型，需要复制的数据对象，以及同步方式、冲突解决方案等内容。
数据复制的实现主要包括以下几步：(1)创建复制站点。(2)创建组对象。(3)配置冲突解决方案。
126.建立 ORACLE 数据库后，系统自带的两个用户是什么，相应的密码是什么？他们的身份是什么？
解答： 用户 密码 身份
System manager SYSDBA
Sys change_on_instal SYSDPER
127.在建立 ORACLE 数据库时，选择“事务处理”模板与选用“数据仓库”模板的
区别是什么？
解答：事物处理型:经常反馈给客户信息,处理大容量或超大容量的数据.
数据仓库型:主要频繁处理小型数据库,只是进行一些查询等操作.
128、在使用 OMS 之前需要建立资料档案库。在建立资料档案库的时候，在“为资料档案库选择数据
库”选项卡中输入的服务名称应该如何写。 （比如你要连接 192.168.1.2 机器上的 SIST 数据库）。
解答：192.168.1.2:1521:SIST
129、登陆 OMS 所使用的用户名和密码分别为什么？如果在登陆时，系统提示找不到服务，你应该如
何处理？
解答：用户名：SYSMAN,
密码：OEM_TEMP
问题出现在服务器没有启动，只能通过手动的方法在 Windows 管理工具下的策略中将服务器启动。
130、请说出两种以上扩大数据库的方式
解答
1) 修改现有表空间的大小；
2)向表空间插入一个新的数据文件.
131 在 ORACLE 中的物理文件包含哪四种？
解答：
1)数据文件 扩展名为*.dbf
2)控制文件 扩展名为*.rtl
3)配置文件 扩展名为*.ora
4)日志文件 扩展名为*.dbf
132. 日志文件（记录文件）有哪几种，分别介绍他们的工作模式。
解答: 归档日志：当日志写满，完成一次循环之前建立一个副本。这样数据库就可以在损坏中得到恢
复。恢复的过程相当于把建库的所有动作重新做一次。最安全的数据库工作方式，占用空间也最大
非归档日志：日志写满后，直接覆盖，它只是部分地记录数据库操作，所以恢复能力有限。
133、简要写出在 system 方案中建立序列 xl 的步骤。
解答：
create squence system.xl
start whith 1
increment by 1
minvalue 1
nomaxvalue
nocycle
nocache
order;
134、写出 SQL 语句，向表中插入一条记录，其中 ID 字段的值来自序列 XL。
Insert into system.table1 values(xl.nextval,’tom’,21,’男’,2000);
135、写出一个匿名的 SQL 程序块，完成如下任务: 向表中插入 3000 条记录， salary 字段中有 500
条记录的值为 1000，500 条记录的值为 1200，1000 条记录的值为 1500，1000 条记录的值为 1800
Id 字段的值来自序列 xl,其他字段的值任意.
declare
x number:=0;
begin
for x in 1..3000 loop
If(x<=500) then
Insert into system.testvalues(x1.nextval,‘jim‘,24,‘m‘,1000);
elsif((x>500)and (x<1001)) then
Insert into system.testvalues(system.xl1.nextval,‘jim‘,24,‘m‘,1200);
Elsif((x>1000)and (x<2001)) then
Insert into system.testvalues(system.xl1.nextval,‘jim‘,24,‘m‘,1500);
Else
Insert into system.testvalues(system.xl1.nextval,‘jim‘,24,‘m‘,1800);
end if;
end loop;
end;
136、写出一个存储过程，这个存储过程的作用是修改特定 id 编号的记录，将该条记录的salary 字
段的值加上 500；
Create or replace proceduresystem.update_age
(vid in number) is
Begin
Update table1 set salary=salary+500 whereid=vid;
End;
137、用 SQL 语句创建个一个视图，这个视图用来显示 ID>1000 的记录；
解答：create viewst as select * from table1 where id>1000;
138、创建一个 system 方案中的函数 fn1，函数作用为：将指定 ID 号的记录中的 salary 字段值乘以
1.05。
Create or replace functionsystem.fn1(salary1 system.table1 salary &type)
Return number as
V1 numbre:=1.05;
V2 numbre;
Begin
V2=v1*salary1;
Return v2;
End ;
139.解释冷备份和热备份的不同点以及各自的优点
解答：热备份针对归档模式的数据库，在数据库仍旧处于工作状态时进行备份。而冷备份指在数据库
关闭后，进行备份，适用于所有模式的数据库。热备份的优点在于当备份时，数据库仍旧可以被使用
并且可以将数据库恢复到任意一个时间点。冷备份的优点在于它的备份和恢复操作相当简单，并且由
于冷备份的数据库可以工作在非归档模式下,数据库性能会比归档模式稍好。 （因为不必将 archive
log 写入硬盘）
140. 你必须利用备份恢复数据库，但是你没有控制文件，该如何解决问题呢？
解答：重建控制文件，用带backup control file 子句的 recover 命令恢复数据库。
141. 如何转换 init.ora 到 spfile?
解答：使用 createspfile from pfile 命令
142. 解释 data block , extent 和 segment 的区别（这里建议用英文术语）
解答：data block 是数据库中最小的逻辑存储单元。当数据库的对象需要更多的物理存储空间时，连
续的 data block 就组成了 extent . 一个数据库对象拥有的所有 extents 被称为该对象的 segment.
143. 给出两个检查表结构的方法
解答：
1、DESCRIBE 命令
2、DBMS_METADATA.GET_DDL 包
144. 怎样查看数据库引擎的报错
解答：alert log.
145. 使用索引的理由
解答：快速访问表中的data block
146. 给出在 STAR SCHEMA 中的两种表及它们分别含有的数据
解答：Fact tables和 dimensiontables. fact table 包含大量的主要的信息而 dimension tables
存放对 fact table某些属性描述的信息
147. FACT Table 上需要建立何种索引？
解答：位图索引（bitmapindex）
148. 给出两种相关约束?
解答：主键和外键
149. 如何在不影响子表的前提下，重建一个母表
解答：子表的外键强制失效，重建母表，激活外键
150. 如何建立一个备份控制文件？
解答：Alterdatabase backup control file to trace.
151. 给出数据库正常启动所经历的几种状态 ?
解答：
STARTUP NOMOUNT – 数据库实例启动
STARTUP MOUNT - 数据库装载
STARTUP OPEN –数据库打开
152. 哪个 column 可以用来区别 V$视图和 GV$视图?
解答： INST_ID 指明集群环境中具体的某个 instance 。
153. 如何生成 explain plan?
解答：
运行utlxplan.sql. 建立 plan 表针对特定 SQL 语句， 使用 explain plan set statement_id = ‘tst1‘
into plan_table 运行 utlxplp.sql 或 utlxpls.sql 察看 explain plan
154. 如何增加 buffer cache 的命中率？
解答：在数据库较繁忙时，适用buffer cache advisory 工具，查询 v$db_cache_advice . 如果有
必要更改，可以使用alter system set db_cache_size 命令
155. 解释$ORACLE_HOME 和$ORACLE_BASE 的区别？
解答：ORACLE_BASE是 oracle 的根目录，ORACLE_HOME 是 oracle 产品的目录
156. 如何判断数据库的时区？
解答：SELECTDBTIMEZONE FROM DUAL
157. 解释 GLOBAL_NAMES 设为 TRUE 的用途
解答：GLOBAL_NAMES指明连接数据库的方式。如果这个参数设置为 TRUE,在建立数据库链接时就必须
用相同的名字连结远程数据库
158.如何加密 PL/SQL 程序？
解答：WRAP
159. 解释 TABLE Function 的用途
解答：TABLEFunction 是通过 PL/SQL 逻辑返回一组纪录，用于普通的表/视图。他们也用于 pipeline
和 ETL(ETL， Extraction-Transformation-Loading 的缩写，中文名称为数据提取、 转换和加载)过程。
160. 举出 3 种可以收集 threeadvisory statistics
解答：BufferCache Advice, Segment Level Statistics, Timed Statistics
161. Audit trace 存放在哪个 oracle 目录结构中?
解答：unix$ORACLE_HOME/rdbms/audit
Windows the event viewer
162. 解释 materialized views 的作用
解答：Materializedviews 用于减少那些汇总，集合和分组的信息的集合数量。它们通常适合于数
据仓库和 DSS 系统
163. 当用户进程出错，哪个后台进程负责清理它
解答： PMON
164. 哪个后台进程刷新 materialized views?
解答：The JobQueue Processes.
165. 如何判断哪个 session 正在连结以及它们等待的资源？
解答：V$SESSION /V$SESSION_WAIT
166. 描述什么是 redo logs
解答：Redo Logs 是用于存放数据库数据改动状况的物理和逻辑结构。可以用来修复数据库
167. 如何进行强制 LOG SWITCH?
解答：ALTERSYSTEM SWITCH LOGFILE;
168. 举出两个判断 DDL 改动的方法？
解答：你可以使用Logminer 或 Streams
169. Coalescing 做了什么？
解答：Coalescing 针对于字典管理的 tablespace 进行碎片整理，将临近的小 extents 合并成单个的
大 extent.
170. TEMPORARY tablespace 和 PERMANENT tablespace 的区别是？
解答：temporarytablespace 用于临时对象例如排序结构而permanent tablespaces 用来存储那些‘
真实‘的对象(例如表，回滚段等)
171. 创建数据库时自动建立的 tablespace 名称？
解答：SYSTEMtablespace.
172. 创建用户时，需要赋予新用户什么权限才能使它联上数据库。
解答：CONNECT
173. 如何在 tablespace 里增加数据文件？
解答：ALTERTABLESPACE <tablespace_name> ADD DATAFILE <datafile_name> SIZE<size>
174. 如何变动数据文件的大小？
解答：ALTERDATABASE DATAFILE <datafile_name> RESIZE <new_size>;
175. 哪个 VIEW 用来检查数据文件的大小？
解答：DBA_DATA_FILES
176. 哪个 VIEW 用来判断tablespace 的剩余空间
解答：DBA_FREE_SPACE
177. 如何判断谁往表里增加了一条纪录？
解答：auditing
178. 如何重构索引？
解答： ALTERINDEX <index_name> REBUILD;
179. 解释什么是 Partitioning（分区）以及它的优点。
解答：Partition 将大表和索引分割成更小，易于管理的分区。
180. 你刚刚编译了一个 PL/SQL Package 但是有错误报道，如何显示出错信息？
解答：SHOW ERRORS
181. 如何搜集表的各种状态数据？
解答： ANALYZE
The ANALYZE command.
182. 如何启动 SESSION 级别的 TRACE
解答:DBMS_SESSION.SET_SQL_TRACE
ALTER SESSION SET SQL_TRACE = TRUE;
183.IMPORT 和 SQL*LOADER 这 2 个工具的不同点
解答：这两个 ORACLE 工具都是用来将数据导入数据库的。
区别是：IMPORT 工具只能处理由另一个 ORACLE 工具 EXPORT 生成
的数据。而SQL*LOADER 可以导入不同的 ASCII 格式的数据源
184.用于网络连接的 2 个文件？
解答：TNSNAMES.ORA and SQLNET.ORA
185. 说出 Servlet 的生命周期，并说出 Servlet 和 CGI 的区别？
解答：
Servlet 被服务器实例化后， 容器运行其 init 方法，请求到达时运行其 service 方法，service
方法自动派遣运行与请求对应的doXXX 方法（doGet，doPost）等，当服务器决定将实例销毁的时候
调用其 destroy 方法。
与 cgi 的区别在于 servlet 处于服务器进程中，它通过多线程方式运行其 service 方法，一个实例可
以服务于多个请求，并且其实例一般不会销毁，而 CGI 对每个请求都产生新的进程，服务完成后就销
毁，所以效率上低于servlet。
186、JAVA 中常用的 XML 解析技术有哪些？区别是什么？
解答： DOM、SAX 两种方式。
DOM：处理大型文件时其性能下降的非常厉害。这个问题是由 DOM 的数结构所造成的，这结构占用的
内存较多，而且 DOM 必须在解析文件之前把整个文档载入内存，适合对 XML 的随机访问
SAX：不同于 DOM，SAX 是事件驱动型的 XML 解析方法。它顺序读取 XML 文件，不需要一次全部装载整
个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过
在其回调事件中写入处理代码来处理 XML 文件，适合对 XML 的顺序访问。
187、XML 文档定义有几种形式？有何本质区别？
解答：两种形式 dtd 和 schema，区别：
a.Schema 是标准的 XML 文件,而 DTD 则使用自己的特殊语法,因此,只需要知道 XML 的语法规则就可以
编写 Schema 了,不需要再学习其它语法规则。
b.Schema 利用命名空间将文件中特殊的节点与 Schema 说明相联系,一个 XML 文件可以有多个对应的
Schema；而一个 XML 文件只能有一个相对应的DTD 文件。
c.Schema 的内容模型是开放的,可以随意扩充,而 DTD 则无法解读扩充的内容.DTD 只能把文件类型定
义为一个字符串,而 XML Schema 却允许把文件类型定义为整数,浮点数,字符串,布尔值或其他各
各数据类型,而无须重新定义。
188.MVC 的各个部分都有哪些技术来实现？如何实现？
解答：MVC 是 Model-View-Controller 的缩写，
Model 代表的是应用的业务逻辑（通过 JavaBean，EJB
组件实现） ，
View 是应用的表示面（由 JSP 页面产生）
Controller 是通过应用的处理过程控制,(一般是一个 servert）
通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现，这些组件可以进行交互和重用。
189 什么是垃圾回收？什么时候触发垃圾回收？如何降低垃圾回收的触发频率？它能保证程序有足
够的可用内存吗？
解答：垃圾回收(GC)是 Java 语言的一个重要特性，作用是释放不再被使用的内存。垃圾回收由系统
进行管理。在系统认为需要的时候自动启动一个线程进行处理。
尽量减少垃圾内存，也就是新建对象的数量，可以降低垃圾回收的频率。
垃圾回收机制无法保证有足够的内存。
190.什么是混淆(obfuscate)?有什么好处？有哪些工具可以混淆 jar 文件？
解答：混淆是指通过对class 文件中的变量名和部分方法名进行处理，来提高代码反编译的难度。
好处主要有 2 个：1、提高反编译以后代码阅读的难度 2、降低 class 文件的大小。
常见的混淆器有Proguard 和 RetroGuard 两种。
191.什么是状态机？游戏开发中有那些地方能用到状态机？
解答：状态机(StateMachine)是根据对应状态进行处理的一种机制，在游戏开发中最典型的应用是
游戏人工智能(AI)等地方。
192. 请根据你的知识，对以下计算机名词进行尽量简单的描述
解答：
1)J2ME 是一种使用 Java 语言进行嵌入式设备开发的技术。
2) Python 是一种语法简单的面对对象的程序设计语言
3)Ant 是 Java 的生成工具。
4)Javac 是 Java 语言的编译程序
5)Subversion 是新一代的版本工具
6)OpenGL 是一套开发的图形界面开发库标准
193.J2EE,EJB,JDBC 是一回事吗，它们之间有什么关系？
解答：不是一回事，J2EE（Java 2 Platform,Enterprise Edition）是一套全然不同于传统应用开发
的技术架构，包含许多组件，主要可简化且规范应用系统的开发与部署，进而提高可移植性、安全与
再用价值。J2EE 核心是一组技术规范与指南，其中所包含的各类组件、服务架构及技术层次，均有共
通的标准及规格，让各种依循J2EE 架构的不同平台之间，存在良好的兼容性。其中，EJB 和 JDBC 都
属于 J2EE 的一部分。
194.什么是数据库系统？
解答：数据库系统是储存、管理、处理和维护数据的软件系统，它由数据库、数据库管理员和有关软
件组成。数据库系统的结构框架由外部层（单个用户的视图） 、概念层（全体用户的公共视图）和内
部层（存储视图）组成。
195.试述数据库完整保护的主要任务和措施。
解答：数据库的完整性保护也就是数据库中数据正确性的维护。
数据库完整性包括三个内容：
实体完整性规则，参照物完整性规则以及用户定义完整性规则。前两个是有 DBMS 自动处理。
实体完整性规则是说针对于基表中的关键字中属性值不能为空值，是数据库完整性的基本要求，主关键字和元组的唯一性对应。
参照物完整性规则是不允许引用不存在的元组：即基表中的外关键字要么为空，要么关联基表中必存在元组。
用户定义的完整性规则针对具体的数据环境由用户具体设置的规则，它反应了具体应用中的语义要求。
一个完整性规则一般由下面三部分组成:
完整性约束条件设置,完整性约束条件的检查以及完整性约束条件的处理.后两部分在数据库中一般有相应的模块处理。另外触发器也可以做完整性的保护，但触发器大量用于主动性领域。
196. 请写出十种以上你知道的 java 开源软件，并用一句话说明功能。
解答：
Ibatis：持久层框架
Hibernate：持久层框架，它对 JDBC 进行了非常轻量级的对象封装
Struts：是一个基于 Sun J2EE 平台的 MVC 框架
Spring：是一个解决了许多在 J2EE 开发中常见的问题的强大框架
Tomcat：实现了 servlet、struts 框架的 web 服务器
WebWork：组件化和代码重用的拉出式 MVC 模式 J2EE Web 框架
Rose：系统分析和设计的工具
JUnit：用于单元测试
ANT：用于辅助开发
Eclipse：IDE 集成开发工具
197. 部署一个 web 应用的步骤是什么？
解答：
1.将 web 应用放到 Tomcat 服务器的 Webapps 包下，
2.启动服务器
3.在地址栏中输入 http://localhost:8080/应用名/
198. 什么是 UDDI、SOAP、WSDL？
解答：UDDI 是一套基于 Web 的、分布式的、为 Web Service 提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service 注册，以使别的企业能够发现的访问协议的实现标准。 SOAP 即简单对象访问协议(SimpleObject Access Protocol)，它是用于交换 XML 编码信息的轻量级协议。WSDL是一种 XML 格式，用于将网络服务描述为一组端点，这些端点对包含面向文档信息或面向过程信息的消息进行操作。这种格式首先对操作和消息进行抽象描述，然后将其绑定到具体的网络协议和消息格式上以定义端点。相关的具体端点即组合成为抽象端点(服务)。
199. Java 数据库编程包含哪些类？Java 数据库编程的基本过程是什么？
解答：用到的类：Connection、ResultSet、PreparedStatement、Statement
Java 中访问数据库的步骤如下：
1）注册驱动；
2）建立连接；
3）创建 Statement；
4）执行 sql 语句；
5）处理结果集（若 sql 语句为查询语句） ；
6）关闭连接。
200. 什么是 B/S 结构,C/S 结构？
解答：C/S 是 Client/Server 的缩写。服务器通常采用高性能的 PC、工作站或小型机，并采用大型数据库系统，如 Oracle、Sybase、Informix 或 SQL Server。客户端需要安装专用的客户端软件。
B/S 是 Brower/Server 的缩写，客户机上只要安装一个浏览器(Browser)，如 Netscape Navigator 或Internet Explorer，服务器安装 Oracle、Sybase、Informix 或 SQL Server 等数据库。在这种结构下，用户界面完全通过 WWW 浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过 Web Server 同数据库进行数据交互。
201. 什么是 AJAX 和 AOP?
解答： Ajax 的全称是：AsynchronousJavaScript And XML。Ajax 不是一个技术，它实际上是几种技术， 每种技术都有其独特这处合在一起就成了一个功能强大的新技术。
Ajax 包括： XHTML 和 CSS 使用文档对象模型(Document Object Model)作动态显示和交互使用 XML 和 XSLT 做数据交互和操作 使用 XMLHttpRequest 进行异步数据接收 使用 JavaScript 将它们绑定在一起 。
AOP 是 OOP 的延续，是 Aspect Oriented Programming 的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP 实际是 GoF 设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
202. 简要说明 JVM、JSP、Servlet、Web Server、Web Browser 之间的关系。
解答：当用户在 JSP 页面上提交了需要服务器处理的数据后，通过 Web Browser 发送到服务器端，Servlet 会根据用户的请求产生必要的相应，如果需要还会通过 JVM 或 Web Server 来获取资源，最后把服务器端的相应结果返回给用户。
203. 说说对开源项目 apache 的了解，说出其中你使用过的项目并给以评价
解答：Apache HTTPServer（简称 Apache）是 Apache 软件基金会的一个开放源码的网页服务器，可以在大多数计算机操作系统中运行由于其多平台和安全性被广泛使用， 是最流行的 Web 服务器端软件之一。它快速、可靠并且可通过简单的 API 扩展，将 Perl／Python 等解释器编译到服务器中。
Apache 起初由伊利诺伊大学香槟分校的国家超级电脑应用中心（NCSA）开发。此后，ApacheHttpd被开放源代码团体的成员不断的发展和加强。Apache Http 网站服务器拥有牢靠可信的美誉，已经在全球超过半数的网站中被使用，特别是几乎所有最热门和访问量最大的网站。
Apache 支持许多特性大部分通过编译的模块实现这些特性从服务器端的编程语言支持到身份认证方案。一些通用的语言接口支持 Perl，Python， Tcl，和 PHP。流行的认证模块包括 mod_access，mod_auth 和 mod_digest。 其他的例子有 SSL 和 TLS 支持 （mod_ssl） 代理服务器 (proxy) 模块，很有用的 URL 重写（由mod_rewrite 实现） ，定制日志文件（mod_log_config） ，以及过滤支持
（mod_include 和 mod_ext_filter）。Apache 日志可以通过网页浏览器使用免费的脚本 AWStats 或Visitors 来进行分析。
204. EJB 与 JAVA BEAN 的区别？
解答：Java Bean 是可复用的组件，对 Java Bean 并没有严格的规范，理论上讲，任何一个 Java 类都可以是一个 Bean。但通常情况下，由于 Java Bean 是被容器所创建（如 Tomcat)的，所以 Java Bean应具有一个无参的构造器，另外，通常 Java Bean 还要实现 Serializable 接口用于实现 Bean 的持久性。Java Bean 实际上相当于微软 COM 模型中的本地进程内 COM 组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于 DCOM，即分布式组件。它是基于 Java 的远程方法调用（RMI）技术的，所以 EJB 可以被远程访问（跨进程、跨计算机）。但 EJB 必须被布署在诸如 Webspere、WebLogic 这样的容器中，EJB 客户从不直接访问真正的 EJB 组件，而是通过其容器访问。EJB 容器是 EJB 组件的代理，EJB 组件由容器所创建和管理。客户通过容器来访问真正的 EJB 组件。
205. spring 有几种事务管理，spring 的事务管理接口是什么？
解答：Spring 提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码
量大，存在重复的代码比较多；而声明式的比编程式的更灵活方便。
接口：其中最重要的三个接口：TransactionDefinition、
PlatformTransactionManager 、 TransactionStatus 。 在 Spring 中，事务是通过
TransactionDefinition 接口来定义的。该接口包含与事务属性有关的方法， TransactionDefinition接口中定义了五个表示隔离级别的常量、代表传播行为的常量，TransactionDefinition 中以 int的 值来 表 示 超 时 时 间 ， PlatformTransactionManager.getTransaction( „ ) 方法 返 回 一 个TransactionStatus 对象。 返回的 TransactionStatus对象可能代表一个新的或已经存在的事务（如果在当前调用堆栈有一个符合条件的事务）。TransactionStatus 接口提供了一个简单的控制事务执行和查询事务状态的方法。
206. 介绍一下 springMVC 的工作原理、为什么用 spring？
解答：springMVC 工作原理：
1）.spring mvc 请所有的请求都提交给 DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。
2）.DispatcherServlet 查询一个或多个 HandlerMapping,找到处理请求的 Controller.
3）.DispatcherServlet 请请求提交到目标 Controller
4）.Controller 进行业务逻辑处理后，会返回一个 ModelAndView
5）.Dispathcher 查询一个或多个 ViewResolver 视图解析器,找到ModelAndView 对象指定的视图对象
6）.视图对象负责渲染返回给客户端。为什么用 spring：
AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务（比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词倒置 所表明的，IOC 就像反过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator） Spring 既是一个 。AOP 框架，也是一 IOC 容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。
207. 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 的默认方法。
208. 请简单画出 struts 技术构建 mvc 的流程图
解答
模型
Struts-config.xml
ActionForm
1.初始化
2.HTTP 请求
业务功能类
3.填写 Form
Struts 框架总控制器
Client JavaBean
7.转换 HTTP 请求 4.将请求交给
5.调用后台业务
具体的 Action 处理
到目标响应对象
6.返回目标响 功能类完成商业
8.响应
应对象 逻辑
视图
业务功能控制器
JSP
Action
209. Jdo 是什么?
解答：JDO 是 Java 对象持久化的新的规范，为 java data object 的简称,也是一个用于存取某种数据
仓库中的对象的标准化 API。JDO 提供了透明的对象存储，因此对开发人员来说，存储数据对象完全
不需要额外的代码（如JDBC API 的使用）。这些繁琐的例行工作已经转移到 JDO 产品提供商身上，使
开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO 很灵活，因为它可以在任何数据
底层上运行。JDBC 只是面向关系数据库（RDBMS）JDO 更通用，提供到任何数据底层的存储功能，比
如关系数据库、文件、XML 以及对象数据库（ODBMS）等等，使得应用可移植性更强。
210. 就 WEB2.0 相关信息做一下描述，谈谈你对这些技术概念的认识。
解答：一些 WEB2.0 产品，就可以理解以上观点。
Blog：用户织网，发表新知识，和其他用户内容链接，进而非常自然的组织这些内容。
RSS：用户产生内容自动分发，定阅。
Podcasting：个人视频/声频的发布/定阅。
SNS：blog+人和人之间的链接。
WIKI：用户共同建设一个大百科全书。
从知识生产的角度看，WEB1.0的任务，是将以前没有放在网上的人类知识，通过商业的力量，放到网上去。
WEB2.0 的任务是， 将这些知识通过每个用户的浏览求知的力量 协作工作，把知识有机的组织起来，
在这个过程中继续将知识深化，并产生新的思想火花；从内容产生者角度看，WEB1.0是商业公司为主体把内容往网上搬，而 WEB2.0 则是以用户为主，以简便随意方式，通过blog/podcasting 方式把新内容往网上搬；从交互性看，WEB1.0 是网站对用户为主；WEB2.0 是以 P2P 为主。从技术上看，WEB 客户端化，工作效率越来越高。
我们看到，用户在互联网上的作用越来越大；他们贡献内容，传播内容，而且提供了这些内容之间的
链接关系和浏览路径。在SNS 里面，内容是以用户为核心来组织的。WEB2.0 是以用户为核心的互联网
211. Servlet 是线程安全吗？以下代码中使用 synchronized 关键字的意义是什么？
Synchronized
(aList){
aList.remove (1);
}
解答：默认不是线程安全的，但是 servlet 实现了 SingthreadModel 接口 就能单线程执行。此题中
代码的意思是给 aList 对象加同步锁，保证 aList 对象在多线程任务环境中，每次只能够有一个线程
调用 remove 方法。从而提高对 aList 对象操作的安全性和正确性。
212. JSP 中动态 INCLUDE 与静态 INCLUDE 的区别？
解答：动态 INCLUDE 用 jsp:include 动作实现 <jsp:includepage="head.jsp"/>
它总是会检查所含文件中的变化， 适合用于包含动态页面， 并且可以带参数； 静态 INCLUDE 用 include
伪码实现,它不会检查所含文件的变化，适用于包含静态页面<%@includefile="head.htm" %>
213. Session 的基本原理是什么？
答：Session 对象的原理在于，服务器可以为客户端创建并维护一个所谓的 Session 对象，用于存放
数据。在创建 Session对象的同时，服务器将会为该Session 对象产生一个唯一编号，这个编号称之
为 SessionID，服务器以 Cookie 的方式将 SessionID 存放在客户端。当浏览器再次访问该服务器时，
会将 SessionID 作为 Cookie 信息带到服务器，服务器可以通过该 SessionID 检索到以前的 Session
对象，并对其进行访问。需要注意的是，此时的 Cookie 中仅仅保存了一个 SessionID，而相对较多的
会话数据保存在服务器端对应的Session 对象中，由服务器来统一维护，这样一定程度保证了会话数
据安全性，但增加了服务器端的内存开销。存放在客户端的用于保存 SessionID 的 Cookie 会在浏览
器关闭时清除。我们把用户打开一个浏览器访问某个应用开始，到关闭浏览器为止交互过程称为一个
“会话” 在一个
。 “会话” 过程中，可能会向同一个应用发出了多次请求， 这些请求将共享一个 Session
对象，因为这些请求携带了相同的 SessionID 信息。Session 对象的正常使用要依赖于 Cookie。如果
考虑到客户端浏览器可能出于安全的考虑禁用了 Cookie， 应该使用 URL 重写的方式使 Session 在客户
端禁用 Cookie 的情况下继续生效。
214. jsp 有哪些动作？作用分别是什么？
解答：JSP 共有以下 6 种基本动作：
jsp:include：在页面被请求的时候引入一个文件；
jsp:useBean：寻找或者实例化一个 JavaBean。 ；
jsp:setProperty：设置 JavaBean 的属性。 ；
jsp:getProperty：输出某个 JavaBean 的属性；
jsp:forward：把请求转到一个新的页面；
jsp:plugin：根据浏览器类型为 Java插件生成 OBJECT 或 EMBED 标记
215. Struts 的控制器部分，视图部分包括哪些内容？
解答：
控制器:在 struts 中， 基本的控制器组件是ActionServlet 类中的实例 servelt， 实际使用的 servlet
在配置文件中由一组映射（由ActionMapping 类进行描述）进行定义。对于业务逻辑的操作则主要由
Action、ActionMapping、ActionForward 这几个组件协调完成的，其中 Action 扮演了真正的业务逻
辑 的实 现 者 ， ActionMapping 与 ActionForward 则 指 定 了 不 同 业 务 逻 辑 或 流 程 的 运 行 方 向 。
struts-config.xml 文件配置控制器。
视图：视图主要由 JSP 建立，struts 包含扩展自定义标签库（TagLib） ，可以简化创建完全国际化用
户界面的过程。目前的标签库包括：Bean Tags、HTML tags、Logic Tags、Nested Tags 以及 Template
Tags 等。
216. WEB SERVICE 名词解释。JSWDL 开发包的介绍。JAXP、JAXM 的解释。
解答：
Web Service是基于网络的、分布式的模块化组件，它执行特定的任务，遵守具体的技术规范，
这些规范使得 Web Service能与其他兼容的组件进行互操作；
JAXP(Java API for XML Parsing)定义了在 Java 中使用 DOM, SAX,XSLT 的通用的接口，这样在
你的程序中你只要使用这些通用的接口，当你需要改变具体的实现时候也不需要修改代码；
JAXM(Java API for XML Messaging)是为 SOAP 通信提供访问方法和传输机制的API；
217. 介绍一下 hibernate 的工作原理、优点以及如何优化？
解答：
工作原理：
1)启动 Hibernate 构建 Configuration 实例，初始化该实例中的所有变量 Configuration cfg = new
Configuration().configure();
2).加载 hibernate.cfg.xml 文件至该实例内存,通过hibernate.cfg.xml 文件中的 mapping 节点配置，
加载 hbm.xml 文件至该实例内存;
3). 由上 面 得 到 的 Configuration 实 例 构 建 一 个 SessionFactory 实 例 SessionFactory sf =
cfg.buildSessionFactory();
4).由上面得到的 SessionFactory 实例创建连接 Session s = sf.openSession();
5).由上面得到的 Session 实例创建事务操作接口 Transaction 的一个实例 tx Transaction tx =
s.beginTransaction();
6).通过 Session 接口提供的各种方法操作数据库的访问
7).提交数据库的操作结果 tx.commit();
8).关闭Session 链接 s.close();
优点：
1).对 JDBC 访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2).Hibernate 是一个基于 JDBC 的主流持久化框架，是一个优秀的 ORM 实现。他很大程度的简化DAO
层的编码工作
3).hibernate 使用 Java 反射机制，而不是字节码增强程序来实现透明性。
4).hibernate 的性能非常好， 因为它是个轻量级框架。 映射的灵活性很出色。 它支持各种关系数据库，
从一对一到多对多的各种复杂关系。
优化：
1).使用双向一对多关联，不使用单向一对多
2).灵活使用单向一对多关联
3).不用一对一，用多对一取代
4).配置对象缓存，不使用集合缓存
5).一对多集合使用 Bag,多对多集合使用 Set
6).继承类使用显式多态
7).表字段要少，表关联不要怕多，可以利用二级缓存
218. Hibernate 实现中，load 和 get 方法的区别，find 和 iterate 的区别?
解答：load 和 get 方法的区别：hibernate 对于 load 方法认为该数据在数据库中一定存在，可以放
心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；而对于 get 方法，hibernate
一定要获取到真实的数据，否则返回 null。
find 和 iterate 的区别：find 方法通过一条 Select SQL 实现了查询操作，而 iterate 方法要执
行多条 SelectSQL.iterate 第一次查询获取所有符合条件的记录的 id，然后再根据各个 id 从库表中
读取对应的记录， 这是一个典型的 N+1 次的查询问题， 如果符合条件记录有 10000 条， 就需要执行 10001
条 Select SQL，性能会非常差。
219. JAVA 中如何进行事务的处理？
答：Connection 类中提供了 3 个事务处理方法：
setAutoCommit(Boolean autoCommit):设置是否自动提交事务，默认为自动提交，即为 true，通
过设置 false 禁止自动提交事务；
commit():提交事务；
rollback():回滚事务。
220. Hibernate 有哪 5 个核心接口？
解答：
Configuration接口：配置Hibernate，根据其启动hibernate，创建SessionFactory 对象；
SessionFactory 接口：初始化 Hibernate，充当数据存储源的代理，创建 session 对象，sessionFactory 是线程安全的，意味着它的同一个实例可以被应用的多个线程共享，是重量级、二级缓存；
Session 接口：负责保存、更新、删除、加载和查询对象，是线程不安全的，避免多个线程共享同一个 session，是轻量级、一级缓存；
Transaction 接口：管理事务；
Query 和 Criteria 接口：执行数据库的查询。
221. 什么是 ORM？
解答：对象关系映射（Object—Relational Mapping，简称 ORM）是一种为了解决面向对象与面向关
系数据库存在的互不匹配的现象的技术；简单的说，ORM 是通过使用描述对象和数据库之间映射的元
数据，将 java 程序中的对象自动持久化到关系数据库中；本质上就是将数据从一种形式转换到另外
一种形式。
222. 数据连接池的工作机制是什么?
解答：J2EE 服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。 客户端程
序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池
驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池
驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。
223. 解释四种会话跟踪技术？
解答：隐藏表单域、URL 重写,Cookie、Session。
1）.隐藏表单域：<inputtype="hidden">，非常适合步需要大量数据存储的会话应用。
2）.URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。
3）.Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至在客户端计算机重启后它仍可以保留其值。
4）.Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话
224.Statement,PreparedStatement,CallableStatment 的区别
解答：
区别有以下几点：
1） Statement 是 PreparedStatement 和 CallableStatement 的父类；
2）Statement 是直接发送 Sql 语句到数据库，事先没有进行预编译。PreparedStatement 会将 sql 进行预编译， sql 语句要重复执行时，当 数据库会调用以前预编译好的 sql 语句，所以 PreparedStatement在性能方面会更好；
3）PreparedStatement 在执行 sql 时，对传入的参数可以进行强制的类型转换。以保证数据格式与底层的数据库格式一致。
4）CallableStatement 适用与存储过程的查询表达语句
225. OOAD 中的 Association（联合） 、Aggregation(聚合)、Composition（组合）的区别？
解答： 三者从概念上来讲： Association 是一般的关联， use-a” 有” 的含义。 Aggregation 和 Composition
都有整体和部分的关系，其中Aggregation 中的部分脱离了整体，部分仍然有意义，有”has a”的含义，是共享式的。而Composition 中的部分脱离了整体，部分将没有任何意义，是独占式的。从代码实现的角度上讲：三者都是以属性出现，其中 Association 中作为属性出现时，不需要对其进行强制赋值，只要在使用是对其进行初始化即可。Aggregation 中作为属性出现时，需要在构造器中通过传递参数来对其进行初始化。Composition 中 作为属性出现时，需要在整体的构造器中创建部分的具体实例，完成对其的实例化。
从数据库的层面上来讲：Association 不需要被级联删除，Aggregation不需要被级联删除，
Composition 是需要被级联删除的。
226. 请说出你所知道的线程同步的方法。
解答：wait():使一个线程处于等待状态，并且释放所持有的对象的 lock；
sleep(): 使 一个 正 在 运 行 的 线 程 处 于 睡 眠 状 态 ， 是 一 个 静 态 方 法 ， 调 用 此 方 法 要 捕 捉
InterruptedException 异常；
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某
一个等待状态的线程，而是由JVM 确定唤醒哪个线程，而且不是按优先级；
notityAll():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让
它们竞争。
227. 谈谈对 ClassLoader 的理解？
解答：ClassLoader加载类用的是全盘负责委托机制。所谓全盘负责，即是当一个 classloader 加载
一个 Class 的时候， 这个 Class 所依赖的和引用的所有 Class 也由这个 classloader 负责载入，除非
是显式的使用另外一个classloader 载入； 委托机制则是先让 parent（父） 类加载器 (而不是 super，
它与 parentclassloader 类不是继承关系)寻找，只有在 parent 找不到的时候才从自己的类路径中
去寻找。此外类加载还采用了cache 机制，也就是如果 cache中保存了这个 Class 就直接返回它，如
果没有才从文件中读取和转换成Class，并存入 cache，这就是为什么我们修改了 Class 但是必须重
新启动 JVM 才能生效的原因。
228. 进程和线程分别该怎么理解？
解答：进程是资源分配的基本单位。所有与该进程有关的资源，都被记录在进程控制块 PCB 中。以表
示该进程拥有这些资源或正在使用它们。另外，进程也是抢占处理机的调度单位，它拥有一个完整的
虚拟地址空间。
与进程相对应，线程与资源分配无关，它属于某一个进程，并与进程内的其他线程一起共享进程的资
源。当进程发生调度时，不同的进程拥有不同的虚拟地址空间，而同一进程内的不同线程共享同一地
址空间。
线程只由相关堆栈（系统栈或用户栈）寄存器和线程控制表 TCB 组成。寄存器可被用来存储线程内的
局部变量，但不能存储其他线程的相关变量。
发生进程切换与发生线程切换时相比较，进程切换时涉及到有关资源指针的保存以及地址空间的变化
等问题；线程切换时，由于同不进程内的线程共享资源和地址 空间，将不涉及资源信息的保存和地
址变化问题，从而减少了操作系统的开销时间。而且，进程的调度与切换都是由操作系统内核完成，
而线程则既可由操作系统内 核完成，也可由用户程序进行。
229. 同步和异步有何异同，在什么情况下分别使用他们？请举例说明
解答：如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据
可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。当应用程序在对象
上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异
步编程，在很多情况下采用异步途径往往更有效率。
230. sleep()和 wait()有什么区别？
解答：sleep 是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，
但是监控状态依然保持，到时后会自动恢复。调用 sleep 不会释放对象锁。
wait 是 Object 类的方法，对此对象调用 wait 方法导致本线程放弃对象锁， 进入等待此对象的等待锁
定池，只有针对此对象发出notify 方法（或 notifyAll）后本线程才进入对象锁定池准备获得对象锁
进入运行状态。
231. java 中会存在内存泄露吗？请简单描述。
解答：内存泄露是指系统中存在无法回收的内存，有时候会造成内存不足或系统崩溃。Java 存在内存
泄露。Java 中的内存泄露当然是指：存在无用但是垃圾回收器无法回收的对象。而且即使有内存泄露
问题存在，也不一定会表现出来。自己实现堆栈的数据结构时有可能会出现内存泄露。
232. 什么叫应用程序域？什么是托管代码？什么是强类型系统？什么是装箱和拆箱？什么是重载？
CTS、CLS 和 CLR 分别作何解释？
解答：应用程序域：一种边界，它由公共语言运行库围绕同一应用程序范围内创建的对象建立（即，
从应用程序入口点开始，沿着对象激活的序列的任何位置） 。应用程序域有助于将在一个应用程序中
创建的对象与在其他应用程序中创建的对象隔离，以使运行时行为可以预知。在一个单独的进程中可
以存在多个应用程序域。
托管代码：由公共语言运行库环境（而不是直接由操作系统）执行的代码。托管代码应用程序可以获
得公共语言运行库服务，例如自动垃圾回收、运行库类型检查和安全支持等。这些服务帮助提供独立
于平台和语言的、统一的托管代码应用程序行为。
强类型系统：通过运行时类型识别（RTTI）(Run-TimeType Identification)，程序能够使用基类的
指针或引用来检查这些指针或引用所指的对象的实际派生类型。
装箱、拆箱：从值类型接口转换到引用类型装箱。从引用类型转换到值类型拆箱。
重载：是方法的名称相同。参数或参数类型不同，进行多次重载以适应不同的需要。
CTS：通用语言系统。CLS：通用语言规范。CLR：公共语言运行库。
233. 程序注释的用途有哪些？带注释的程序有什么缺点？
解答：注释可以说明程序，给自己或他人在阅读程序时提供帮助，使程序更容易理解，也就是增强程
序代码的可读性。过多的代码注释会使程序结构变得不清晰。
234. UDP 和 TCP 连接有和异同？
解答：TCP 协议是面向连接的，每个数据包的传输过程是：先建立链路、数据传输、然后清除链路。
数据包不包含目的地址。受端和发端不但顺序一致，而且内容相同。它的可靠性高；UDP 协议是面向
无连接的，每个数据包都有完整的源、目的地址及分组编号，各自在网络中独立传输，传输中不管其
顺序，数据到达收端后再进行排序组装，遇有丢失、差错和失序等情况，通过请求重发来解决。它的
效率比较高
235. 构造器 Constructor 是否可以被继承？是否可以被 Override?
解答：构造器Constructor 不能被继承，因此不能重写Overriding，但可以被重载Overloading。
236. 什么是 java 序列化，如何实现 java 序列化？
解答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流
化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行
读写操作时所引发的问题；
序列化的实现：将需要被序列化的类实现 Serializable 接口， 该接口没有需实现的方法， implementsSerializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如FileOutputStream)来构 造一 个 ObjectOutputStream( 对 象 流 ) 对 象， 接 着 ， 使 用 ObjectOutputStream 对 象 的writeObject(Object obj)方法就可以将参数为 obj 的对象写出(即保存其状态)，要恢复的话则用输入流。
237. 面向对象的特征有哪些方面？
解答：面向对象的特征主要有以下几个方面：
1)抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关
的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个
方面，一是过程抽象,二是数据抽象。
2)继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性
的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，
新类称为原始类的派生类（子类） ，而原始类称为新类的基类（父类） 。派生类可以从它的基类那里继
承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3)封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于
这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的
接口访问其他对象。
4)多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多
态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问
题
238. 接口是否可继承接口? 抽象类是否可实现接口? 抽象类是否可继承实体类?
解答：接口是可以继承接口的并且可以继承多个其它接口；抽象类可以实现接口中的方法；抽象类可
以继承实体类。
239. nonymous Inner Class (匿名内部类) 是否可以 extends(继承)其它类，是否可以 implements(实现)interface(接口)?
解答：匿名内部类是可以继承其它类，同样也可以去实现接口的，用法为：
JButton button = new JButton();
button.addActionListener(newActionListener()
{
public void actionPerformed(ActionEvente){//some mothod...}
});
这样的用法在 swing 编程中是经常使用的，就是因为它需要用到注册监听器机制,而该监听类如果只
服务于一个组件,那么,将该类设置成内部类/匿名类是最方便的。
240. Bit 和 Byte 是什么意思?它们之间有什么关系?
解答：bit 中文名称是位，是用以描述电脑数据量的最小单位。
byte（字节）是计算机信息技术用于计量存储容量和传输容量的一种计量单位 1byte=8bit
241. 你认为 java 与其他（你所了解的）语言相比，有什么优点和缺点?
解答：1). Java 没有预处理指令。（如 C 中的#define ,#include , #ifdef 等）中的常量定义在。C
Java 中用 static final 来取代。
2)． Java 中没有 C 中的全局变量。
3)． Java 中的主类型的 size 是确定的，而 C 中主类型的 size 跟平台相关。
4)． Java 中没有了指针，它使用了类似的句柄来取代指针，但是 Java 中不允许对句柄进行加减，
没有取地址操作符之类的东东。
5)． Java 有垃圾收集机制，不需要自己释放空间。
6)． Java 没有 goto 语句。Java 在 C 提供的控制语句基础上增加了异常处理和标签 break 和
continue 语句。这些可以替代 goto 的作用。
7)． C 要求一个方法或块中使用的所有局部变量的定义在该方法或块的最开始处定义，而 Java
允许这些定义在方法或块的任意地方出现。
8)． Java 不要求在调用一个函数以前已经定义了该函数，可以在调用点后面定义。而 C 有这个要
求。
9)． Java 不支持 C 中的 strut 和 union 类型。Java 支持方法重载。
10)． Java 不支持 C 中的 enum 关键字。
11)． Java 不支持 C 中的 bitfields 能力。
12)． Java 不支持 C 的 typedef。
13)． Java 不支持 C 的方法指针。
14). Java 不支持 C 的可变参数表。
java 和.net 的都不适合做桌面程序,这两个比较适合写 WEB 的程序;
c++比较适合写桌面程序 c++/java 都是强类型的静态预编译型语言。 优点是结构性强，程序可读性好，
开发效率高，适合开发大型应用。就本人的经验而言，java 的开发效率优于 c++，实际上 java 大行
其道的首要因素就是它够简单。java尤其不适合开发桌面程序，GUI的 API 一直都是 java 的弱点；
perl/python 是动态解释型语言。perl 是弱类型的而 python 是强类型的，后者的变量一旦赋值，
就拥有了类型，不能再赋其他类型的值。不象 javascript/perl 可以随便定义。perl 是 unix 下的王
牌工具，在缺乏 IDE 的字符界面下，很好地弥补了 unix；
shell/utility 的不足，并且部分继承了面向对象语言的灵活性。适合用来搭建大程序。
242. 一个 subclass 怎样调用 superclass 中的方法（myMethod）和构造函数?
答：用 super 关键字,子类去调用父类的方法，如：super.myMethod();子类去调用父类的构造函数，
如：super();。
243. 排序都有哪几种方法？用伪代码实现一个快速排序
答：排序的方法有：插入排序（直接插入排序、希尔排序） ，交换排序（冒泡排序、快速排序） ，选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）快速排序的伪代码： 使用快速排序方法对 a[ 0 :n- 1 ]排序从 a[ 0 :n- 1 ]中选择一个元素作为 middle，该元素为支点； 把余下的元素分割为两段 left 和 right，使得 left 中的元素都小于等于支点， right 而中的元素都大于等于支点；
递归地使用快速排序方法对left 进行排序；递归地使用快速排序方法对 right 进行排序；所得结果为 left + middle + right。
243. String a=null; if (a!=null &&a.length()>10) {...}上面面的代码，如果你用“&”替换“&&”将发生什么错误？
答：会抛出空指针异常；&&会短路，只要遇到 boolean 值为 false 就不会再往后执行了；而&则是会把两边的运算都执行完。
三 编程题（30）
1.编程实现：二分搜索算法
解答：
public class SearchTest {
/** 被搜索数据的大小 */
private static final int size = 5000000;
public static void main(String[] args) {
long[] data = new long[size];
// 添加测试数据
for (int k = 0; k < data.length; k++) {
data[k] = k;
}
// 要查找的数据
long target = 4970002;
binaryFindTest(data, target);
}
/**
* 二分搜索算法实现
*
* @param data
* 数据集合
* @param target
* 搜索的数据
* @return 返回找到的数据的位置，返回-1表示没有找到。
*/
public static int binaryFind(long[] data, long target) {
int start = 0;
int end = data.length - 1;
while (start <= end) {
int middleIndex = (start + end) / 2;
if (target == data[middleIndex]) {
return middleIndex;
}
if (target >= data[middleIndex]) {
start = middleIndex + 1;
} else {
end = middleIndex - 1;
}
}
return -1;
}
/**
* 二分搜索测试
*
* @param data
* 数据集合
* @param target
* 搜索的数据
*/
public static void binaryFindTest(long[] data, long target) {
long start = System.nanoTime();
int result = binaryFind(data, target);
long end = System.nanoTime();
System.out.println("binary search position：" + result);
System.out.println("binary search time：" + (end - start));
}
}
2.编程实现：线程 A 向队列 Q 中不停写入数据，线程 B 从队列 Q 中不停读取数据（只要 Q 中有数据）
解答：
接口中有两个一个是向队列中写push 方法 一个是从队列中读。
public interface StackInterface
{
public void push(int n);
public int[] pop();
}
上边接口的实现类。
public class SafeStack implementsStackInterface {
private int top = 0;
private int[] values = new int[10];
private boolean dataAvailable = false;
public void push(int n) {
synchronized (this) {
while (dataAvailable) // 1
{
try {
wait();
} catch (InterruptedException e){
// 忽略 //2
}
}
values[top] = n;
System.out.println("压入数字" + n + "步骤 1 完成");
top++;
dataAvailable = true;
notifyAll();
System.out.println("压入数字完成");
}
}
public int[] pop() {
synchronized (this) {
while (!dataAvailable) // 3
{
try {
wait();
} catch (InterruptedExceptione) {
// 忽略 //4
}
}
System.out.print("弹出");
top--;
int[] test = { values[top], top };
dataAvailable = false;
// 唤醒正在等待压入数据的线程
notifyAll();
return test;
}
}
}
读线程
public class PopThread implements Runnable
{
private StackInterface s;
public PopThread(StackInterface s)
{
this.s = s;
}
public void run()
{
while(true)
{
System.out.println("->"+s.pop()[0] + "<-");
try {
Thread.sleep(100);
}
catch(InterruptedException e){}
}
}
}
写线程
public class PushThread implements Runnable
{
private StackInterface s;
public PushThread(StackInterface s)
{
this.s = s;
}
public void run()
{
int i = 0;
while(true)
{
java.util.Random r = new java.util.Random();
i = r.nextInt(10);
s.push(i);
try {
Thread.sleep(100);
}
catch(InterruptedException e){}
}
}
}
3.编程实现：使用 Socket 经行网络通信时，客户端和服务器端流程。
解答：
服务器，使用ServerSocket 监听指定的端口，端口可以随意指定（由于 1024 以下的端口通常属于保
留端口，在一些操作系统中不可以随意使用，所以建议使用大于 1024 的端口） ，等待客户连接请求，
客户连接后，会话产生；在完成会话后，关闭连接。
客户端，使用 Socket 对网络上某一个服务器的某一个端口发出连接请求，一旦连接成功，打开
会话；会话完成后，关闭Socket。客户端不需要指定打开的端口，通常临时的、动态的分配一个 1024
以上的端口。
4.编写代码实现同一平面内两圆是否碰撞，其中：
第一个圆圆心坐标为(x1,y1)，半径是 r1，第二个圆圆心坐标为(x2,y2)，半径是 r2。
方法声明如下：
boolean collisWith(int x1,inty1,int r1,int x2,int y2,int r2){}
解答：
boolean collisWith(int x1, int y1, int r1,int x2, int y2, int r2) {
boolean flag=false;
int num1=(x1-x2)*(x1-x2);
int num2=(y1-y2)*(y1-y2);
int num3=num1+num2;
double distance=Math.sqrt(num3);
if(distance<=（r1+r2）){
flag=true;
}
return flag;
}
5.判断一个 int 数组中的元素是否存在重复，方法声明如下：
boolean isRepeat(int[] m){ }
解答：
public boolean isRepeat2(int[] m){
Set h =new HashSet(m.length);
for (int i = 0; i < m.length; i++) {
h.add(new Integer(m[i]));
}
if (h.size()==m.length ){
return false;
}else {
return true;
}
}
6.用递归方法实现正序显示数组元素。例如 String[] s = {“a”,”b”,”c”,”d”};
方法声明如下：
void print(String[] s,int i){ }
解答：参数 i 是指打印 string 数组的起始位置，原理是正序打印 s 从第 0 个开始的所有字符串，等
价于先打印第 0 个，在打印 s 中从第一个开始的所有字符串，如此递归
void print(String[] s, int i) {
if ((i >= 0) && (i < s.length)) {
System.out.print(s[i]);
i++;
print(s, i);
}
}
7.请写出求 n！的算法。
解答：
public class Factorial {
public static void main(String[] args) {
long n = 6;
System.out.println(doFactorial(n));
}
public static long doFactorial(long n) {
if (n < 1) {
System.out.println("ERROR");
return 0;
} else if (n == 1 || n == 2) {
return n;
} else {
return n * doFactorial(n - 1);
}
}
}
8.在当前的 JSP 网页里，提交用户名和密码，提交给 post . jsp, post . jsp 打印出用户名和密码
并返回给浏览器。请写出post . jsp
解答：
假设页面用户名和密码在login.jsp 里，login.jsp 页面代码如下：
<form action=”post.jsp”method=”post”>
<input type=”text” name=”userName”>
<input type=”password” name=”pwd”>
<input type=”submit”>
</form>
post.jsp 页面代码：
<%
StringuserName=request.getParameter(“userName”);
String pwd=request.getParameter(“pwd”);
out.println(“用户名：”+userName+”,密码：”+pwd);
%>
9.编写一个字符界面的 Java Application 程序，接受用户输入的 10 个整数，并输出这 10 个整数的最大值和最小值。
解答：采用了冒泡进行排序
import java.util.Scanner;
import java.util.Scanner;
public class MaxAndMin {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
int next = scanner.nextInt();
arr[i] = next;
}
int[] after=Arrays.sort(arr);
System.out.println("最小值："+after[0]+",最大值："+after[arr.length-1]);
}
}
10.写一个排序算法 1-100 随机数字 进行排序 要求效率。
解答：
public class Sort {
// 选择排序方法
public static void selectionSort(int[] number) {
for (int i = 0; i < number.length - 1; i++) {
int m = i;
for (int j = i + 1; j < number.length; j++) {
if (number[j] < number[m])
m = j;
}
if (i != m)
swap(number, i, m);
}
}
//用于交换数组中的索引为 i、j 的元素
private static void swap(int[] number, int i, int j) {
int t;
t = number[i];
number[i] = number[j];
number[j] = t;
}
public static void main(String[] args) {
// 定义一个数组
int[] num = new int[100];
for(int i=0;i<num.length;i++){
num[i]=(int)(Math.random()*100)+1;
}
// 排序
selectionSort(num);
for (int i = 0; i < num.length; i++) {
System.out.println(num[i]);
}
}
}
11.冒泡排序:依次比较相邻的两个数,将大数放在前面,小数放在后面。
第一趟结束,在最后的数必是所有数中的最小数。重复以上过程,直至最终完成排序。由于在排序过程中总是大数往前放,小数往后放,相当于气泡往上升,所以称作冒泡排序。请用 JAVA 语言编写一个完成冒泡排序算法的程序。
解答:
int[] bubbleSort(int before[]) {
int t;
for (int i = 0; i < before.length; i++) {
for (int j = 0; j < before.length - i- 1; j++) {
if (before[j] > before[j +1]) {
t = before[j];
before[j] = before[j + 1];
before[j + 1] = t;
}
}
}
return before;
}
12.写出一段 socket 通讯（客户端）的代码，功能描述如下：
a)客户端发起 socket 通讯，报文结构为报文号（3 位）+用户名（5 位）+密码（8 位）+ 结束符（固定为 END） 。此处报文号为 100
b)服务端收到后返回应答报文，报文结构为报文号（3 位）+验证结果（2 位）+结束符（固定为 END）此处报文号为 101
c)Socket 服务器 ip 为 192.168.0.2，端口号为 9999
解答：
客户端代码：
Socket sk = newSocket("192.168.0.2",9999);
OutputStream os = sk.getOutputStream();
PrintWriter pw = new PrintWriter(os,true);
pw.write("100stone888888END");
pw.close();
sk.close();
服务器端代码：
ServerSocket vk = new ServerSocket(9999);
Socket sk = vk.accept();
OutputStream os = sk.getOutputStream();
PrintWriter pw = new PrintWriter(os,true);
pw.write("101oldEND");
pw.close();
sk.close();
13.编写函数 insert(String str)，将字符串”a,123;b,456;c,789”置入 HashMap 中。
解答：
import java.util.HashMap;
public class HashMapDemo {
HashMap<String,String> map=new HashMap<String,String>();
public void insert(String str){
map.put("a", str);
}
public static void main(String[] args) {
HashMapDemo demo=new HashMapDemo();
demo.insert("a,123;b,456;c,789");
}
}
14.有一数组 a[1000]存放了 1000 个数,这 1000 个数取自 1-999, 且只有两个相同的数,剩下的 998个数不同, 写一个搜索算法找出相同的那个数的值（请用 C# or JAVA 编程实现，注意空间效率和时
间效率尽可能优化）
解答：
import java.util.Arrays;
public class SearchDemo {
/** 被搜索数据的大小 */
private static final int size = 1000;
public static void main(String[] args) {
int[] data = new int[size];
// 添加测试数据
for (int k = 0; k < data.length; k++) {
data[k] = k + 1;
}
data[999] = 567;
result(data);
}
/**
* 调用分搜索算法的方法实现查找相同元素
*@param data
*/
public static void result(int data[]){
Arrays.sort(data);
for (int i = 0; i < data.length; i++) {
int target = data[i];
data[i] = 0;
int result = binaryFind(data, target);
if (result != -1) {
System.out.println("相同元素为："+data[result]);
break;
}
}
}
/**
* 二分搜索算法实现
*
*@param data
* 数据集合
*@param target
* 搜索的数据
*@return 返回找到的数据的位置，返回-1表示没有找到。
*/
public static int binaryFind(int[] data, int target) {
int start = 0;
int end = data.length - 1;
while (start <= end) {
int middleIndex = (start + end) / 2;
if (target == data[middleIndex]) {
return middleIndex;
}
if (target >= data[middleIndex]) {
start = middleIndex + 1;
} else {
end = middleIndex - 1;
}
}
return -1;
}
}
15.下面是一个由*号组成的 4 行倒三角形图案。要求：1、输入倒三角形的行数，行数的取值 3-21 之，对于非法的行数，要求抛出提示“非法行数！；2、在屏幕上打印这个指定了行数的倒三角形。
”
*******
*****
***
*解答：
import java.util.Scanner;
public class Lines {
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
int lines = scanner.nextInt();
if (lines > 3 && lines < 21) {
for (int i = lines-1; i >= 0; i--) {
for (int z = 0; z <= i * 2;z++) {
System.out.print("*");
}
System.out.print("\n");
}
}else{
System.out.println("非法行数！");
}
}
}
16.现有一个 32 位的整型变量 value 和一个有 32 个元素的数组 a[32]，要求：
1、对 value 随机赋值；
2、让数组 a[n]的值等于 value“位 n”的值，0<=n<=31。举例：如果 value 的“位 0”(Bit0)=0，那么 a[0]=0；如果 value 的“位 10”(Bit10)=1，那么 a[10]=1。
解答：
public class Foo {
public static void main(String[] args) {
//产生随机数
int random = (int) (Math.random() * Integer.MAX_VALUE + 1);
//转成二进制字符串
String str=Integer.toBinaryString(random);
//转成二进制时最前面的零被省略，补上省略的 0
if(str.length()<32){
for(int j=0;j<=32-str.length();j++){
str="0"+str;
}
}
//给数组赋值
int[] a=new int[32];
for(int i=0;i<str.length();i++){
a[i]=Integer.parseInt(String.valueOf(str.charAt(i)));
System.out.println("a["+i+"]="+a[i]);
}
}
}
17.现有1~100 共一百个自然数，已随机放入一个有 98 个元素的数组 a[98]。要求写出一个尽量简单的方案，找出没有被放入数组的那 2 个数，并在屏幕上打印这 2 个数。注意：程序不用实现自然数随
机放入数组的过程
答：
int[] b = new int[]{....存入 98 个随机的 1~100 的整数};
int[] a = new int[100];
for(int t : b)
a[t-1]=t;
for(int t=0; t < a.length; t++)
if(a[t]==0)
System.out.println(t+1);
18. 实现函数 public String[ ] array(List list)，其中参数 list 中元素类型为字符串
解答：
public String[] array(List list) {
String[] elementData = new String[list.size()];
for(int i=0;i<list.size();i++){
elementData[i]=(String)list.get(i);
}
return elementData ;
}
19．创建类 Person，其中存储的成员数据为:age(int),sex(boolean),weight(int)，至少有一个构造
函数可以初始化这三个属性值，同时提供获取这三个属性值的 public 方法
解答：
public class Person {
private int age;
private boolean sex;
private int weight;
public Person() {
}
public Person(int age, boolean sex, intweight) {
this.age = age;
this.sex = sex;
this.weight = weight;
}
public int getAge() {
return age;
}
public boolean isSex() {
return sex;
}
public int getWeight() {
return weight;
}
}
20．设计线程类 WorkerThread，其构造函数接受一个 message 字符串作为参数，把该字符串打印到
console 上，同时，在 WorkThread 的 main 函数中启动该线程。
解答：
public class WorkerThread extends Thread {
public WorkerThread(String message) {
System.out.println(message);
}
public static void main(String[] args) {
new WorkerThread("hello world!").start();
}
}
21.写一个函数去掉一个字符串中单词间多余的空格，使得相邻两个单词间有且只有一个空格。例如当 输入 字 符 串 是 “Hello!_ _Game_programming_ _world!”时 ， 调 用 该 函 数 后 字 符 串 变 为
“Hello!_Game_programming_world!”。
解答：
/**
* 去除字符串中多余的空格
*
* @param s
* 需要处理的字符串
* @return 处理后的字符串
*/
public String trimSpace(String before) {
String temp= "" + before.charAt(0);
for (int i = 1; i < before.length(); i++) {
char c = before.charAt(i);
// 如果当前字符是空格
if (c == ‘ ‘) {
// 判断前一个不是是空格则添加，否则不添加
if (before.charAt(i - 1) != ‘‘) {
temp += c;
}
} else {
temp += c;
}
}
return temp;
}
22. 编写一个程序，用来计算 1 到 100 间所有整数的和是多少？
解答：
public static void GetSum()
{
int sum = 0;
for(int i=1;i<=100;i++)
{
sum+=i;
}
System.out.println("和为："+sum);
}
23.请简单写出用 JAVA 连接 Oracle 数据库，并执行一条/SQL 语句。只需要写关键几条语句即可（ /SQL语句：SELECT*FROMt_users WHERE users_id=‘1111’ ）
解答：
Class.forName("oracle.jdbc.OracleDriver");
String url = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";
String user = "scott";
String password = "tiger";
Connection con = DriverManager.getConnection(url, user, password);
Statement stm = con.createStatement();
ResultSet rs = stm
.executeQuery("SELECT*FROM t_users WHERE users_id=‘1111‘");
while (rs.next()) {
// 取值
}
rs.close();
stm.close();
con.close();
24.在 web 应用开发过程中经常遇到输出某种编码的字符，如从 GBK 到 iso8859-1 等，如何输出一个某种编码的字符串？
public static String translate(String str) {
String tempStr = "";
try {
tempStr = new String(str.getBytes("ISO-8859-1"),"GBK");
tempStr = tempStr.trim();
} catch (Exception e) {
System.err.println(e.getMessage());
}
return tempStr;
}
25. 请写出一个公用方法，输入 String 返回该串是否含有非空字符,并写出 junit 的测试用例
答：
public class TestString {
public static boolean hasBlank(String str) {
if (str.endsWith("") || str.startsWith("")) {
return false;
} else {
String[] strs = str.split("");
if (strs.length == 1) {
return false;
}
}
return true;
}
@Test
public void testFun() {
System.out.println(TestString.hasBlank("test"));
}
}
26.JAVA 实现一种排序
答：用插入法进行排序代码如下
package com.tarena;
import java.util.*;
class InsertSort
{
ArrayList list;
public InsertSort(int num,int mod)
{
list = new ArrayList(num);
Random rand = new Random();
System.out.println("The ArrayList SortBefore:");
for (int i=0;i<num ;i++ )
{
list.add(newInteger(Math.abs(rand.nextInt()) % mod + 1));
System.out.println("list["+i+"]="+list.get(i));
}
}
public void SortIt()
{
Integer tempInt;
int MaxSize=1;
for(int i=1;i<list.size();i++)
{
tempInt = (Integer)list.remove(i);
if(tempInt.intValue()>=((Integer)list.get(MaxSize-1)).intValue())
{
list.add(MaxSize,tempInt);
MaxSize++;
System.out.println(list.toString());
}
else
{
for (int j=0;j<MaxSize ;j++ )
{
if(((Integer)list.get(j)).intValue()>=tempInt.intValue())
{
list.add(j,tempInt);
MaxSize++;
System.out.println(list.toString());
break;
}
}
}
}
System.out.println("The ArrayList SortAfter:");
for(int i=0;i<list.size();i++)
{
System.out.println("list["+i+"]="+list.get(i));
}
}
public static void main(String[] args)
{
InsertSort sort = new InsertSort(10,100);
sort.SortIt();
}
}
27. 编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如"我 ABC"4，应该截为"我 AB"，输入"我 ABC 汉 DEF"，6，应该输出为"我ABC"而不是"我 ABC+汉的半个"。
答：
package com.tarena;
public class SplitString {
String SplitStr;
int SplitByte;
public SplitString(String str, int bytes) {
SplitStr = str;
SplitByte = bytes;
System.out.println("The String is:" + SplitStr +";SplitBytes="
+ SplitByte);
}
public void SplitIt()
{
int loopCount;
loopCount=(SplitStr.length()%SplitByte==0)?(SplitStr.length()/SplitByte):(SplitStr.leng
th()/SplitByte+1);
System.out.println("Will Split into "+loopCount);
for (int i=1;i<=loopCount ;i++ )
{
if (i==loopCount){
System.out.println(SplitStr.substring((i-1)*SplitByte,SplitStr.length()));
} else {
System.out.println(SplitStr.substring((i-1)*SplitByte,(i*SplitByte)));
}
}
} public static voidmain(String[] args) {
SplitString ss = new SplitString(
"test 中 dd 文 dsaf 中男大 3443n 中国 43 中国人 0ewldfls=103", 4);
ss.SplitIt();
}
}
28. 编写 程 序 将 由 数 字 及 字 符 组 成 的 字 符 串 中 的 数 字 截 取 出 来 并 按 顺 序 输 出 ， 例 如 ：
“ABC137GMNQQ2049PN5FFF”输出结果应该为 01234579
答：
package com.tarena;
import java.util.Arrays;
public class NumberSplitChar {
public static void main(String[] args) {
String str="ABC137GMNQQ2049PN5FFF";
char[] beforechars=str.toCharArray();
char[] afterchars=new char[beforechars.length];
int j=0;
for(int i=0;i<beforechars.length;i++){
if(beforechars[i]>=‘0‘ && beforechars[i]<=‘9‘){
afterchars[j++]=beforechars[i];
}
}
Arrays.sort(afterchars);
for(int i=(afterchars.length-j);i<afterchars.length;i++){
System.out.print(afterchars[i]);
}
}
}
29. 请用 JAVA 实现两个类，分别实现堆栈（Stack)和队列（Queue）操作。
答：public classMyStack {
private List list;
public MyStack(){
list = new ArrayList();
}
public boolean isEmpty(){
return list.size() == 0;
}
public void push(Object obj){
list.add(obj);
}
public Object pop(){
if(list.size()>0){
Object obj = list.get(list.size()-1);
list.remove(list.size()-1);
return obj;
}else{
return null;
}
}
public int getNumber(){
return list.size();
}
}
class IntegerQueue {
public int[] integerQueue;// 用来当队列
public int tail;// 队尾
public int size;// 队的长度，也可以设置一个默认值，溢出时从新申请
public IntegerQueue(int size) {
integerQueue = new int[size];
this.size = size;
tail = 0;
}
public void inQueue(int i) {
if (tail < size) {
this.integerQueue[tail] = i;
tail++;
} else {
System.err.println("溢出啦！");
}
}
public int outQueue() {
if (tail >= 0) {
int tmp = this.integerQueue[tail];
tail--;
return tmp;
} else {
System.err.println("队列为空！");
throw new RuntimeException();
}
}
}
30. 假定屏幕的像素宽度为 screenWidth，写一个函数计算一个字符串需要分成几行显示。
要求：
1）、每行应尽可能多地显示字符，但不能有字符部分或完全显示在屏幕外。超过部分的字符换下一行显示。
2）、每个字符的像素宽度不一样，每个字符的像素宽度不一样。用 int GetCharWidth(char c)获得每
个字符的像素宽度。
/**
* 计算一个字符串可以分多少行进行显示
*
*@param s
* 原始字符串
*@param screenWidth
* 屏幕宽度
*@return 行数
*/
int calcLineNum(String s, int screenWidth){
int length = 0;
// 行数
int n = 0;
// 统计长度
for (int i = 0; i < s.length(); i++) {
// 当前字符的宽度
int charLen = GetCharWidth(s.charAt(i));
// 总长度增加
length += charLen;
// 如果达到屏幕宽度
if (length > screenWidth) {
n++; // 行数+1
length = charLen; // 重新计算长度
}
}
// 最后一行处理
if (length > 0) {
n++;
}
return n;
}
基本信息：姓名 不写籍贯户口
姓名 电话电子邮箱写一块 年龄和性别在一块
求职意向：
教育背景
掌握技能corejava 框架 java web 数据库 服务器
项目经历
实习经历
获奖情况
个人评价
www.java.job.cn
www.cxy.job.com
插入排序算法：
publicstatic void injectionSort(int[] number) {
// 第一个元素作为一部分，对后面的部分进行循环
for (int j = 1; j < number.length; j++) {
int tmp = number[j];
int i = j - 1;
while (tmp < number[i]) {
number[i + 1] = number[i];
i--;
if (i == -1)
break;
}
number[i + 1] = tmp;
}
}
选择排序的算法
/** 选择排序: 每轮选择一个最小的交换到前面*/
public static void selectionSort(int[] ary) {
for (inti = 0; i < ary.length - 1; i++) {
for(int j = i + 1; j < ary.length; j++) {
if(ary[i] > ary[j]) {
intt = ary[j];
ary[j] = ary[i];
ary[i] = t;
}
}
}
}
}
冒泡算法进行数组的排序
Class BubbleSort{
Publicstatic int[] sort(int[] array){
Int temp=0;
For(int i=0;i<array.length:i++){
For(int j=array.length-1;j>I;j--){
If(array[j]<array[j-1]){
Temp=array[j];
Array[j]=array[j-1];
Array[j-1]=temp;
}
}
}
Return array;
}
}
栈的实现代码
Public class mystack{
PrivateList list;
Publicmystack(){
list=new ArrayList();
}
Public Boolean isEmpty(){
Return list.size==0;
}
Public void push(Object o)
List.add(o);
}
Public object pop(){
If(list.size()>0){
Object obj=list.get(list.size()-1);
List.remove(list.size（）-1);
Return obj;
}else{
Return null;}
}
Public int getNumber(){
Return list.size();
}
}
堆的的实现
Public class IntegerQueue{
Public int[] integerQueue;
Public int tail;
Public int size;
Public IntegerQueue(int size){
Integerqueue=new int[size];
This.size=size;
Tail=0;
}
Public void in Queue(int i){
If(tail<size){
This.integerQueue[tail]=I;
Tail++;
}else{
System.err.println(“溢出啦！”);
}
}
Public int outQueue(){
If(tail>=0){
Int tmp=this.integerQueue[tail];
Tail--;
Return tmp;
}else{
System.err.println(“队列为空”);
Throw new RuntimeException()；
}
}
}
Bit 和byte是什么意思呢 他们之间的有什么关系呢
Bit中文名称是位，用以描述电脑数据量的最小单位
Byte字节是计算机信息技术用于存储容量和传输容量的最小单位。
1byte =8bit
排序都有哪几种方法？请举例
冒泡排序 插入排序二叉树排序 快速排序 选择排序 基数排序
最有校的方法算出2乘以8
2《《3
数组和向量的区别是数组只能放指定类型的数据，向量可以放集合和对象向量可以动态调整大小，不过他的实现方式也是数组。数组一旦创建就不能申请了大小除非销毁重建，否则大小无法改变。
对属于为N个数进行快速排序算法的平均时间复杂度是：O（n2）
Int n=10;
Int a=1,a2=1,a3=0;
For(int i=0;i<n;i++){
If(i<2)
System.out.println(1);
Else{
A3=a1+a2;
A1=a2;
A2=a3;
Sysem.out.println(a1+a2);
}
}
Select * from user where username in(selectusername from user group by
Username having count(username)>1)
Alter table a add(policyNo, varchar2(25));
create table mytemp_ning(id number(4));
--增加列，只能增加在最后一列。
alter table mytemp_ning add (namechar(10));
alter table mytemp_ning add (passwordchar(4));
--修改列名password为pwd
alter table mytemp_ning
rename column password to pwd;
--修改列的数据类型：pwd char(8)
alter table mytemp_ning
modify (pwd char(8));
--删除列pwd
alter table mytemp_ning
drop column pwd;
创建索引
Create index a_index ona(policyNo,StartDate);
Update s setClassCode=”01” whereStartDate>to_date(“2007-02-01”,
“yyyy-MM-dd”) and UnderWriterFlag in(1,3)and RiskCode=null;
约束条件是
Not null primary key foreign key uniquecheck
Imp oracle 的数据库导入的命令是
imp Oracle mysql Db2 SQLServer
User :create table user（id number(10) primary key,
Uname varchar2(20) not null unique;
Comment create table comment(id number(10)
Comment_id number(20) not null unique,
Titlevarchar2(20) not null,
Commentvarchar2(255) not null,
Foreign key(id) reference user(id)
);
Create table replay(id number(10),
Comment varchar2(255) not null,
Foreign key(id) referencecomment(comment_id)
因为此应用所要存储的数据量比较大，所以为了避免数据的冗余，表的设计依托于第三范式。
设置权限系统
Java代码的安全性
类加载器加载程序运行所需要的所有类，他通过区分本机的文件系统的类和网络系统导入的类增加安全性，这可以限制任何的特洛伊木马程序，因为本机类总是先被加载一旦所有的类被加载完，执行文件的内存划分就固定了，这个时候特定的内存地址被分配到对应的符号引用。
Java中的继承
Java中的继承都是单继承关系，也就是说一个类只能既有一个父类，但是可以同时实现多个接口;对于接口本身而言，可以继承多个接口的了，这样做的目的就是为了阻止因为多继承而造成的业务对象本身的可读性的降低。
Java中的垃圾回收
Gc是垃圾回收的意思，内存处理是变成人员容易出现问题的地方，忘记或者错误的回收会导致程序或系统的不稳定甚至崩溃，java提供的Gc功能可以自动的检测对想是否超过作用域从而达到自动回收内存的目的，java语言没有提供释放已分配内存示操作方法。
内存管理不是管理员担心的，因为垃圾收集器会自动进行管理。要请求垃圾回收，可以调用下面的方法之一：System.gc();或Runtime.getRuntime().gc();
输入字符串，返回该串是否为空。
Public static Boolean nullString (Stringtemp){
Int len=temp.split(“ ”).length;
If(len>1||temp.length()!=temp.trim().length()){
Return ture;
}
Return false;
}
Import org.junit.Test;
public class Tests{
public void testFun(){
system.out.println(TestString.nullstring（”hah ”）;
}
}
手工转码方式
Public staticString s(String str){
String mstr=””;
Try{
String mstr=newString(str.getBytes(“ISO-8859-1”),”GBK”);
M=mstr.trim();
}catch(Exception e){
System.out.println(e.getMessage());
}
Return M;
}
单例模式 主要是只会new 一个对象，而且还要隐藏构造方法
Public class singleton{
Private static Singleton sin=null;
Static {
Sin=new Singleton();
}
Public static Singleton init(){
Return sin;
}
}
机器输入指令的格式是java Myclass 1 2 3 4
单例模式：设计系统的时候，通常希望控制对象的用法，防止用户复制对象对象或建立新的实例。例如：你可以使用它创建一个连接池，每次程序需要往数据库里面写入内容时候才创建一个新的连接的做法并不明智。或者一个或者是组连接就可以使用Singleton模式的实例化。
工厂模式：主要是隐藏了实现的细节，用户不用去关心对象是怎么去创建出来的。
代理模式：对已有的方法进行使用的时候出现需要对原有的方法进行或者修改，这时候有两种改进选择：修改原有方法来适应现在的方法。或者使用一个第三者方法来调用原有的方法并且对方法产生的结果进行一定的控制。第一种是明显违背了对扩展开放，对修改关闭的开闭原则。而且在原来的方法中修改可能使用原来的类的功能变得模糊好多元化而是使用第二种方式可以将功能划分的更加清晰，有助于后面的维护。
基本数据类型有：int Boolean byte short long float double char
String 不是基本的数据类型，因为String类是final的，所以不能够被继承的饿了
Round方法返回与参数最接近的长整数
String s=new String(“xyz”):创建几个string object
创建两个，一个在堆内存（通过New的到） 另个是在常量池（xyz）对象。
Char型嫩不能储存一个中文的汉字，为啥呢
答，能够定义成为一个中文，因为java中以Unicode编码，一个char站16字节，所以放一个中文是没有问题的了。
Switch可以作用在char short byte int 类型上 还可以作用在枚举类型上的了
面向对象的特征有哪些方面
抽象：抽象就是忽略一个主题中与当前目标无关的哪些方面，以便更充分的注意与当前目标有关的方面，抽象并不算了解全部的问题。而是其中的一部分，暂时不用部分细节，抽象包括两个方面，一是过程的抽象，而是数据的抽象:
继承：继承是一种连接类的层次模型，并且鼓励类的重用，他提供了一种明确的表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程成为继承。新类继承了原始类的方法新类成为原始类的子类，原始类成为新类的父类，派生类可以从他的父类那里继承方法和实例变量，并且类可以修改或者是增加新的方法使之更适合特殊的需要。
封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面型对象的计算始于这个基本的概念，既现实世界可以被描述成一系列完全自治，封装的对象，这些对象通过一个受保护的借口访问其他的对象。
多态性：多态性是指允许不同的类的对象对同一个消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活，抽象，行为共享，代码共享的优势，很好的解决了应用函数同名的问题。
简述abstractclass和interface的区别。
接口是抽象类的变体，新型多继承性可以通过实现这样的接口而获得，接口中的所有的方法都是抽象的，所有的成员变量都是publicstaticfinal的。一个类可以实现多个接口，当类实现特殊接口时，它定义所有的这种接口的方法。然后该接口的类的对象上调用接口的方法，由于有抽象类，它允许使用接口名作为应用变量的类型。通常的动态联编将生效，引用可以转换到接口类型或者接口的类型的转换，
声明方法的存在而不去实现他的类被叫做抽象类，它用于要创建一个体现某些基本行为的的类，并为该类的声明方法，但不能在该类中实现类的情况，不能创建acstract，然而可以创建一个变量。其类型是一个抽象类，并指向具体的子类的一个实例，不能有抽象构造的函数或者不能有抽象构造函数或抽象静态方法，acstract类的子类为他们父类
的
我的总结是：抽象类是声明了方法而没有去实现的类叫做抽象类，不能创建抽象类的实例但是可以定义变量指向子类的实例，然而还可以不全部实现抽象类的方法这样子类还是抽象类。接口呢可以实现多继承和多实现但是必须全部实现里面的抽象方法。
答;方法的重写和重载时java多态性的体现，重写是父类与子类之间的多态性的一种体现。重载是一个类中多态性的实现，如果在子类继承父类的时候定义了和父类相同的方法名字和参数类型，我们说该方法被重写子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被屏蔽。如果在一个类中定义多个同名的参数他们或有不同的参数个数或者有不同的参数类型，则称为方法的重载。重载的方法时可以改变返回值的类型。
请写出十种以上你知道的java开源软件，并用一句话说明功能。
Hibernate 持久化框架，他对jDBC、进行了非常轻量级的封装
Struts是一个基于sun j2ee平台的mVC框架主要是采用servlet和JSp技术来实现的。
Spring 是个解决了许多在j2ee开发中的常见问题的强大框架
Tomcat 是一种servlet 和struts的框架的web服务器
Webwork组件化和代码重用拉出式MVC模式j2ee web 框架
Rose 系统分析和设计的工具
ANT：用于辅助开放
eClipse IDe集成开发工具 IDE开发工具
面向对象的缺点是：无法处理更加复杂的逻辑，代码的执行效率比较低。
值类型和应用类型的区别
值类型是指他在自己的内存中分配存储数据就是值类型 应用类型的值指向存储数据的其他内存位置的指针其他位置的指针
值类型包括所有的数字数据类型 所有的结构，即使其成员是引用类型枚举
引用类型包括String 所有的数组，即使其元素是值类型和类类型
推出双重循环的可以用哪些语句呢？
Loop1;for(;;){
For(;;){
Break loop1;
}
}
Uml 统一建模语言
ANT构建文件build.xml可以放在位置是：工程根目录
运行ant需要设置的环境ANT_HOME JAVA_HOME PATH
把一个Array复制到ArrayList里面去()
New ArrayList(Arrays.asList(new String[]{“”,””,””}));
HashMap 与TreeMap 的区别
Hashmap 通过Hashcode对其内容进行快速查询，而Treemap中的所有元素都保持着
某种特定的顺序，如果你需要得到一个有序的结果，就应该使用TreeMap
HashMap中元素的排序顺序是不固定的
Hashmap和hashtable的区别
二者都实现了map接口，是将惟一键映射到特定的直上区别在于
Hashmap没有排序并且允许一个空值键和多个空值而hashtable不允许
Hashmap把hashtable中的contains方法去掉了改成containsvalue和cntains因为contains方法容易让人误解：
Hashtable继承自dictionary类，hashMap是Map接口
Hashtable的方法时Synchrnize的，而hashMap不是，在多个线程访问hashtable
不需要自己为它实现同步，而hashMap就必须为之提供外同步。
进程是指一个独立执行过程中的程序，而每一个进程都有自己的一块独立的内存和一组系统资源。在进程的概念中每一个进程的内部数据和状态都是完全独立的。Java程序通过流控制来执行程序流，程序中单个顺序的流控制成为线程，多线程是指单个程序中可以同时运行多个不同的线程。执行不同的任务。多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行。
Synchronize 同步修饰符通过修饰成员方法或块，在多线程中，对用于共享的方法和快加以互斥锁使得任一时刻synchronize修饰的方法或者是快只能由个线程执行或操作。使用synchronize主要用于设置同步机制，以实现线程的同步。
Native 关键字
Native修饰符一般用来声明用其他的语言如c c++，Fortran，汇编等书写方法并具体实现方法功能的特殊方法。Native修饰的方法为本地方法 既方法实现与本机系统有关。Native
方法可应实用性强 执行效率高。运行速度要求较高的场合。
自己的说法是 native修饰的方法为特殊的方法 他的方法体可以用c语言 c++
汇编等语言书写。他的方法为本地方法，与系统有关。Native可适应强，执行效率高。运行速度要求较高的场合。
反射
概述反射和序列化
反射：程序集包含模块而模块包含类型类又包含成员。反射则提供了封装了程序集，
。模块和类型的对象。你可以使用反射动态的创建类型的实例，将类型绑定到有的对象，或从现有的对象中获取数据，然后，可以调用类型的方法或访问其字段和属性。
重点是反射提供了程序集合模块 和类型的封装对象。你可以使用发射动态的创建类型的实例，成员的实例 把他们绑定到现有的对象上 然后就可以调用类型的方法或访问其字段和属性。
序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象，这两个过程结合起来可以轻松的储存和传输数据。
Socket
编程中的常用的api是：
Accept（） getInputstream() getOutputStream() close()
Synchronize 既可以作用在方法上又可以作用在程序快上的
无论synchronize关键字加在方法上还是对像上，它取得的锁都是对象而不是把函数或者当做锁。而且同步方法很可能还会被其他的线程的对象访问。
每个对象只有一个锁与之相关联。
实现同步要很大的开销甚至思索，所以尽量避免无谓的同步控制。
Public synchronize void execute（）{
For(int i=0;i<50;i++){
System.out.println(Thread.currentThread().getName（）+”:”+i);
}
}
public void run() {
synchronized(this) {
for(int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+" synchronized loop " + i);
}
Servlet是线程安全吗？
以下代码中使用synchronized关键字的意义是什么？
Synchronized (aList){
aList.remove (1);
}
答：默认不是线程安全的，但是继承了singTreadModel接口 就能单线程执行。。此题中的代码的意思是对alist对像枷锁，保证alist对象在多线程的任务中每次只有有一个线程调用remove的方法。从而提高对alist 对象操作安全性和正确性。
死锁的四个必要条件：
互斥条件：一个资源每次只能被一个进程使用
请求与保持条件：一个进程因请求而阻塞时，对已获得的资源不释放。
不剥夺条件：进程已获得的资源，在问使用之前，不能强行剥夺；
循环等待条件 若干进程之间形成了一种头尾相接的等待资源关系。
这四个条件死锁的必要条件，只要系统发生死锁。这些条件必然成立。而只要上述条件之一不满足，就不会发生死锁。
死锁排除的方法
撤销陷于死锁的全过程
逐个撤销陷于死锁的进程直到死锁不存在
从陷于死锁的进程中逐个强迫放弃所占用的资源，直至死锁消失。
从另外一些进程那里强行剥夺足够数量分配给进程。以解除死锁状态。
request 对象：保存了很多客户端请求的信息。
response 对象：生成服务器端响应，然后将响应结果发送到客户端
out 对象：表示输出流，此输出流将作为请求发送到客户端
session 对象：我们写个对象放在这个 session 对象中,这个对象就在我们的会话中都存在。
application 对象:我们写个对象放在这个application 对象中， 这个对象就在整个应用程序中都存在
pageContext 对象相当于当前页面的容器，可以访问当前页面的所有对象。
paget 对象:一般我们使用 Page 指令来替代使用这个对象
exception 对象：用来处理异常的
config 对象：一样的我们在页面中是使用很少的，一般会在 Servlet 中使用这个
OSI-RM ISO／OSI Reference Model
该模型是国际标准化组织（ISO）为网络通信制定的协议，根据网络通信的功能要求，它把通信
过程分为七层，分别为物理层、数据链路层、网络层、传输层、会话层、表示层和应用层，每层都规
定了完成的功能及相应的协议。
26.简单说明什么是递归？什么情况会使用？并使用 java 实现一个简单的递归程序。
解答：
1）递归做为一种算法在程序设计语言中广泛应用.是指函数/过程/子程序在运行过程中直接或间接调
用自身而产生的重入现象。
2）递归算法一般用于解决三类问题：
a.数据的定义是按递归定义的。(Fibonacci（斐波那契）函数)
b.问题解法按递归算法实现。(回溯)
c.数据的结构形式是按递归定义的。(树的遍历，图的搜索)
3） .这是一个排列的例子， 它所做的工作是将输入的一个字符串中的所有元素进行排序并输出， 例如：
你给出的参数是"abc"则程序会输出：
abc
acb
bac
bca
cab
cba
a.算法的出口在于：ｌｏｗ＝ｈｉｇｈ也就是现在给出的排列元素只有一个时。
b.算法的逼近过程：先确定排列的第一位元素，也就是循环中ｉ所代表的元素，
然后ｌｏｗ＋１开始减少排列元素，如此下去，直到ｌｏｗ＝ｈｉｇｈ
public class Foo {
public static void main(String[] args) {
permute("abc");
}
public static void permute(String str) {
char[] strArray = str.toCharArray();
permute(strArray, 0, strArray.length - 1);
}
public static void permute(char[] list, int low, int high) {
int i;
if (low == high) {
String cout = "";
for (i = 0; i <= high; i++)
cout += list[i];
System.out.println(cout);
} else {
for (i = low; i <= high; i++) {
char temp = list[low];
list[low] = list[i];
list[i] = temp;
permute(list, low + 1, high);
temp = list[low];
list[low] = list[i];
list[i] = temp;
}
}
}
}
30. 简述基于 Struts 框架 Web 应用的工作流程
解答：在 web 应用启动时就会加载初始化ActionServlet,ActionServlet 从 struts-config.xml 文件
中读取配置信息,把它们存放到各种配置对象中， 当 ActionServlet 接收到一个客户请求时,将执行
如下流程.
1)检索和用户请求匹配的 ActionMapping 实例,如果不存在,就返回请求路径无效信息;
2)如果 ActionForm 实例不存在,就创建一个ActionForm 对象,把客户提交的表单数据保存到
ActionForm 对象中;
3)根据配置信息决定是否需要表单验证.如果需要验证,就调用 ActionForm 的 validate()方法;
4)如果 ActionForm 的 validate()方法返回 null 或返回一个不包含ActionMessage 的 ActionErrors
对象, 就表示表单验证成功;
5)ActionServlet 根据 ActionMapping 所包含的映射信息决定将请求转发给哪个 Action,如果相应的
Action 实例不存在,就先创建这个实例,然后调用 Action 的 execute()方法;
6)Action 的 execute()方法返回一个 ActionForward 对象,ActionServlet 在把客户请求转发给
ActionForward 对象指向的 JSP 组件;
7)ActionForward 对象指向 JSP 组件生成动态网页,返回给客户;
31. 在项目中用过 Spring 的哪些方面？及用过哪些 Ajax 框架？
解答：在项目使用过Spring IOC ，AOP，DAO，ORM，还有上下文环境。
在项目使用过Ext,Juery 等 Ajax 框架.
33.MVC 模式中 M，V，C 每个代表意义，并简述在 Struts 中 MVC 的表现方式。
解答：
MVC 是 Model-View-Controller 的缩写，Model 代表的是应用的业务逻辑（通过JavaBean，EJB 组件
实现） ，View 是应用的表示层（由 JSP 页面产生）Controller 是通过应用的处理过程控制， （一般是
一个 servert）通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现，这些组件
可以进行交互和重用。
在 Struts 框架中 Controller 功能由 ActionServlet 和 ActionMapping 对象构成， 核心是一个 Servlet
类 型的对象 ActionServlet ，它 用来接 收客户 端的 请求 。 ActionServlet 包 括一 组基于 配置 的
ActionMapping 对象，每个 ActionMapping 对象实现了一个请求到一个具体的 Model 部分的 Action
处理器对象之间的映射。 Model 部分由 Action 和 ActionForm 对象构成。 所有的 Action 处理器对象都
是开发者从 Struts 的 Action 类派生的子类。 Action 处理器对象封装了具体的处理逻辑， 调用业务逻
辑模块， 并且把响应提交到合适的 View 组件以产生响应。 Struts 提供的 ActionForm 组件对象可以通
过定义属性描述客户端表单数据，开发者可以从它派生子类对象，并利用它和 Struts 提供的自定义
标记库相结合， 可以实现对客户端的表单数据的良好封装和支持， Action 处理器对象可以直接对它进
行读写，而不再需要和request、response 对象进行数据交互。通过 ActionForm 组件对象实现了对
View 和 Model 之间交互的支持（View 部分是通过 JSP 技术实现的） 。Struts 提供了自定义的标记库，
通过这些自定义标记库可以非常容易地和系统的 Model 部分交互，通过使用这些自定义标记库创建的
JSP 表单，可以实现对 Model 部分中的 ActionForm 的映射，完成对用户数据的封装。
41.请解释分布式事务管理？
解答：分布式事务是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同
的分布式系统的不同节点之上。为了实现分布式事务，需要使用下面将介绍的两阶段提交协议。阶
段一：开始向事务涉及到的全部资源发送提交前信息。此时，事务涉及到的资源还有最后一次机会来
异常结束事务。如果任意一个资源决定异常结束事务，则整个事务取消，不会进行资源的更新。否则，
事务将正常执行，除非发生灾难性的失败。为了防止会发生灾难性的失败，所有资源的更新都会写入
到日志中。这些日志是永久性的，因此，这些日志会幸免遇难并且在失败之后可以重新对所有资源进
行更新。 阶段二：只在阶段一没有异常结束的时候才会发生。此时，所有能被定位和单独控制的资
源管理器都将开始执行真正的数据更新。 在分布式事务两阶段提交协议中，有一个主事务管理器负
责充当分布式事务协调器的角色。事务协调器负责整个事务并使之与网络中的其他事务管理器协同工
作。 为了实现分布式事务，必须使用一种协议在分布式事务的各个参与者之间传递事务上下文信息，
IIOP 便是这种协议。 这就要求不同开发商开发的事务参与者必须支持一种标准协议， 才能实现分布式
的事务。
一、 XML（返回目录）
1 XML文档定义有几种形式？解析XML文档有哪几种方式？在项目中如何应用XML？
答：1）两种形式：dtd以及schema；
2）本质区别：schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)；
3）解析方式：有DOM,SAX,STAX等：
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问；
SAX:不同于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问；
STAX:Streaming API for XML (StAX)。
2名词一句话解释SOAP、WSDL
SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。
WSDL是一种 XML 格式，用于将网络服务描述为一组端点，这些端点对包含面向文档信息或面向过程信息的消息进行操作。这种格式首先对操作和消息进行抽象描述，然后将其绑定到具体的网络协议和消息格式上以定义端点。相关的具体端点即组合成为抽象端点(服务)。
二、 JDBC&Hibernate&持久层框架（返回目录）
1 JDBC连接数据库的步骤
答：1.加载驱动：Class.forName(“com.microsoft.jdbc.sqlserver.SQLServerDriver”). newInstance();
2.
2.建立连接：Connection conn=riverManager.getConnection(url,username,password);
2请简述您对Hibernate和Configuration接口的认识。
答：Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用。
Configuration接口：配置Hibernate，根据其启动hibernate，创建SessionFactory对象。
3名词解释ADO：
答：ADO (ActiveX Data Objects) 是一个用于存取数据源的COM组件。它提供了编程语言和统一数据访问方式OLE DB的一个中间层。允许开发人员编写访问数据的代码而不用关心数据库是如何实现的，而只用关心到数据库的连接。
4在Hibernate 的接口中，被用户的应用程序调用的，用来完成基本的创建、读取、更新、删除操作的以及查询操作的接口，是Hibernate实现用户程序的商业逻辑的主要接口，包括：
Session、Transaction和Query
5从数据库中取出100，000条数据，每次插入数据库1000条，请写出java相关处理程序，其中insertAll(ArrayList或Vector)为公共方法，已封装好；功能：批量插入数据；
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;
public class InsertBatch {
private static Connection conn;
static {
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/test", "root", "1234");
} catch (Exception e) {
e.printStackTrace();
}
}
public static boolean insertAll(List<?>result) {
Iterator<?> it =result.iterator();
int i = 0;
try {
PreparedStatement ps = conn
.prepareStatement("insert into tablevalues(?)");
while (it.hasNext()) {
++i;
ps.setString(0,it.next()+"");
if (i % 1000 == 0) {
ps.execute();
ps.clearBatch();
}
ps.addBatch();
}
return true;
} catch (SQLException e) {
e.printStackTrace();
}
return false;
}
}
a) 一个Collection中有多个学生成绩对象StuDto，StuDto有学号StuNo、科目代码StuKe、成绩StuGrade等属性，请求出Collection中学号为S10的学生的除了英语之外的总成绩
public static intgetTotalScore(List<Student> students, String stuNo) {
Iterator<Student> it =students.iterator();
int totalScore = 0;
while(it.hasNext()){
Student stu =(Student)it.next();
if(stuNo.equals(stu.getStuNo())&&!"english".equalsIgnoreCase(stu.getStuKe())){
totalScore +=stu.getStuGrade();
}
}
return totalScore;
}
6 Java数据库编程包含哪些类？Java数据库编程的基本过程是什么？
答：用到的类：
JDBC：DriverManager
Hibernate：Configuration
用到的接口：
JDBC：Connection、ResultSet、PreparedStatement、Statement
Hibernate：SessionFactory、Session、Query
Java中访问数据库的步骤如下：
1
1）注册驱动；
2）建立连接；
3）创建Statement；
4）执行sql语句；
5）处理结果集（若sql语句为查询语句）；
6）关闭连接。
四、 WEB（返回目录）
1名词解释 AJAX
答：AJAX全称为“AsynchronousJavaScript and XML”（异步JavaScript和XML），是指一种创建交互式网页应用的网页开发技术。
2 Tomcat缺省端口号是多少，如果需要修改哪个目录下的哪个文件？
答：默认8088，修改时在conf/server.xml下修改，
<Connector port="80"maxHttpHeaderSize="8192"
maxThreads="150" minSpareThreads="25"maxSpareThreads="75"
enableLookups="false" redirectPort="8443"acceptCount="100"
connectionTimeout="20000"disableUploadTimeout="true" />
3简述MVC设计模式及常用的MVC组件
答：MVC（Model-View-Controller）应用程序结构被用来分析分布式应用程序的特征。这种抽象结构能有助于将应用程序分割成若干逻辑部件，使程序设计变得更加容易。
在MVC结构中，模型（Model）代表应用程序的数据（data）和用于控制访问和修改这些数据的业务规则（business rule）。通常模型被用来作为对现实世界中一个处理过程的软件近似，当定义一个模型时，可以采用一般的简单的建模技术。
当模型发生改变时，它会通知视图（View），并且为视提供查询模型相关状态的能力。同时，它也为控制器（Controller）提供访问封装在模型内部的应用程序功能的能力。
一个视图（View）用来组织模型的内容。它从模型那里获得数据并指定这些数据如何表现。当模型变化时，视图负责维持数据表现的一致性。视同时将用户要求告知控制器（Controller）。
控制器（Controller）定义了应用程序的行为；它负责对来自视图的用户要求进行解释，并把这些要求映射成相应的行为，这些行为由模型负责实现。
常用组建有：Struts、Spring等。
4 HTTP是无状态的连接协议吗？简述Cookie和Session的作用和实现
答：HTTP是无状态的协议。
Cookie作用：服务器可以利用Cookies包含信息的任意性来筛选并经常性维护这些信息，以判断在HTTP传输中的状态。
实现：文档的 HTML 代码中的命令行告诉浏览器设置某一名称或数值的 cookie。以下是用来设置 cookie 脚本的一个普通实例。
Set-Cookie:name = VALUE;
expires= DATE;
path =PATH;
domain= DOMAIN_NAME;
Session作用：Session 的作用就是它在 Web 服务器上保持用户的状态信息供在任何时间从任何页访问。因为浏览器不需要存储任何这种信息，所以可以使用任何浏览器。
实现：
5简述页面跳转forward和redirect的不同
答：forward是容器中控制权的转向，是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。 redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取，并且从浏览器的地址栏中可以看到跳转后的链接地址。前者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接；在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。
6如何使用JSP实现页面的跳转？
答：JSP中的请求转发可利用forward动作实现：<jsp:forward />；
7写出JSP中内置对象名称。
答：JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）：
request：用户端请求，此请求会包含来自GET/POST请求的参数；
response：网页传回用户端的回应；
pageContext：网页的属性是在这里管理；
session：与请求有关的会话期；
application：servlet正在执行的内容；
out：用来传送回应的输出；
config：servlet的构架部件；
page：JSP网页本身；
exception：针对错误网页，未捕捉的例外。
8 Portlet API 中GenericPortlet对象是何作用。
答：像 Servle一样，编写的 Portlet 也必须直接或者间接的扩展基类 GenericPortlet ，这个是由 JCP 针对Portal 提出的 JSR168 规范定义的。只要扩展自规范的 GenericPortlet ，所有的 Portlet 都可以在支持 JSR168 规范的 Portal 服务器上运行。
9名词一句话解释： UDDI
UDDI 的目的是为电子商务建立标准;UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。
10解释MVC模式，说明各个部分主要由哪些技术来实现？说出你了解的开源框架及其优缺点？
答：MVC是Model－View－Controller的简写。"Model" 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现），"View" 是应用的表示面（由JSP页面产生），"Controller"是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。
Struts：优点：将业务层与表示层强制解耦，重用架构扩展维护方便
缺点：应用反射，效率降低
11谈谈对Struts、spring和hibernate的理解
答：struts可以将jsp页面的表单关联起来,就是把JSP页面的表单数据封装成javaBean,这样的话,在action中你再也不需要使用传统一的request.getParameter("name");
还有struts有一个控制器,你在struts编程中的控制器(XxxAction)都是继承总的ActionServlet,它能集中处理请求,然后转到相关的页面.
还有struts的表单验证组件,不用你写js验证了,只需要你配置一下文件就可以了
另外struts的令牌机制可以防表单重复提交
---------------------------------------------------
spring:轻量级容器,非侵入性.包含依赖注入,AOP等.
Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。
---------------------------------------------------
hibernate:1、hibernate让我们以oo的方式操作数据库，这让我们看到了hibernate的强大之处，体验到操作数据的方便。但hibernate最耀眼之处是hibernate的缓存机制，而不是以oo的方式操作数据库。Hibernate的缓存机制不外乎是一级缓存session，二级缓存sessionFactory，和第三方缓存如ehcache。也就是hibernate的最强大的地方是它的缓存，理解了这个才能真正的理解hibernate。
2、可维护性： Hibernate的命名查询/命名参数查询，就是将hql语句放在一个单独的xml文件之中，它仍然让人们以面向对象的方式去操纵数据，而不用在以oo的方式写着代码的同时，然后再转变思维，用面向关系的方式去写那些sql语句。但hibernate不仅做了这些，它的native sql查询方式，完全满足sql语句的偏爱者，它像ibatis一样，将sql语句放在配置文件之中。
12 B/S结构,C/S结构
C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。
B/S是Brower/Server的缩写，客户机上只要安装一个浏览器(Browser)，如Netscape Navigator或Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Web Server 同数据库进行数据交互。
13在一个BS结构中需要传递变量值时，不能使用session,cookie,application,你有几中方法？
答：可以使用request和ＵＲＬ 字符串传输及Server.Transfer()方法可以传递页面中的任何对象到目标页面中。
14名词解释STRUTS：
使用Struts为业务应用的每一层提供支持。它的目的是为了帮助我们减少在运用MVC设计模型来开发Web应用的时间。
15下面是两个数据库表，分别记录员工姓名和工资，涉及两个JSP页面(search.jsp/result.jsp),以对下面两个表进行查询
T_EMPLOYEE
ID
NAME
2
张三
3
李四
5
王五
·····
·····
T_SALARY
ID
SALARY
2
3400
3
4300
5
2500
·····
·····
条件：type = employee，id = ？
结果：查询表 T_EMPLOYEE 中 id = ？ 的员工记录
条件：type = employee，id = null
结果：查询表 T_EMPLOYEE 中所有员工记录
条件：type = salary，id = ？
结果：联合查询表 T_EMPLOYEE 和T_SALARY 中所有员工的姓名和工资记录
ID
NAME
SALARY
2
张三
3400
条件：type = salary，id = null
结果：联合查询表 T_EMPLOYEE 和T_SALARY 中所有员工的姓名和工资记录，并按照薪水从高到低排列
ID
NAME
SALARY
·····
·····
·····
·····
·····
·····
如果不符合任何查询条件，则提示用户“查询条件错误，请重新输入”，并在5秒后自动跳转到查询条件search.jsp页面
JSP:
跳转页面：
<html>
<head>
<script type="text/javascript">
var i = 5;
var id = setInterval(
function() {
$(‘time‘).innerHTML = i--;
},1000);
window.setTimeout(
function() {
clearInterval(id);
window.location= ‘jsp/search.jsp‘;
},5000);
</script>
</head>
<body>
您输入的查询条件有错误，系统将在
<div id="time"></div>
秒后跳转！！
<br>
</body>
</html>
查询页面：
<body>
<form action="">
请输入查找类型：<input type="text" name="type"><br>
请输入查询值 ：<input type="text" name="id">
</form>
</body>
结果页面：
<body>
<table>
<c:forEach var="l" varStatus="${msg}">
<tr>${l}</tr>
</c:forEach>
</table>
</body>
JAVA:
DAO：
public class SearchDao {
public List getMessage(String type, Stringid){
Connectionconn = DAOFactory.getConnection();
Stringsql = "";
boolean flag = false;
if("employee".equals(type)){
if(id!=null){
sql= "select * from T_EMPLOYEE whereid="+Integer.parseInt(id);
}else{
sql= "select * from T_EMPLOYEE";
}
}else if("salary".equals(type)){
if(id!=null){
sql= "select e.id,e.name,s.salary fromT_EMPLOYEE e,T_SALARY s where e.id=s.id and e.id="+Integer.parseInt(id);
}else{
sql= "select e.id,e.name,s.salary fromT_EMPLOYEE e,T_SALARY s where e.id=s.id order by e.salary desc";
}
flag= true;
}else{
return null;
}
Listl = null;
StringBuffersb = newStringBuffer();
try {
ResultSetresult = conn.createStatement().executeQuery(sql);
l= new ArrayList();
while(result.next()){
int eid = result.getInt(0);
sb.append(eid+" ");
Stringename = result.getString(1);
sb.append(ename+" ");
if(flag){
double salary = result.getDouble(2);
sb.append(salary+" \n");
}
l.add(sb.toString());
sb.delete(0,sb.length()-1);
}
}catch(SQLException e) {
e.printStackTrace();
}
return l;
}
}
Action：
public class SearchAction extends Action {
@Override
public ActionForward execute(ActionMapping mapping,ActionForm form,
HttpServletRequestrequest, HttpServletResponse response)
throws Exception {
Stringtype = request.getParameter("type");
Stringid = request.getParameter("id");
SearchServicess = newSearchService();
Listl = ss.getMessage(type,id);
request.setAttribute("msg", l);
if(l!=null){
return mapping.findForward("success");
}
return mapping.findForward("fail");
}
}
要求：只要求写出主要代码（JAVA、SQL和html主要标签）
16一个Web页面包含哪三大要素，都有些什么标准。要解决跨浏览器访问的问题应注意哪些方面。
答：HTML/XHTML/CSS 都是基于W3C标准
夸浏览器访问问题主要是因为浏览器对于脚本语言的解析和支持程度不同。要编写跨浏览器的页面，就要注意页面中的标签和脚本语言是否被支持。
17就WEB2.0 相关信息做一下描述，谈谈你对这些技术概念的认识。
答：一些WEB2.0产品，就可以理解以上观点。
Blog：用户织网，发表新知识，和其他用户内容链接，进而非常自然的组织这些内容。
RSS：用户产生内容自动分发，定阅。
Podcasting：个人视频/声频的发布/定阅。
SNS：blog+人和人之间的链接。
WIKI：用户共同建设一个大百科全书。
从知识生产的角度看，WEB1.0的任务，是将以前没有放在网上的人类知识，通过商业的力量，放到网上去。
WEB2.0的任务是，将这些知识，通过每个用户的浏览求知的力量，协作工作，把知识有机的组织起来，在这个过程中继续将知识深化，并产生新的思想火花；
从内容产生者角度看，WEB1.0是商业公司为主体把内容往网上搬，而WEB2.0则是以用户为主，以简便随意方式，通过blog/podcasting 方式把新内容往网上搬；
从交互性看，WEB1.0是网站对用户为主；WEB2.0是以P2P为主。
从技术上看，WEB客户端化，工作效率越来越高。
我们看到，用户在互联网上的作用越来越大；他们贡献内容，传播内容，而且提供了这些内容之间的链接关系和浏览路径。在SNS里面，内容是以用户为核心来组织的。WEB2.0是以用户为核心的互联网
18以下哪条语句不会产生运行错误：（B ）
A．var obj = ( );
B．var obj = [ ]; //js定义数组
C．var obj = ｛ ｝;
D．var obj = / /;
19请选择结果为真的表达式：（B ）
A. null instanceof Object
B. null = = undefined
C. NaN = = NaN
20 foo对象有att属性，那么获取att属性的值，以下哪些做法是可以的：（ A、C ）
A.foo.att
B.foo ( “att”)
C.foo [ “att” ]
D.foo｛ “att” ｝
E.foo｛ “a”+“t”+“t” ｝
21 UDP和TCP连接有和异同？
TCP协议是面向连接的，每个数据包的传输过程是：先建立链路、数据传输、然后清除链路。数据包不包含目的地址。受端和发端不但顺序一致，而且内容相同。它的可靠性高；UDP协议是面向无连接的，每个数据包都有完整的源、目的地址及分组编号，各自在网络中独立传输，传输中不管其顺序，数据到达收端后再进行排序组装，遇有丢失、差错和失序等情况，通过请求重发来解决。它的效率比较高。
五、 EJB&Spring（返回目录）
1名词解释AOP
答：AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向切面编程。可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦。
2用JPA写一个用户表的实体类，表结构如下：
CREATE TABLE user(
id NUMBER(8) primary key,
userName VARCHAR2(30), -- 用户名称
password VARCHAR (20), -- 密码
);
填出以下实现类的空白；
package net.greatsoft.cms
import java.io.*;
import java.persistence.*;
@Entity
@Table(name="user")
public class user implements Serializable{
@Id
@GeneratedValue
@Column(name="id")
private Integer id;
@Column(name="userName")
private String username;
@Column(name="password")
private String password;
public long getID(){
return id;
}
public void setID(long id){
this.id = id;
}
public String getUsername(){
return username;
}
public void setUsername(String username){
this.username = username;
}
public String getPassword(){
return password;
}
public void setPassword(){
this.password = password;
}
}
3 EJB3.0 有哪几种类型？写出一个 stateless bean 的本地接口类及实现类，接口如下 ：
String helloWorld();
答：会话Bean（Session Bean），实体Bean（EntityBean）和消息驱动Bean（MessageDriven Bean）。
@Local
public interface StatelessBean{
String helloWorld();
}
@Stateless
public class StatelessBeanImpl implements StatelessBean{
String helloWorld(){
System.out.println("Hello world!!!");
}
}
4说说java EE 5由哪些技术规范构成及相对于J2 EE 1.4的新特点和优势是什么。
javaEE5规范有：企业应用、Web应用、Web服务和管理四个方面
新特性为：EJB规范、Web层规范、标注(Annotation)的使用、Security(基于容器的安全访问)、事务管理(TransactionManagement)等。
简化业务逻辑开发。
简化测试和依赖关系管理。
简化 O/R 持久性。
增强 Web 服务编程模型。
5说出下列配置文件是何含义：
<bean id ="testLocal"
class="org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean">
<property name="jndiName"value="Test"/>
<property name="businessInterface"
value="net.greatsoft.cms.prv.test.TestLocal"/>
<bean>
定义一个 bean 。
对应的2个初始化参数 String jndiName 值为test String businessInterface 值为 net.greatsoft.cms.prv.test.TestLocal
6名词解释ISO 9000/CMM：专门由于软件企业的软件开发过程管理的一套标准规范，主要是为了减少项目的失败率
六、C&C++（返回目录）
1请指出下面的C++程序可能产生的后果
while(true){
new char[4096]
sleep(100);
}
内存溢出
2指出下面的C程序可能产生的后果：（说明：以下程序是一个函数中的节选，其中，lpszName是一个指针变量，之前已经申明过。）
if(lpszName==NULL||!strcmp(lpszName,"[local]")){
// do something.
...
} else {
// do something
...
}
3 New有几种用法？（C++）
第一种:newClass();
第二种:覆盖方法
public newXXXX(){}
第三种:new 约束指定泛型类声明中的任何类型参数都必须有公共的无参数构造函数。
4 Const和ReadOnly？
const是一个C语言的关键字，它限定一个变量不允许被改变；
readonly 是只读，不可修改的变量。
5 C/C++网络编程中，网络数据传输的顺序为____位在前、____位在后，Java网络编程中，网络数据传输的顺序为____位在前、____位在后。
七、软件工程（返回目录）
1结构化程序设计所规定的三种基本控制结构是：顺序、选择、循环
2结构化程序设计的一种基本方法是：逐步求精法
3软件测试方法中，黑盒测试和白盒测试法是常用的方法，其中黑盒测试法主要是用于测试（ 测试软件的功能需求 ）
4现在要开发一个投票系统，从系统的可扩充性和实用性出发，做系统的功能定义。
答：本系统为无记名投票系统，本系统要求能够浏览被选举人的个人信息或者提案的信息；需要有选票统计系统，统计系统中应该定义投票情况（分两种情况：一种为选举系统，选取人员；另外一种为提案通过投票），这里可以定义接口，根据不同情况调用不同实现类；需要有当选规则，当选规则需要根据情况灵活确定，所以当选规则在设计上应该为接口，根据不同需要使用其实现类作为规则。
5简述软件开发的生命周期？你觉得那个阶段最重要？代码规范的重要性？如何实现代码规范？
答：无论是瀑布开发模式还是螺旋开发模式 软件开发的周期大约都是分成需求，设计，编码和单元测试，系统集成，运行和维护几个阶段
如果是迭代方法开发 那么软件的生命周期应该分为开端、评价、构建和产品化。
6软件开发过程中，一般需要编写哪些文档？分别在哪个阶段提交这些文档？
7货车车主查找要运货的货源或货源方查找要运货的车源，请以两者之一做为用户需求，列举这个用例应该具备哪些功能。
答：以货源方查找要运货的车源为需求。
需求应该包括：显示车源清单、按条件查询车源、显示车源具体信息等。
8名词解释:
SQL语言:结构化查询语言
ERP: 是指建立在信息技术基础上，以系统化的管理思想，为企业决策层及员工提供决策运行手段的管理平台。
HIS: 利用电子计算机和通讯设备，为医院所属各部门提供对病人诊疗信息和行政管理信息的收集、存储、处理、提取及数据交换的能力，并满足所有授权用户的功能需求。
9在面向对象方法学中，直接反映了用户对目标系统的要求的模型是：功能模型
10目前有一个电子商务网站需要开发，如果你接手负责这个项目，请描述一下你将如何开展这个项目。（包括开发工具的选型，人员的安排、功能的设计等等）
11面向对象编程与传统的面向过程编程有何优点？可以从继承、多态两个方面来谈谈具体感受。
答：使用面向对象思想进行开发有以下优点：
1
1、易维护
采用面向对象思想设计的结构，可读性高，由于继承的存在，即使改变需求，那么维护也只是在局部模块，所以维护起来是非常方便和较低成本的。
2
2、质量高
在设计时，可重用现有的，在以前的项目的领域中已被测试过的类使系统满足业务需求并具有较高的质量。
3
3、效率高
在软件开发时，根据设计的需要对现实世界的事物进行抽象，产生类。使用这样的方法解决问题，接近于日常生活和自然的思考方式，势必提高软件开发的效率和质量。
4
4、易扩展
由于继承、封装、多态的特性，自然设计出高内聚、低耦合的系统结构，使得系统更灵活、更容易扩展，而且成本较低。
继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
自我介绍
简历上的自我评价进行口语化，从心理加上开头结尾，整体围绕岗位要求进行陈述你的自我介绍
你的优势 你的劣势
可以接受适当的加班 出差的看法
与上级的意见不一致怎么办 ，你怎么办
我希望与怎样的领导同事共事
你是实习生 没有经验 如何开展工作
兴趣爱好的
职业规划
请介绍你的家庭学校
说说你期望的薪金待遇
关于工资合同的问题
你觉得你的学业能真实的反应你的工作水平吗？如果不能为什么
你对我们有什么要问的吗
咱们有定期的技术培训吗
我去了 有人带着吗
有定期的活动吗
---------------------
作者：佐酒先生
来源：CSDN
原文：https://blog.csdn.net/pamguangyou/article/details/54925060
标签：数据文件 链表实现 ORC 定义 element 超链接 next 数据库 分布式系统
原文地址：https://www.cnblogs.com/GreenHands/p/10803353.html
