南开《J2EE信息系统设计》复习资料-刘杨

南开《J2EE信息系统设计》复习资料-刘杨满分答案

《J2EE信息系统设计》课程期末复习资料

《J2EE信息系统设计》课程讲稿章节目录：
第一章JAVA基础
第一节 Java环境及配置
第二节 Java基本语法
第三节 类和接口
第四节 Java Applet
第五节 Java图形处理
第六节 Java用户界面技术
第七节 异常、事件和多线程机制
第八节 输入输出技术
第二章 SQL Server
   第一节 SQL Server2008的安装与管理器
   第二节 数据库管理
   第三节 数据表的管理
   第四节 数据的管理
   第五节 视图与索引
   第六节 T-SQL编程
   第七节 事务
   第八节 游标
   第九节 存储过程
   第十节 触发器
   第十一节 权限以及安全
   第十二节 数据库的设计
第三章 HTML、Javascript、CSS基础
第一节 HTML基本标签
第二节 表单和框架
第三节 CSS
第四节 Javascript
第五节 Javascript综合操作实践
第四章 JavaEE
第一节JavaEE平台及开发入门
第二节 struts基础
第三节 struts2标签库
第四节 struts2 类型转换及输入校验
第五节 struts2拦截器
第六节 struts2的其他应用
第七节 struts2综合应用案例
第八节 Hibernate基础
第九节 Hibernate映射机制
第十节 Hibernate对持久化对象的操作
第十一节 Hibernate的高级特性
第十二节 Hibernate与struts2的整合应用案例
第十三节 Spring基础
第十四节 Spring的aop及事物支持
第十五节 Spring的其他功能
第十六节 用Spring整合的各种JavaEE框架

一、客观部分：（填空题、单项选择题）
（一）、填空题部分
1. 企业级应用程序通常应具备快速适应性、　分布式　、　高安全性　、　　可扩展性和　集成化　等特性。
2. 两层体系结构由　客户层　和　服务器层　构成，即所谓的　C/S　模式。
3. 三层体系结构通常包括　客户层　、　服务器层　和　应用服务器层　三个层次。
4. 典型Java EE 应用包括：　客户层　、　表示层（Web层）　、　业务逻辑层　和　企业信息系统层　四个层次。
5. Java EE技术框架大致包括　组件技术　、　服务技术　和　通信技术　三个部分。
6. Java EE组件主要包括　客户端组件　、　Web组件　和　EJB组件　三大类。
7. 按打包粒度从小至大的顺序，Java归档包的类型分别是　JAR　、WAR　　和　EAR　。
8. 程序错误可分为　语法错　、　语义错　和　逻辑错　三类。
★考核知识点: javaee的基础
9. JSP指令元素主要包括　include　、　page　和　taglib　三个。
10. include指令的基本语法为　<%@ include file=”URL” %>　。
11. taglib指令的基本语法为　<%@ taglib uri=”taglibURI” prefix=”pre” %>　。
12. JSP参数标记的基本语法为　　<jsp:param name="name" value="value" />

★考核知识点: 第三章 HTML、Javascript、CSS基础

13. 读取request单值参数的方法是　getParameter()　，读取多值参数的方法是　getParameterValues()　。获取所有参数名称的方法是　getParameterNames()　。
14. request作用范围变量可以通过　setAttribute()　和　getAttribute()　方法设置和读取变量的数据。
15. 调用　response　对象的　addCookie(Cookie cookie)　方法可将一个Cookie对象传回客户端保存。
16. 调用　request　对象的　getCookies()　方法可以读取保存在客户端的所有Cookie对象。
17. 在web.xml文件中定义Web应用初始化参数的标记是　<context-param></context-param>和子标记　<param-name></param-name>　、　<param-value></param-value>　。
18. 读取Web应用初始化参数的相关方法有　getInitParameter(String name)　和　　getInitParameterNames()　。
19. HttpServlet处理客户端请求的方法是　doGet()　和　doPost()　。P(62)
20. Servlet的生命周期大致分为　初始化阶段　、　处理请求阶段　和　销毁阶段　三个阶段。
21. <jsp:useBean>标记的scope属性可取　page　、　request　、　session　和application四个值。
22. MVC模式的三个基本部分是　模型(Model)　、　视图(View)　和　控制器(Controller)　。
23. JSF应用的主控制器是　FacesServlet 　，它需要在　web.xml　文件中进行配置，其URL映射通常配置为　* . faces　。
24. MyEclipse的JSF工具面板包括　Core标签　和　HTML标签　两类JSF标签，使用这些标签的页面需要使用JSP指令　taglib　导入标签库。
25. JSF标签<h:outputText…>的常用属性是　id　和　value　，后者常用于绑定辅助Bean的属性，例如　<h:outputText value="#{students.birthday}"></h:outputText>　。
26. JSF标签　loadBundle　用于装载资源文件，其常用属性是　basename　和　var　。
27. JSF标签　selectItem　用于为选择类标签提供选项，属性　itemLabel　用于设置显示文本，　itemValue　设置对应的数据值。
28. JSF<f:selectItems…>标签的value属性通常绑定辅助Bean的SelectItem类型　　或　Map类　属性，还可以是　　类或SelectItemGroup类属性。
29. JSF　dataTable　标签用于显示数据库表数据，其　value　属性通常绑定辅助Bean的ResultSet类型属性，另外还须设置　var　属性以便在列子标签中访问该记录集的数据。
30. JSF　column　标签通常不须设置属性，而是通过嵌入　facet　子标签定义表头，并利用　outputText　或　inputText　子标签设置记录集的列。
31. JSF事件可分为　实时事件　、　动作事件　、　值变事件　和生命周期事件4类。
32. EJB 3的开发通常涉及到　业务接口　、　Bean类　以及　辅助类　3种文件EJB3的Bean类分为　会话Bean　、　实体Bean　和　消息驱动Bean　3大类。
33. JMS消息由　消息头字段　、　一组可选属性　以及　消息体　组成。
34. JMS提供　点对点方式　和　发布-订阅方式　两种类型的消息服务。
35. 有状态会话Bean的生命周期包括　不存在状态　、　准备就绪状态　和　挂起状态　三种状态。
36. JPA的配置文件名默认为　persistence.xml　，标签<persistence-unit …>的主要属性有　name　和　transaction-type　。
37. Web服务架构的三类角色是服务的　提供者　 、　请求者　和　注册中心　。
38. Web服务架构的三种基本操作是　发布　 、　查找　和　绑定　。Struts 2框架由　核心控制器FilterDispatcher　、　业务控制器　和　用户业务逻辑组件　3部分组成。
39. Action的配置文件为　struts.xml　，通过<action…/>元素的　name　属性声明Action的访问名，　class　属性指明其具体的实现类。
40. Struts 2的Action类通常可继承系统类　ActionSupport　或实现　Action　接口，它们约定的关键业务方法是　execute()　。
41. Struts 2标记库中用于显示验证错误信息的标记主要有　<s:actionnerror cssStyle=” “ />　和　<s:fielderror cssStyle=” “ />　。
42. Struts 2框架由__WebWork_________和____XWork_______框架发展而来。
43. Struts 2以__过滤器_________为核心，采用____拦截器_______的机制来处理用户的请求。
44. 构建Struts 2应用的最基础的几个类库是_____struts2-core______、____xwork_______、____freemaker_______、__ognl_________以及____commons-logging_______。
45. Struts 2中的控制器类是一个普通的____POJO_______。
46. 如果要在JSP页面中使用Struts 2提供的标签库，首先必须在页面中使用taglib编译指令导入标签库，其中taglib编译指令为____<%@ uri=”/struts-tags” prefix=”s”%>_______。
47. 在Struts 2表单标签库中，表单标签为____<s:form></s:form>_______。

★考核知识点: 第四章 JAVAEE
48. Hibernate包括　SessionFactory　、　Session　、　Query和Criteria　、Transaction和Configuration 5个核心接口。
49. Hibernate框架提供的查询语言为　HQL　，相关的查询接口有　Query　和　Criteria　。
50. Hibernate框架的主配置文件为hibernate. cfg.xml ，对象关系映射配置文件为一系列
51. Hibernate配置数据库连接的四种属性名是connection.driver_class、connection.username 、connection.password 、connection.url 。
52. 在Hibernate XML影射文件中描述主键生成机制，其属性描述了主键的生成策略，至少写出三种策略名identity、native、increment  。
53. 基于Hibernate用标注（annotations）描述映射关系，映射实体类中表示主键的属性的标注是___@Id________  ；映射实体类中普通属性的标注是___@Column________；实体属性对应的列用标注____@Entity_______。
54. Hibernate的会话接口中声明了持久化的操作，删除一个实体的方法是__delete(obj)_________，合并一个实体的方法是____merge_______，获得事务处理接口的方法是_getTransaction()__________。
55. Hibernate的会话接口同时又是一个工厂类型：创建一个HQL查询接口的方法是____createQuery_______，创建基于公式（标准）接口的方法是 __createCriteria_________。
56. Hibernate应用缺省的XML格式的配置文件名是___hibernate.cfg.xml________, 放置在__classpath_________下；配置数据库方言的属性名是____dialect_______。
57. 在Hibernate中级联操作的属性值至少写出三个_______save-update____ 、_____none______、_____delete______。All ,delete-orphan
58. 基于Hibernate用标注（annotations）描述映射关系，实体类型用标注__@Entity_________ ；实体对应的表用标注___@Table________。
59. Hibernate的会话接口是 __Session_________，它由接口 ___SessionFactory________创建；Hibernate处理事务的接口是___Transaction________；封装HQL的接口是___Query________ 。


★考核知识点: 第四章 JAVAEE


60. Spring容器相关的核心接口是　BeanFactory　和　ApplicationContext　，默认的配置文件是　applicationContext.xml　。
61. Spring配置文件中的<bean…/>标记的常用属性有　id　 、　class　和　scope　。
62. Spring容器配置Bean的作用域包括　singleton　、　prototype　、　request　、session和globalsession 五种。
63. Spring提供了　设值注入　和　构造注入　两种依赖注入方式访问容器配置的Bean实例。
★考核知识点: 第四章 JAVAEE


64. 使用Ext的Web页面需要引入　ext-all.css　、　ext-base.js　和　ext-all.js　3个Ext库文件。
（二）、选择题部分
1 Java语言可以划分为三大应用平台，哪个不属于其中？（C）
A  Java Plateform Micro Edition（Java ME）
B  Java Plateform Standard Edition（Java SE）
C  Enterprise JavaBean
D  Java Plateform Enterprise Edition（Java EE）
★考核知识点: JAVA的三个体系

附：Java分为三个体系：
JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

2   下面有关MVC设计模式说法不正确的是（D
A  按MVC设计模式，一个模型对应多个视图，可以减少代码的复制及代码的维护量
B  模型返回的数据与显示逻辑分离
C  控制层可以把不同的模型和不同的视图组合在一起，完成不同的请求
D  MVC更符合软件工程化管理的精神，并能提高软件运行速度
★考核知识点:MVC


3  下面有关target属性保留字说法错误的是（A）
A   _blank,无窗口显示
B   _parent,父框架页或窗口。如果包含链接的框架不是嵌套的，则链接的目标文件加
载到整个浏览器窗口中
C   _self,所在的统一框架或窗口
D  _top,整个浏览器的窗口，并删除所有的框架
★考核知识点:target属性

4   下面哪个不是复选框的响应事件（D）
A   onfocus，得到焦点时执行的代码
B   onblur，失去焦点时执行地代码
C   onclick，单击该文本框时执行的代码
D   onselect，选择内容时执行的代码
★考核知识点:jsp中的事件响应

5   下面关于框架集frameset相关属性说明有误的是（C）
A   cols，创建纵向分隔框架时指定各个框架的列宽，取值有3种形式，即像素，百分 比（%）和相对尺寸（*）
B   rows，横向分隔框架时各个框架的行高
C   frameborder，框架周围是否显示边框，默认值为1，表示有边框，0表示无边框
D  framespacing，框架之间的间隔（以像素为单位，默认值为0）
★考核知识点:框架集frameset

6   下面哪个有关Servlet中service()方法说法不正确的是（C）
A   在init()方法正确执行完成后，service()将被容器调用
B   容器调用service()方法来处理客户端的请求
C   service()中有用于接收客户端请求信息的ServletResponse对象和用于对客户端进行响应的ServletResquest对象
D Servlet对象通过ServletRequest获取客户端的相关信息和请求信息
★考核知识点:jsp中的事件响应

7    下面哪个有关Servlet中init()操作的说法不正确的是（C）
A 在Servlet实例化之后，Servlet容器会调用init()方法
B Servlet通过init()方法可以实现一些初始化工作，如建立数据库连接，获取配置信息等
C init()方法可被多次调用
D init()方法中需要带一个类型为ServletConfig的参数
★考核知识点:jsp中的事件响应

8    关于JSP的说法正确的有（A） 
A  JSP在服务器端被执行
B  JSP的最终存在形式是java application  C JSP在客户端被执行
D  JSP的最终存在形式是servlet
★考核知识点:jsp中的事件响应

9   下面有关sendRedirect和Forword机制的说法不正确的是（） 
A  sendRedirect发送状态码给客户端浏览器
B sendRedirect传送时会保留HttpServletRequest对象
C forward发送请求给其他Web资源时，不使用客户端浏览器
D forward传送HttpServletRequest和HttpServletResponse对象给其他Web资源
10  下面哪个方法不是HttpServlet类（D）
A pretected void doGet(HttpServletRequest req,HttpSevletRequest res)   throws Servlet Exception, java.io.IOException 
B pretected void doPost(HttpServletRequest req,HttpSevletRequest res)  throws Servlet Exception, java.io.IOException 
C pretected void doHead(HttpServletRequest req,HttpSevletRequest res)   throws Servlet Exception, java.io.IOException
D  pretected void execute(HttpServletRequest req,HttpSevletRequest res)   throws Servlet Exception, java.io.IOException

11  下面哪个方法不属于JSP指令（A）
  A <jsp:param name=”username” value=”liu”/> 
B <%@include file=”head.jsp”%> 
C <%@ taglib uri=”struts-tags” prefix=”s”%> 
D <%@page contentType=”text/html, charset=gb2312”%> 
12  下面有关JSP注释说法不正确的是（C） 
A  <!--  -->注释，和HTML文件中的注释很相似，唯一不同的是，前者可以在这个注 释中用表达式 
B <!--  -->注释的内容在客户端是可见的
C <%--  --%>注释的内容在客户端是可见的 
D <%--  --%>这个注释虽然写在JSP程序中，但是不会发送给用户 
13   下面JSP内置对象作用范围最大的是（B）application>session>request>page=其他的 
A page  B Application  C Session  D Request 
14   下面有关Struts2框架说法不正确的是（B）
A  Struts2采用过滤器Dispatcher截获客户请求，确定适当的Action表对请求进行逻
辑处理
B  Struts2中对用Action中只能采用execute方法用来进行信息（逻辑）处理 
C  Struts2也能采用其他方法（如find()）只需在struts.xml配置Action时，制定method 参数
D  要使Struts2机制在web请求中生效，必须在Web.xml配置<filter>
★考核知识点:strusts

15   ORM系统一般以中间件的形式存在，实现程序对象到关系数据库数据的映射下面哪个部分不属于ORM组成？（B）
  A  对持久类对象进行CRUD操作的API 
B  用于访问数据库的SQL语句 
C  规定mapping metadata的工具  
D  可以让ORM实现同事物对象一起进行dirty checking，lazy association fetching和其他优化操作的技术
16  在三层结构中，数据访问层承担的责任是（B）〔选一项〕
a) 定义实体类
b) 数据的增删改查操作
c) 业务逻辑的描述
d) 页面展示和控制转发
17  下面关于数据持久化概念的描述，错误的是（D〔选择一项〕
a) 保存在内存中数据的状态是瞬时状态
b) 持久状态的数据在关机后数据依然存在
c) 数据可以由持久状态转换为瞬时状态
d) 将数据转换为持久状态的机制称为数据持久化
状态:瞬时，持久，脱管
18  下面关于Hibernate的说法，错误的是（C）〔选择一项〕
a) Hibernate是一个“对象-关系映射”的实现
b) Hibernate是一种数据持久化技术
c) Hibernate是JDBC的替代技术
d) 使用Hibernate可以简化持久化层的编码
19 Hibernate配置文件中，不包含下面的（AB）〔选择二项〕
a) “对象-关系映射”信息
b) 实体间关联的配置
c) show_sql等参数的配置
d) 数据库连接信息
20 在Hibernate关系映射配置中，inverse属性的含义是（B）。〔选择一项〕
a) 定义在<one-to-many>节点上，声明要负责关联的维护
b) 声明在<set>节点上，声明要对方负责关联的维护
c) 定义在<one-to-many>节点上，声明对方要负责关联的维护
d) 声明在<set>节点上，声明要负责关联的维护
21 在使用了Hibernate的系统中，要想在删除某个客户数据的同时删除该客户对应的所有订单数据，下面方法可行的是（B。〔选择一项〕
a) 配置客户和订单关联的cascade属性为save-update
b) 配置客户和订单关联的cascade属性为all
c) 设置多对一关联的inverse属性为true
d) 设置多对一关联的inverse属性为false
22 下面一对多关联的配置中，存在哪些错误（BD）。
<set name="orders" inverse="false" cascade="true">
<one-to-many class="com.x.entity.Order"
         column="customer_id" />
</set>
a) inverse属性不可以设置为false
b) cascade属性不可设置为true
c) class="com.x.entity.Order"应为type="com.x.entity.Order"
d) column属性不可再<one-to-many>节点内设置
23 执行下面的hql查询，关于返回值的说法，正确的是（B）。
    select  u.username,u.userid
      from  com.x.entity.User u
   where u is not null
a) 语法错误，不能执行
b) 返回一个类型为List的实例
c) 返回一个数组
d) 当返回结果只有一条时，返回一个数组
24 下面创建Criteria对象的语句中正确的是（D）。
a) Criteria c = query.createCriteria();
b) Criteria c = query.addCriteria();
c) Criteria c = session.createCriteria();
d) Criteria c = session.createCriteria(User.class);
25 一般情况下，关系数据模型与对象模型之间有哪些匹配关系（ACD多选）
a) 表对应类
b) 记录对应对象
c) 表的字段对应类的属性
d) 表之间的参考关系对应类之间的依赖关系
26 以下关于SessionFactory的说法哪些正确？BC
a) 对于每个数据库事务，应该创建一个SessionFactory对象
b) 一个SessionFactory对象对应一个数据库存储源。
c) SessionFactory是重量级的对象，不应该随意创建。如果系统中只有一个数据库存储源，只需要创建一个。
d) SessionFactory的load()方法用于加载持久化对象
27 Customer类中有一个Set类型的orders属性，用来存放Order订单对象，在Customer.hbm.xml文件中，用哪个元素映射orders属性？AB
a) <set>
b) <one-to-many>
c) <many-to-one>
d) <property>
28 <set>元素有一个cascade属性，如果希望Hibernate级联保存集合中的对象，casecade属性应该取什么值？（D）〔选择一项〕
a) none
b) save
c) delete
d) save-update
29 以下哪些属于Session的方法？ABD
a) load()
b) save()
c) open()
d) saveOrUpdate()
30 创建序列时，若未指定Cycle选项，则当当前值大于MaxValue时将（）〔选择一项〕
a) 从MinValue重新开始循环
b) 重复使用MaxValue 值
c) 执行出错
d) 使用随机值
31 以下程序的打印结果是什么？C
tx = session.beginTransaction();
Customer c1=(Customer)session.load(Customer.class,new Long(1));
Customer c2=(Customer)session.load(Customer.class,new Long(1));
System.out.println(c1==c2);
tx.commit();
session.close();
a) 运行出错，抛出异常
b) 打印false
c) 打印true
d) 编译出错
32 以下程序代码对Customer的name属性修改了两次：B
tx = session.beginTransaction();
Customer customer=(Customer)session.load(Customer.class,
                              new Long(1));
customer.setName(\"Jack\");
customer.setName(\"Mike\");
tx.commit();
执行以上程序，Hibernate需要向数据库提交几条update语句？（单选）
a) 0
b) 1
c) 2
d) 3
33 在持久化层，对象分为哪些状态？（ACD多选）
a) 瞬时(Transient)
b) 新建(New)
c) 脱管(Detached)
d) 持久(Persistent)
34 对于以下程序，Customer对象在第几行变为持久化状态？（B单选）
Customer customer=new Customer(); 
customer.setName(\"Tom\");  
Session session1=sessionFactory.openSession(); 
Transaction tx1 = session1.beginTransaction();  //line1
session1.save(customer);  //line2
tx1.commit();  //line3
session1.close(); //line4
a) line1
b) line2
c) line3
d) line4
35 对于以下程序，Customer对象在第几行变为游离状态？（D）
Customer customer=new Customer(); 
customer.setName(\"Tom\");  
Session session1=sessionFactory.openSession(); 
Transaction tx1 = session1.beginTransaction();  //line1
session1.save(customer);  //line2
tx1.commit();  //line3
session1.close(); //line4
a) line1
b) line2
c) line3
d) line4

南开《J2EE信息系统设计》复习资料-刘杨多选题答案

二、主观部分：
（一）、简答
1Java EE模块主要有哪4种基本类型？简述其构成。.
★考核知识点：JAVAEE模块的基本类型
附：EJB 模块：包含企业 Bean 的类文件和一个 EJB 配置描述文件。EJB 模块包装成扩展名为.jar 的 JAR 文件。
Web 模块：包括 JSP 文件、Servlet 类文件、HTML 文件、图形文件和一个 Web 配置描 述文件。Web 模块被打包成扩展名为.war 的 WAR（Web Archive File，Web 应用档案） 文件。
资源适配器模块：包含所有的 Java 接口、类、本地库、其他文档和资源适配器配置描 述 文 件 。它 们 是 实 现 了 某 个 特定  EIS  的 连接器 体 系 结 构 （ Java  EE  Connector Architecture）。资源适配器模块被包装成扩展名为.jar 的 JAR 文件。
应用程序客户端模块：包含类文件和一个应用程序客户端配置描述符。应用程序客户 端模块被包装成扩展名为.jar 的 JAR 文件。
2  列举java.sql.Connection接口的常用方法。
★考核知识点:java中的类和接口使用方法
附：
 createStatement()创建一个 Statement 对象，用于发送SQL 语句给数据库服务器。
 prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)：为一条带参数的SQL语句生成PreparedStatement对象(预编译对象)。
 commit()：提交事务，这个方法只有在手动事务提交模式下才有效。
 close()：关闭数据库连接，释放资源。
3 简述JSF应用的基本组成部分。
★考核知识点:jsf应用    
  附：
JSF应用也需要运行在Servlet容器中，通常包含以下几个组成部分：
a) 包含UI标签的页面(JSP页面)；
b) 辅助Bean类，用于传递数据和执行处理；
c) 验证器、转换器、事件监听器；
d) 其它JavaBean组件；  
e) 应用配置文件(web.xml、faces-config.xml)。
4 列举5个以上Query接口的主要方法。
★考核知识点:Query接口     
  附：
a) int executeUpdate()
i. 用于执行update或delete语句。如果Query对象的查询语句为select将抛出IllegalStateException异常，如果事务不存在将抛出TransactionRequiredException异常。
b) List getResultList()
i. 用于执行select语句并返回结果集实体列表。如果Query对象的查询语句为update或delete将抛出IllegalStateException异常。
c) Object getSingleResult()
i. 用于执行只返回单个结果实体的select语句。如果查询语句为update或delete则抛出IllegalStateException异常；如果没有得到返回结果将抛出EntityNotFoundException异常；如果返回多于一个结果将抛出NonUniqueResultException异常；
d) Query setFirstResult(int startPosition)
i. 用于设置从哪个实体记录开始返回查询结果。如果参数为负数将抛出IllegalArgumentException异常。
e) Query setMaxResults(int maxResult)
i. 用于设置返回结果实体的最大数。如果参数为负数将抛出IllegalArgumentException异常。与setFirstResult结合使用可实现分页查询。
5 Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)
★考核知识点:继承和接口
附：
匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现
6 Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别
★考核知识点:set中的元素
附：
Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等，equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值
7  导致session生命期结束的主要因素有哪些？
★考核知识点：session
附：
导致session生命期结束的主要因素有：
① 客户端关闭浏览器窗口，主动结束一次会话；
② Web服务器关闭，session对象及其属性将被注销；
③ 用户长时间没有访问请求，导致session超时，session对象将被删除；
④ 程序调用session.invalidate()方法主动结束会话，session对象将被删除。
8 列举java.sql.ResultSet接口的5种以上常用方法：
★考核知识点：接口
附：
（1） next()、last()等：移动记录指针。
（2） getString(String column Name)/getString(int columnIndex)、getByte()、getDate()、getTime()等：读取当前记录的指定字段值。
（3） updateString(String columnName, String x)等：更新当前记录指定字段值。
（4） updateRow()：用当前记录的新值更新数据库数据。
（5） deleteRow()：删除当前记录。

9 Java EE模块主要有哪4种基本类型？简述其构成。
★考核知识点：JaveEE基本类型
附：
EJB 模块：包含企业 Bean 的类文件和一个 EJB 配置描述文件。EJB 模块包装成扩展名为.jar 的 JAR 文件。
Web 模块：包括 JSP 文件、Servlet 类文件、HTML 文件、图形文件和一个 Web 配置描 述文件。Web 模块被打包成扩展名为.war 的 WAR（Web Archive File，Web 应用档案） 文件。
资源适配器模块：包含所有的 Java 接口、类、本地库、其他文档和资源适配器配置描 述 文 件 。它 们 是 实 现 了 某 个 特定  EIS  的 连接器 体 系 结 构 （ Java  EE  Connector Architecture）。资源适配器模块被包装成扩展名为.jar 的 JAR 文件。
应用程序客户端模块：包含类文件和一个应用程序客户端配置描述符。应用程序客户 端模块被包装成扩展名为.jar 的 JAR 文件。
10 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递
★考核知识点：参数的传递
附：
是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的
11谈谈final, finally, finalize的区别
★考核知识点：final,finally,finalize关键字
附:
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的
12简述response的sendRedirect()与RequestDispatcher的forward()两种方法执行页面跳转的异同点。
★考核知识点：页面跳转
附：
第一点区别，过程不同：第一种方式相当于浏览器接收到了响应之后又向服务器发送了一次请求，所以相当于两次请求。第二种方式相当于方法调用，在执行当前文件的过程中转向执行目标文件，两个文件（当前文件和目标文件）属于同一次请求，最本质的特点就是两次请求共享了reques对象和response对象。
第二点区别，地址栏不同：第一种方式下用户在浏览器地址栏中看到的是目标文件的地址，第二种方式下用户在浏览器地址栏中看到的是当前文件的地址。
13 heap和stack有什么区别
★考核知识点：heap和stack的区别
附：
栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。堆是栈的一个组成元素
14 Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型
★考核知识点：返回值类型
附：
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型
15.Spring框架的优点都有什么？
Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分
Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高
依赖注入和IoC使得JDBC操作简单化
Spring是开源的免费的
Spring使得对象管理集中化合简单化
16.描述一下Spring中实现DI（Dependency Injection）的几种方式
方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。
方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去
方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入Spring的方式
17.简述你对IoC（Inversion of Control）的理解
一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C的实例，但这种方法显然两者的依赖（Dependency）太大了。而IoC的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的实现C放入IoC的 容器（Container）中，通过一定的配置由容器（Container）来实现类A与接口B的实现C的关联。
18. 简述AOP核心？
1）Aspect（切面） 切面，是对交叉业务逻辑的统称。
2）Joinpoint（连接点） 连接点，指切面可以织入到目标对象的位置（方法，属性等）。
3）Advice（通知） 通知，指切面的具体实现。
4）Pointcut（切入点） 切入点，指通知应用到哪些类的哪些方法或属性之上的规则。
5）Introduction（引入） 引入，指动态地给一个对象增加方法或属性的一种特殊的通知。
6）Weaving（织入） 织入，指将通知插入到目标对象。
7）Target（目标对象） 目标对象，指需要织入切面的对象。
8）Proxy（代理对象） 代理对象，指切面织入目标对象之后形成的对象。
19. EJB包括（SessionBean,EntityBean）说出他们的生命周期？
SessionBean：Stateless Session Bean 的生命周期是由容器决定的，当客户机发出请求要建立一个Bean的实例时，EJB容器不一定要创建一个新的Bean的实例供客户机调用，而是随便找一个现有的实例提供给客户机。当客户机调用了@PreDestroy修饰的方法时候，它就结束了。当客户机第一次调用一个Stateful Session Bean 时，容器必须立即在服务器中创建一个新的Bean实例，并关联到客户机上，以后此客户机调用Stateful Session Bean 的方法时容器会把调用分派到与此客户机相关联的Bean实例。
EntityBean：Entity Beans能存活相对较长的时间，并且状态是持续的。只要数据库中的数据存在，Entity beans就一直存活。而不是按照应用程序或者服务进程来说的。即使EJB容器崩溃了，Entity beans也是存活的。Entity Beans生命周期能够被容器或者 Beans自己管理。
20.如何在Spring的applicationContext.xml里面使用JNDI而不是datasource?
可以使用”org.springframework.jndi.JndiObjectFactoryBean”来实现。示例如下：
<bean id=”dataSource”>
<property name=”jndiName”>
<value>java:comp/env/jdbc/appfuse</value>
</property>
</bean>
21.Spring里面如何配置数据库驱动？
使用”org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下：
<bean id=”dataSource”>
<property name=”driverClassName”>
<value>org.hsqldb.jdbcDriver</value>
</property>
<property name=”url”>
<value>jdbc:hsqldb:db/appfuse</value>
</property>
<property name=”username”><value>sa</value></property>
<property name=”password”><value></value></property>
</bean>
22.Spring里面applicationContext.xml文件能不能改成其他文件名？
ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下， 它会在WEB-INF/applicationContext.xml文件找Spring的配置。 你可以通过定义一个<context-param>元素名字为”contextConfigLocation”来改变Spring配置文件的位置。示例如下：
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/xyz.xml</param-value>
</context-param>
</listener-class>
</listener>
23.如何在web应用里面配置spring?
在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
24.Spring里面如何定义hibernate mapping？
添加hibernate mapping 文件到web/WEB-INF目录下的applicationContext.xml文件里面。示例如下：
<property name=”mappingResources”>
<list>
<value>org/appfuse/model/User.hbm.xml</value>
</list>
</property>

25  名词解释
1 Annotation：
2 泛型：
附：
（1） Annotation：标注，是Java EE 5中引入的一项小特性，也是一项十分有效的新特性。标注本质上是一种元数据，通过在Java代码中加入元数据信息（Meta Data），从而指导工具和库对代码的处理。
（2） 泛型：Java EE 5通过引入泛型，允许约定集合元素的类型来获得强类型检查，避免等到运行时出现类型转换错误，也可免除显式的强制类型转换(cast)。
26   名词解释
EJB：
附：
EJB是EnterpriseJavaBeans 的缩写，又称为企业 Bean，是一种Java服务器端组件模型。 EJB提供了服务器上的自治、企业级和分布式功能，并能帮助开发者在不同粒度级别上定 义和封装系统功能。
27 名词解释
JPA：
附：
（JavaPersistenceAPI，Java持久化 API），是 JavaEE5 规范中用于对象/关系映射（O/R）的一组 API，它是 SUN官方的对象/关系映射模型。JPA规范详细阐述了实体 Bean 的定义、实体 Bean支持的注释、全新的查询语言、实体管理接口、容器实现规范等内容
28  列举JDBC编程常用的接口和类。
附：
a) java.sql.Driver接口
b) java.sql.DriverManager类
c) java.sql.Connection接口
d) java.sql.Statement接口
e) java.sql.ResultSet接口

（四）、编程题
1  下面是一个图像缩放程序，请按要求填写下划线部分的语句。
Import  java.applet.*;
Import  java.awt.*;
Public  class  Test9_3  extends  Applet{
Image  img;
Public  void  init(){
img=getImage(getCodeBase(),"disk.gif");
}

Public  void  paint(Graphics  g){
Int  w=img.getWidth(this);
Int  h=       ①        //读取图片的高度
g.drawImage(img,20,40,this);
g.         ①         将图片缩小1/2显示
g.         ①         //将图片扩大1倍显示
}}
附：答案
①img.getHeight(this);
②drawImage(img,100,100,w/2,h/2,this)
③drawImage(img,160,10,w*2,h*2,this);
2 编程：编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。
附：答案
package test;
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.length()/Split
Byte+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 void main(String[] args)
{
  SplitString ss = new SplitString("test中dd文dsaf中男大3443n中国43中国人
0ewldfls=103",4);
  ss.SplitIt();
}
}
3 编写程序获取已知文件的扩展名. 注意: abc.txt的扩展名是txt, abc.java.txt的扩展名也是txt。
附：
publicclass ExtensionDemo {
publicstaticvoid main(String[] args) {
String str = "abc.java.txt";
String name=str.substring(str.lastIndexOf(".")+1);
System.out.println(name);
4 将一个键盘输入的数字转化成中文输出
附:
(例如:输入:1234567     输出:一百二拾三万四千五百六拾七)
用java语言实现,,请编一段程序实现!
public class Reader {
  private String strNum;
  private String strNumChFormat;
  private String strNumTemp;
  private int intNumLen;
  private String strBegin;
  public Reader(String strNum) {
    this.strNum = strNum;
  }
  public boolean check(String strNum) {
    boolean valid = false;
   
    if (strNum.substring(0,1).equals("0")){
     this.strNum = strNum.substring(1);
    }
    try {
      new Double(strNum);
      valid = true;
    }
    catch (NumberFormatException ex) {
      System.out.println("Bad number format!");
    }
    return valid;
  }
  public void init() {
    strNumChFormat = "";
    intNumLen = strNum.length();
    strNumTemp = strNum;
    strNumTemp = strNumTemp.replace('1', '一');
    strNumTemp = strNumTemp.replace('2', '二');
    strNumTemp = strNumTemp.replace('3', '三');
    strNumTemp = strNumTemp.replace('4', '四');
    strNumTemp = strNumTemp.replace('5', '五');
    strNumTemp = strNumTemp.replace('6', '六');
    strNumTemp = strNumTemp.replace('7', '七');
    strNumTemp = strNumTemp.replace('8', '八');
    strNumTemp = strNumTemp.replace('9', '九');
    strNumTemp = strNumTemp.replace('0', '零');
    strNumTemp = strNumTemp.replace('.', '点');
    strBegin = strNumTemp.substring(0, 1);
  }
  public String readNum() {
    if (check(strNum)) {
      init();
      try {
        for (int i = 1, j = 1, k = 1; i < intNumLen; i++) {
          if (strNumTemp.charAt(intNumLen - 1) == '零' && i == 1) {
            strNumChFormat = "位";
          }
          else if (strNumTemp.charAt(intNumLen - i) == '零' && j == 1) {
            strNumChFormat = "位" + strNumChFormat;
          }
          else if (strNumTemp.charAt(intNumLen - i) == '点') {
            j = 1;
            k = 1;
            strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
            continue;
          }
          else {
            strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
          }
          if (strNumTemp.charAt(intNumLen - i - 1) != '位' &&
              strNumTemp.charAt(intNumLen - i - 1) != '零') {
            if (j == 1 && i < intNumLen) {
              strNumChFormat = '拾' + strNumChFormat;
            }
            else if (j == 2 && i < intNumLen) {
              strNumChFormat = '百' + strNumChFormat;
            }
            else if (j == 3 && i < intNumLen) {
              strNumChFormat = '千' + strNumChFormat;
            }
          }
          if (j == 4 && i < intNumLen) {
            j = 0;
          }
          if (k == 4 && i < intNumLen) {
            strNumChFormat = '万' + strNumChFormat;
          }
          else if (k == 8 && i < intNumLen) {
            k = 0;
            strNumChFormat = '亿' + strNumChFormat;
          }
          j++;
          k++;
        }
        while (strNumChFormat.indexOf("位") != -1) {
          strNumChFormat = strNumChFormat.replaceAll("位", " ");
        }
        if (strNumChFormat.substring(0, 2) == "一拾") {
          strNumChFormat = strNumChFormat.substring(1, strNumChFormat.length());
        }
        if (strNumChFormat.indexOf("点") >= 0) {
          String rebegin = strNumChFormat.substring(0,
              strNumChFormat.indexOf("点"));
          String relast = strNumChFormat.substring(strNumChFormat.indexOf("点"),
              strNumChFormat.length());
          for (int i = 1; i <= relast.length(); i++) {
            relast = relast.replaceAll("拾", "");
            relast = relast.replaceAll("百", "");
            relast = relast.replaceAll("千", "");
            relast = relast.replaceAll("万", "");
            relast = relast.replaceAll("亿", "");
          }
          strNumChFormat = rebegin + relast;
        }
      }
      catch (ArrayIndexOutOfBoundsException ex) {
        ex.printStackTrace();
      }
      catch (Exception ex) {
        ex.printStackTrace();
      }
      int off = strNumChFormat.indexOf("点");
      strNumChFormat = strBegin + strNumChFormat.substring(0);
    }
    else {
      strNumChFormat = "";
    }
    return strNumChFormat;
  }
  public static void main(String args[]) {
    try {
      String number = args[0].toString();
      System.out.println("The number is: " + number);
      Reader reader = new Reader(number);
      System.out.println("Output String: " + reader.readNum());
    }
    catch (Exception ex) {
      System.out.println("Please input like that: javac Reader <number>");
    }
  }
}


5 设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。
附:
public class ThreadTest1{
  private int j;
  public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.start();
}
}
  private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
  }
  private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
  }
  class Inc implements Runnable{
public void run(){
for(int i=0;i<100;i++){
inc();
}
}
  }
  class Dec implements Runnable{
public void run(){
for(int i=0;i<100;i++){
dec();
}
}
  }
}
6定义一个学生类, 需要有姓名, 年龄, 考试成绩三个成员属性. 属性(成员变量)需要私有并提供get, set方法, 可以通过构造函数进行初始化。
附:
publicclass StudentDemo {
private String name;
privateint age;
privateint score;
public StudentDemo(String name, int age, int score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
publicvoid setName(String name) {
this.name = name;
}
publicint getAge() {
return age;
}
publicvoid setAge(int age) {
this.age = age;
}
publicint getScore() {
return score;
}
publicvoid setScore(int score) {
this.score = score;
}
}
7使用上一题定义的学生类创建5个对象, 属性可为任意值. 编程对这5个对象按成绩排序, 并将结果输出。
附：
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

publicclass ScoreSort {
private StudentDemo stu1;
private StudentDemo stu2;
private StudentDemo stu3;
private StudentDemo stu4;
private StudentDemo stu5;
private List<StudentDemo> list = new ArrayList<StudentDemo>();
public ScoreSort() {
super();
stu1 = new StudentDemo("zhangfei",40,85);
list.add(stu1);
stu2 = new StudentDemo("zhaoyun",41,70);
list.add(stu2);
stu3 = new StudentDemo("guanyu",42,80);
list.add(stu3);
stu4 = new StudentDemo("huangzhong",43,90);
list.add(stu4);
stu5 = new StudentDemo("liubei",44,75);
list.add(stu5);
}
publicvoid sort(){
ContentCompare comp = new ContentCompare();
Collections.sort(list,comp);
for(int i=0;i<list.size();i++){
StudentDemo stu = list.get(i);
System.out.println(stu.getName());
}
}
publicstaticvoid main(String[] args) {
ScoreSort ss = new ScoreSort();
ss.sort();
}
class ContentCompare implementsComparator{
@Override
publicint compare(Object o1, Object o2) {
StudentDemo s1 = (StudentDemo)o1;
StudentDemo s2 = (StudentDemo)o2;
if(s1.getScore()>s2.getScore()){
return 1;
}elseif(s1.getScore()==s2.getScore()){
return 0;
}else{
return -1;
}
}
}
}
8 已知一个int数组，编程从数组中获取最大值。
附：
class ArrDemo
{
public static void main(String[] args){
int[] arr = {4,2,6,9,8};
int temp;
for(int j=0;j<arr.length-1;j++){
for(int i=0;i<arr.length-1;i++){
temp = arr[i];
if(arr[i]<arr[i+1]){
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
}
System.out.println(arr[0]);
}
}

9、编写HTML注册表单, 需要字段: 用户名, 密码, 确认密码, 性别(单选), 城市(下拉列表), 兴趣爱好(多选), 个人简介(文本域)。（10分）
答：
<form>
用户名：<input type="text" name="username"><br>
密码：<input type="password" name="pwd"><br>
确认密码：<input type="password" name="repwd"><br>
性别(单选)：
女 <input type="radio" value="female"  name="sex" checked>
男<input type="radio" value="male" name="sex"><br>
城市(下拉列表)：
<select name="city">
<option value="nanchang">南昌</option>
<option value="jiujiang" selected>九江</option>
<option value="shangrao">上饶</option>
<select>
<br>
兴趣爱好(多选)：
游泳<input type="checkbox" name="interest">
骑马<input type="checkbox"  name="interest">
踢球<input type="checkbox"  name="interest">
<br>
个人简介(文本域）：
<textarea name="comment" cols="30" rows="9" wrap="soft"></textarea>
</form>
10、使用JavaScript验证第9题的HTML表单. 用户名: 必须是字母数字或下划线, 不能以数字开头. 密码: 6-16位字母数字下划线. 确认密码: 和密码一致. 其他项为必填。
<script type=”text/javascript”>
Function checkName(){
Var regex = /^[a-zA-Z]{1}[\w]*/;
Var name = document.username.value;
If(regex.exec(name)){
Alert(“匹配成功”);
}else{
Alert(“匹配不成功”);
}
}
Function checkPassword(){
Var regex = /[\w]{6,16}/;
Var pwd = document.pwd.value;
If(regex.exec(pwd)){
Alert(“匹配成功”);
}else{
Alert(“匹配不成功”);
}
}
Function checkRepwd(){
Var pwd = document.pwd.value;
Var repwd = document.repwd.value;
If(pwd==repwd){
Alert(“匹配成功”);
}else(
Alert(“匹配不成功”);
)
}
Function checkForm(){
If(document.form.name.value=-1){
Alert(“必填”);
Return false;
}
}
</script>
11编写程序拷贝一个文件. 尽量使用效率高的方式。
答：
public class Test {
public static void main(String[] args){
try {
FileInputStream in = new FileInputStream("f:\\ 1.txt");
FileOutputStream out = new FileOutputStream("f:\\2.txt");
copyFile(in, out);
in.close();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}

public static void copyFile(InputStream in,OutputStream out) {
BufferedInputStream bin = new BufferedInputStream(in);
BufferedOutputStream bos = new BufferedOutputStream(out);
int ch;
try {
while ((ch = bin.read()) != -1) {
}
bos.write(ch);
bin.close();
bos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
12 、编写一个 Servlet ，实现输出：“你好 ！ACCP ”。要求：实现必须实现 Servlet 生命周期的各个方法的调用过程．
public class HelloServl et exteods HttpServlet {
public Hell oServletO { super();
II初始比方法
public void i nit() throws ServletException {
System.out.println （“初始化时，init（）方法被调用 ！”）；



//doGet（）方法
public void  doGet(H ttpServletRequest  request, HttpServletResponse  response)  throws ServletException, IOException{
System.out.println（“处理请求时，doGet（）方法被调用！”），
response.setCouteutType（“text/htntl;charset=GBK”）； PrintWrirer out = response.getWriter();
out.print!11（“＜bttnJ＞”）；
out.println （“ <head><title>Ser飞怕＜／title></head         ＞”）； out.println（“ ＜body＞你好   ！ACCP</body＞”）， out.printlu（“＜/html＞”）；
out. flush();
out.close();

//doPost（）方法
public void doPostt(HttµServletReq uest request, HttpServletResponse  response)  throws Sen’l etException, IOExcepti oo{
doGet(request,response);
//用于释放资源
public void destroy() { super.destroy();
System.out.printl叫“释放系统资源时，destroy（）方法被调用”）；
}
}
13 在y2javaee.sg.ch06包下建立Env.java文件，实现对db.properties文件的加载工作，要求：必须使用单例模式创建，获得对象实例。
package  y2javaee.sg.ch06; itnport java.io.lnputStrean1; import
java.util .Properties;
public final class Env extends Properties{ private static Env instance;
public static Env getlnsta nceO{ i f(insta nce != null){
return instance;
}
else{
makelnstanceO; return instance;
private  static synchronized  void  makelnstan白 ｛
if(instance =null) instance = new Env();
private EnvO{
lnputStrea1n is =  getC!ass().getResourceAsStream("/db.properties”）；
try {
load(is);
}
catch(Exception e)
{
System .err.pr intln（“错误：没有读取属性文件，”＋ “消确认 db.property  文件是否存在。” ），
}}}

南开《J2EE信息系统设计》复习资料-刘杨历年参考题目如下：