由于session会消耗内存资源，因此，如果不打算使用session，应该在所有的JSP中关闭它。

2、session何时被删除
综合前面的讨论，session在下列情况下被删除a.程序调用HttpSession.invalidate();或b.距离上一次收到客户端发送的session id时间间隔超过了session的超时设置;或c.服务器进程被停止（非持久session）

3、如何做到在浏览器关闭时删除session
严格的讲，做不到这一点。可以做一点努力的办法是在所有的客户端页面里使用javascript代码window.oncolose来监视浏览器的关闭动作，然后向服务器发送一个请求来删除session。但是对于浏览器崩溃或者强行杀死进程这些非常规手段仍然无能为力。

4、有个HttpSessionListener是怎么回事
你可以创建这样的listener去监控session的创建和销毁事件，使得在发生这样的事件时你可以做一些相应的工作。注意是session的创建和销毁动作触发listener，而不是相反。类似的与HttpSession有关的listener还有HttpSessionBindingListener，HttpSessionActivationListener和HttpSessionAttributeListener。

5、存放在session中的对象必须是可序列化的吗
不是必需的。要求对象可序列化只是为了session能够在集群中被复制或者能够持久保存或者在必要时server能够暂时把session交换出内存。在Weblogic Server的session中放置一个不可序列化的对象在控制台上会收到一个警告。我所用过的某个iPlanet版本如果session中有不可序列化的对象，在session销毁时会有一个Exception，很奇怪。

6、如何才能正确的应付客户端禁止cookie的可能性
对所有的URL使用URL重写，包括超链接，form的action，和重定向的URL，具体做法参见[6]
http://e-docs.bea.com/wls/docs70/webapp/sessions.html#100770

7、开两个浏览器窗口访问应用程序会使用同一个session还是不同的session
参见第三小节对cookie的讨论，对session来说是只认id不认人，因此不同的浏览器，不同的窗口打开方式以及不同的cookie存储方式都会对这个问题的答案有影响。

8、如何防止用户打开两个浏览器窗口操作导致的session混乱
这个问题与防止表单多次提交是类似的，可以通过设置客户端的令牌来解决。就是在服务器每次生成一个不同的id返回给客户端，同时保存在session里，客户端提交表单时必须把这个id也返回服务器，程序首先比较返回的id与保存在session里的值是否一致，如果不一致则说明本次操作已经被提交过了。可以参看《J2EE核心模式》关于表示层模式的部分。需要注意的是对于使用javascript window.open打开的窗口，一般不设置这个id，或者使用单独的id，以防主窗口无法操作，建议不要再window.open打开的窗口里做修改操作，这样就可以不用设置。

9、为什么在Weblogic Server中改变session的值后要重新调用一次session.setValue
做这个动作主要是为了在集群环境中提示Weblogic Server session中的值发生了改变，需要向其他服务器进程复制新的session值。

10、为什么session不见了
排除session正常失效的因素之外，服务器本身的可能性应该是微乎其微的，虽然笔者在iPlanet6SP1加若干补丁的Solaris版本上倒也遇到过；浏览器插件的可能性次之，笔者也遇到过3721插件造成的问题；理论上防火墙或者代理服务器在cookie处理上也有可能会出现问题。
出现这一问题的大部分原因都是程序的错误，最常见的就是在一个应用程序中去访问另外一个应用程序。

注意这个输出包括了时区信息：GMT-04:00 和 PM EDT。这个时区是人系统的时区设置里捕获的。你可以看见，日期是以那个地区的用户期望的格式显示的。让我们等一下来看看时区的概念

时区
TimeZone类，即java.util.TimeZone类的实例包含了一个与格林威治标准时间（GMT）相比较得出的以微秒为单位的时区偏移量，而且它还处理夏令时
。要获得一个所有支持的进区的列表，你可以使用方法TimeZone.getAvailableIDs，它将返回一个包含了所有进区ID的字符串数组。要知道关于TimeZone类的更多细节，可以参看Sun公司的Web站点。

为了演示这个概念，我们将创建三个时区对象。第一个对象将使用getDefault从系统时钟返回时区数据；第二个和第三个对象将传入一个时区字符串ID。见表C中的代码。

表 C

代码内容 import java.util.TimeZone; import java.util.Date; import java.text.DateFormat; import java.util.Locale; public class DateExample8 { public static void main(String[] args) { // Get the system time zone. TimeZone timeZoneFL = TimeZone.getDefault(); System.out.println(" " + timeZoneFL.getDisplayName()); System.out.println("RawOffset: " + timeZoneFL.getRawOffset()); System.out.println("Uses daylight saving: " + timeZoneFL.useDaylightTime()); TimeZone timeZoneLondon = TimeZone.getTimeZone("Europe/London"); System.out.println(" " + timeZoneLondon.getDisplayName()); System.out.println("RawOffset: " + timeZoneLondon.getRawOffset()); System.out.println("Uses daylight saving: " + timeZoneLondon.useDaylightTime()); TimeZone timeZoneParis = TimeZone.getTimeZone("Europe/Paris"); System.out.println(" " + timeZoneParis.getDisplayName()); System.out.println("RawOffset: " + timeZoneParis.getRawOffset()); System.out.println("Uses daylight saving: " + timeZoneParis.useDaylightTime()); } }

其输出如下：

代码内容 Eastern Standard Time RawOffset: -18000000 Uses daylight saving: true GMT+00:00 RawOffset: 0 Uses daylight saving: true Central European Standard Time RawOffset: 3600000 Uses daylight saving: true

正如你所看见的，TimeZone对象给我们的是原始的偏移量，也就是与GMT相差的微秒数，而且还会告诉我们这个时区是否使用夏令时。有个这个信息，我们就能够继续将时区对象和日期格式化器结合在一起在其它的时区和其它的语言显示时间了。

国际化的时期显示了时区转换
让我们来看一个结合了国际化显示，时区和日期格式化的例子。表D为一个在迈阿密和巴黎拥有办公室的公司显示了当前的完整日期和时间。对于迈阿密的办公室，我们将在每个办公室里用英语显示完整的日期和时间。对于巴黎的办公室，我们将用法语显示完整的当前日期和时间。

表 D

代码内容 import java.util.TimeZone; import java.util.Date; import java.util.Locale; import java.text.DateFormat; public class DateExample9 { public static void main(String[] args) { Locale localeEN = Locale.US; Locale localeFrance = Locale.FRANCE; TimeZone timeZoneMiami = TimeZone.getDefault(); TimeZone timeZoneParis = TimeZone.getTimeZone("Europe/Paris"); DateFormat dateFormatter = DateFormat.getDateTimeInstance( DateFormat.FULL, DateFormat.FULL, localeEN); DateFormat dateFormatterParis = DateFormat.getDateTimeInstance( DateFormat.FULL, DateFormat.FULL, localeFrance); Date curDate = new Date(); System.out.println("Display for Miami office."); // Print the Miami time zone display name in English System.out.println(timeZoneMiami.getDisplayName(localeEN)); // Set the time zone of the dateFormatter to Miami time zone. dateFormatter.setTimeZone(timeZoneMiami); // Print the formatted date. System.out.println(dateFormatter.format(curDate)); // Set the time zone of the date formatter to Paris time zone. dateFormatter.setTimeZone(timeZoneParis); // Print the Paris time zone display name in English. System.out.println(timeZoneParis.getDisplayName(localeEN)); // Print the Paris time in english. System.out.println(dateFormatter.format(curDate)); System.out.println(" Display for Paris office."); // Print the Miami time zone display name in French System.out.println(timeZoneMiami.getDisplayName(localeFrance)); // Set the timezone of the // dateFormatterParis to Miami time zone. dateFormatterParis.setTimeZone(timeZoneMiami); // Print the formatted date in French. 燬ystem.out.println(dateFormatterParis.format(curDate)); // Set the timezone of the date formatter to Paris time zone. dateFormatterParis.setTimeZone(timeZoneParis); // Print the Paris time zone display name in French. System.out.println(timeZoneParis.getDisplayName(localeFrance)); // Print the Paris time in French. System.out.println(dateFormatterParis.format(curDate)); } }

这个例子的输出是：

代码内容 Display for Miami office. Eastern Standard Time Friday, October 5, 2001 10:28:02 PM EDT Central European Standard Time Saturday, October 6, 2001 4:28:02 AM CEST Display for Paris office. GMT-05:00 vendredi 5 octobre 2001 22 h 28 GMT-04:00 GMT+01:00 samedi 6 octobre 2001 04 h 28 GMT+02:00

在一个SQL数据库中保存和提取日期数据我们将要使用的下一个类是java.sql.Date，它是java.util.Date的子类但它使用了Java数据库连接（JDBC）方法
。让我们来看一个简单的只有一个表单－－LAST_ACCESS的ORACLE数据库，它是用下面的SQL创建的：

代码内容 create table LAST_ACCESS ( LAST_HIT date );

这个表单只有一个记录，用下面的插入语句创建：
insert into LAST_ACCESS values (Sysdate);

表E演示了如何修改和提取LAST_HIT数据库域。

表 E

代码内容 import java.sql.*; import java.text.DateFormat; import java.util.Date; public class DateExample10 { public static void main(String[] args) { // Get a full date formatter. DateFormat dateFormatter = DateFormat.getDateTimeInstance( DateFormat.FULL, DateFormat.FULL); // Get the system date and time. java.util.Date utilDate = new Date(); // Convert it to java.sql.Date java.sql.Date date = new java.sql.Date(utilDate.getTime()); // Display the date before storing. System.out.println(dateFormatter.format(date)); // Save the date to the database. setLastHit(date); // Get the date from the database. Date dateFromDB = getLastHit(); // Display the date from the database. System.out.println(dateFormatter.format(dateFromDB)); } public static void setLastHit(java.sql.Date date) { try { // Load the class. Class.forName("oracle.jdbc.driver.OracleDriver"); // Get a connection. Connection connection = DriverManager.getConnection( // Database URL "jdbc:oracle:thin:@localhost:1521:buzz2", "web_site", // Username "web_site"); // Password try { / Get a prepared statement fromthe connection // specifying the update SQL. PreparedStatement ps = connection.prepareStatement( "update LAST_ACCESS set LAST_HIT="); try { / set the date letting JDBC to the work of // formatting the SQL appropriately. ps.setDate(1, date); // Execute the update statement. int iRowsUpdated = ps.executeUpdate(); System.out.println("Rows updated: " + iRowsUpdated); } finally { ps.close(); } } finally { connection.close(); } } catch (Exception ex) { System.out.println("Error: " + ex.getMessage()); } } public static java.sql.Date getLastHit() { java.sql.Date returnDate = null; try { // Load the driver class. Class.forName("oracle.jdbc.driver.OracleDriver"); // Get the connection. Connection connection = DriverManager.getConnection( "jdbc:oracle:thin:@localhost:1521:buzz2", "web_site", "web_site"); try { / Get the prepared statement specifying the // select SQL. PreparedStatement ps = connection.prepareStatement( "select LAST_HIT from LAST_ACCESS"); try { // Execute the SQL and get the ResultSet object. ResultSet rs = ps.executeQuery(); try { // Retreive the record. if (rs else { System.out.println("Did not get last hit."); } } finally { rs.close(); } } finally { ps.close();  } finally { connection.close(); } } catch (Exception ex) { System.out.println("Error: " + ex.getMessage()); } return returnDate; } }

这个例子的输出如下：

代码内容 Friday, October 5, 2001 10:42:34 PM EDT Rows updated: 1 Successfully retrieved last hit. Friday, October 5, 2001 12:00:00 AM EDT

虽然这个例子没有为保存和提取日期数据提供性能上优良的方法，但它确实示范了如何为一条更新和删除语句将Java日期数据转换成SQL日期数据。从一个java.util.Date对象设置Oracle date数据域的过程是由以下的语句处理的：
ps.setDate(1, date);

它是我们预定义语句接口java.sql.PreparedStatement.setDate 的一个方法。

这行代码出现在我们的setLastHit方法里。它将Java以微秒为单位的长整型日期值转换成ORACLE的SQL日期格式。当我们能够在getLastHit方法里用java.sql.PreparedStatement.getDate从数据库取得日期数据的时候这种转换就能够完成。

你还应该注意到只有日期被设置了。小时，分钟，秒，和微秒都没有包括在从Java日期数据到SQL日期数据的转换过程中。

结论
一旦你掌握了这些概念，你就应该能够基于系统时间或者一个输入的时间创建日期对象了。另外，你还应该能够使用标准和定制的格式化过程格式化日期数据，将文本的日期数据解析成日期对象，并以多种语言和多种时区显示一个日期数据。最后，你将能够在一个SQL数据库里保存和提取日期值

CREATE procedure pagination1

(@pagesize int,  --页面大小，如每页存储20条记录

@pageindex int   --当前页码

)

as

set nocount on

begin

declare @indextable table(id int identity(1,1),nid int)  --定义表变量

declare @PageLowerBound int  --定义此页的底码

declare @PageUpperBound int  --定义此页的顶码

set @PageLowerBound=(@pageindex-1)*@pagesize

set @PageUpperBound=@PageLowerBound+@pagesize

set rowcount @PageUpperBound

insert into @indextable(nid) select gid from TGongwen where fariqi >dateadd(day,-365,getdate()) order by fariqi desc

select O.gid,O.mid,O.title,O.fadanwei,O.fariqi from TGongwen O,@indextable t where O.gid=t.nid

and t.id>@PageLowerBound and t.id<=@PageUpperBound order by t.id

end

set nocount off

文章中的点评：

以 上存储过程运用了SQL SERVER的最新技术――表变量。应该说这个存储过程也是一个非常优秀的分页存储过程。当然，在这个过程中，您也可以把其中的表变量写成临时表： CREATE TABLE #Temp。但很明显，在SQL SERVER中，用临时表是没有用表变量快的。所以笔者刚开始使用这个存储过程时，感觉非常的不错，速度也比原来的ADO的好。但后来，又发现了比此方 法更好的方法。

感觉：

没有做过测试，从感觉上讲，效率不是太高。

从publish 表中取出第 n 条到第 m 条的记录：
SELECT TOP m-n+1 *
FROM publish
WHERE (id NOT IN
　　　　(SELECT TOP n-1 id
　　　　 FROM publish))

id 为publish 表的关键字

文章中的点评：

 当时看到这篇文章的时候，真的是精神为之一振，觉得思路非常得好。等到后来，在作办公自动化系统（ASP.NET+ C#＋SQL SERVER）的时候，忽然想起了这篇文章，想如果把这个语句改造一下，这就可能是一个非常好的分页存储过程。于是就满网上找这篇文章，没想到，文章 还没找到，却找到了一篇根据此语句写的一个分页存储过程，这个存储过程也是目前较为流行的一种分页存储过程，很后悔没有争先把这段文字改造成存储过程：
（更多的内容，请查看原文。）

感觉：

使用了 not in  而 not in  是无法使用索引的，所以从效率上讲还是差了一点。

2. max 的方法：

select top 页大小 *

from table1

where id>

     (select max (id) from

     (select top ((页码-1)*页大小) id from table1 order by id) as T

      )    

 order by id

文章中的点评：

几乎任何字段，都可以通过max(字段)或min(字段)来提取某个字段中的最大或最小值，所以如果这个字段不重复，那么就可以利用这些不重 复的字段的max或min作为分水岭，使其成为分页算法中分开每页的参照物。在这里，可以用操作符“>”或“<”号来完成这个使命，使查 询语句符合SARG形式。如：

Select top 10 * from table1 where id>200

感觉：

这个就高高效了一点。但是不清楚 max的工作原理，不知道它的性能如何。

下面的才是重点

1、追求高效的翻页算法 —— 定位法。

declare @pageSize int   --返回一页的记录数
declare @CurPage int  --页号（第几页）0：第一页；-1最后一页。

declare @Count int
declare @id int

set @pageSize=10
set @CurPage =1

--定位
if @CurPage = -1
begin
 --最后一页
 set rowcount @pageSize
 select @id=newsID from newsTemp   order by newsID
end

if @CurPage > 0
begin
 set @Count = @pageSize * (@CurPage -1) + 1
 set rowcount @Count
 select @id=newsID from newsTemp   order by newsID desc
end

--返回记录
set rowcount @pageSize
select * from newsTemp where newsID <=@id order by newsID desc

set rowcount 0

思路：就是上面的算法的延续，就是说呢避免使用  not in 和 max 的方法。

也就是这个思路：Select top 10 * from table1 where id>200

定位 —— 就是说要找到“临界点”，分页的临界点。找到了之后剩下的事情就好办了。

缺点：单字段排序、排序字段的值不能重复（不是绝对不能重复，可以有少量的重复）。

2、通用法 —— 颠颠倒倒法

有的时候“定位法”的缺点是不可以接受的，但是没有关系，可以用这个的。

select * from table where id in 
(
 select top 10 ID from 
 (
  select top 20 ID,addedDate from table 
  order by addedDate desc
 ) as aa order by addedDate
)
order by addedDate desc

ID 是主键，addedDate 是排序字段。

缺点：必须有主键。

　　作为一个Java程序员，你至少应该能够找出两个问题。但是，如果你不能找出全部六个问题，请继续阅读本文。

　　本文讨论的不是Java异常处理的一般性原则，因为这些原则已经被大多数人熟知。我们要做的是分析各种可称为“反例”（anti-pattern）的违背优秀编码规范的常见坏习惯，帮助读者熟悉这些典型的反面例子，从而能够在实际工作中敏锐地察觉和避免这些问题。

　　反例之一：丢弃异常

　　代码：15行-18行。

　 　这段代码捕获了异常却不作任何处理，可以算得上Java编程中的杀手。从问题出现的频繁程度和祸害程度来看，它也许可以和C/C++程序的一个恶名远播 的问题相提并论??不检查缓冲区是否已满。如果你看到了这种丢弃（而不是抛出）异常的情况，可以百分之九十九地肯定代码存在问题（在极少数情况下，这段代 码有存在的理由，但最好加上完整的注释，以免引起别人误解）。

　　这段代码的错误在于，异常（几乎）总是意味着某些事情不对劲了，或 者说至少发生了某些不寻常的事情，我们不应该对程序发出的求救信号保持沉默和无动于衷。调用一下printStackTrace算不上“处理异常”。不 错，调用printStackTrace对调试程序有帮助，但程序调试阶段结束之后，printStackTrace就不应再在异常处理模块中担负主要责 任了。

　　丢弃异常的情形非常普遍。打开JDK的ThreadDeath类的文档，可以看到下面这段说明：“特别地，虽然出现 ThreadDeath是一种‘正常的情形’，但ThreadDeath类是Error而不是Exception的子类，因为许多应用会捕获所有的 Exception然后丢弃它不再理睬。”这段话的意思是，虽然ThreadDeath代表的是一种普通的问题，但鉴于许多应用会试图捕获所有异常然后不 予以适当的处理，所以JDK把ThreadDeath定义成了Error的子类，因为Error类代表的是一般的应用不应该去捕获的严重问题。可见，丢弃 异常这一坏习惯是如此常见，它甚至已经影响到了Java本身的设计。

　　那么，应该怎样改正呢？主要有四个选择：

　　1、处理异常。针对该异常采取一些行动，例如修正问题、提醒某个人或进行其他一些处理，要根据具体的情形确定应该采取的动作。再次说明，调用printStackTrace算不上已经“处理好了异常”。

　　2、重新抛出异常。处理异常的代码在分析异常之后，认为自己不能处理它，重新抛出异常也不失为一种选择。

　　3、把该异常转换成另一种异常。大多数情况下，这是指把一个低级的异常转换成应用级的异常（其含义更容易被用户了解的异常）。

　　4、不要捕获异常。

　　结论一：既然捕获了异常，就要对它进行适当的处理。不要捕获异常之后又把它丢弃，不予理睬。

　　反例之二：不指定具体的异常

　　代码：15行。

　　许多时候人们会被这样一种“美妙的”想法吸引：用一个catch语句捕获所有的异常。最常见的情形就是使用catch(Exception ex)语句。但实际上，在绝大多数情况下，这种做法不值得提倡。为什么呢？

　 　要理解其原因，我们必须回顾一下catch语句的用途。catch语句表示我们预期会出现某种异常，而且希望能够处理该异常。异常类的作用就是告诉 Java编译器我们想要处理的是哪一种异常。由于绝大多数异常都直接或间接从java.lang.Exception派生，catch (Exception ex)就相当于说我们想要处理几乎所有的异常。

　　再来看看前面的代码例子。我们真正想要捕获的异常是什么 呢？最明显的一个是SQLException，这是JDBC操作中常见的异常。另一个可能的异常是IOException，因为它要操作 OutputStreamWriter。显然，在同一个catch块中处理这两种截然不同的异常是不合适的。如果用两个catch块分别捕获 SQLException和IOException就要好多了。这就是说，catch语句应当尽量指定具体的异常类型，而不应该指定涵盖范围太广的 Exception类。

　　另一方面，除了这两个特定的异常，还有其他许多异常也可能出现。例如，如果由于某种原因， executeQuery返回了null，该怎么办？答案是让它们继续抛出，即不必捕获也不必处理。实际上，我们不能也不应该去捕获可能出现的所有异常， 程序的其他地方还有捕获异常的机会??直至最后由JVM处理。

　　结论二：在catch语句中尽可能指定具体的异常类型，必要时使用多个catch。不要试图处理所有可能出现的异常。

　　反例之三：占用资源不释放

　　代码：3行-14行。

　　异常改变了程序正常的执行流程。这个道理虽然简单，却常常被人们忽视。如果程序用到了文件、Socket、JDBC连接之类的资源，即使遇到了异常，也要正确释放占用的资源。为此，Java提供了一个简化这类操作的关键词finally。

　　finally是样好东西：不管是否出现了异常，Finally保证在try/catch/finally块结束之前，执行清理任务的代码总是有机会执行。遗憾的是有些人却不习惯使用finally。

　　当然，编写finally块应当多加小心，特别是要注意在finally块之内抛出的异常??这是执行清理任务的最后机会，尽量不要再有难以处理的错误。

　　结论三：保证所有资源都被正确释放。充分运用finally关键词。

2.抽象类和接口的区别
(1)接口可以被多重implements,抽象类只能被单一extends
(2)接口只有定义,抽象类可以有定义和实现
(3)接口的字段定义默认为:public static final, 抽象类字段默认是"friendly"(本包可见)

3.Hashtable的原理,并说出HashMap与Hashtable的区别
HashTable的原理:通过节点的关键码确定节点的存储位置,即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),将此值解释为该节点的存储地址.
HashMap 与Hashtable很相似,但HashMap 是非同步(unsynchronizded)和可以以null为关键码的.

4.forward和redirect的区别
forward: an internal transfer in servlet
redirect: 重定向,有2次request,第2次request将丢失第一次的attributs/parameters等

5.什么是Web容器?
实现J2EE规范中web协议的应用.该协议定义了web程序的运行时环境,包括:并发性,安全性,生命周期管理等等.

6.解释下面关于J2EE的名词
(1)JNDI:Java Naming & Directory Interface,JAVA命名目录服务.主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能.
(2)JMS：Java Message Service,JAVA消息服务.主要实现各个应用程序之间的通讯.包括点对点和广播.
(3)JTA：Java Transaction API,JAVA事务服务.提供各种分布式事务服务.应用程序只需调用其提供的接口即可.
(4)JAF: Java Action FrameWork,JAVA安全认证框架.提供一些安全控制方面的框架.让开发者通过各种部署和自定义实现自己的个性安全控制策略.
(5)RMI:Remote Method Interface,远程方法调用

7.EJB是基于哪些技术实现的？并说 出SessionBean和EntityBean的区别，StatefulBean和StatelessBean的区别.
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现.
SessionBean 在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件.EntityBean被用来代表应用系统中用到的数据.对 于客户机，SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑;EntityBean是一种持久性对象，它代表一个存储在持 久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体.
Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean .这两种的 Session Bean都可以将系统逻辑放在 method之中执行，不同的是 Stateful Session Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体.Stateless Session Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless Session Bean 的时候，EJB Container 并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method.换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行.从内存方面来看， Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而 Stateful Session Bean 的优势却在于他可以维持使用者的状态.

8.XML的解析方法
Sax,DOM,JDOM

9.什么是Web Service?
Web Service就是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。
Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。
注： SOAP协议（Simple Object Access Protocal,简单对象访问协议）,它是一个用于分散和分布式环境下网络信息交换的基于XML的通讯协议。在此协议下，软件组件或应用程序能够通过标 准的HTTP协议进行通讯。它的设计目标就是简单性和扩展性，这有助于大量异构程序和平台之间的互操作性，从而使存在的应用程序能够被广泛的用户访问。

优势：
(1).跨平台；
(2).SOAP协议是基于XML和HTTP这些业界的标准的，得到了所有的重要公司的支持。
(3).由于使用了SOAP，数据是以ASCII文本的方式而非二进制传输，调试很方便；并且由于这样，它的数据容易通过防火墙，不需要防火墙为了程序而单独开一个“漏洞”。
(4).此外，WebService实现的技术难度要比CORBA和DCOM小得多。
(5).要实现B2B集成，EDI比较完善与比较复杂；而用WebService则可以低成本的实现，小公司也可以用上。
(6).在C/S的程序中，WebService可以实现网页无整体刷新的与服务器打交道并取数。
缺点：
(1).WebService使用了XML对数据封装，会造成大量的数据要在网络中传输。
(2).WebService规范没有规定任何与实现相关的细节，包括对象模型、编程语言，这一点，它不如CORBA。

10.多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
答：多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify

11.JSP中动态INCLUDE与静态INCLUDE的区别？
动态INCLUDE用jsp:include动作实现
<jsp:include page="included.jsp" flush="true"/>
它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面
<%@ include file="included.htm" %>
 

[Java编程与程序运行结果]
1.Java编程,打印昨天的当前时刻
public class YesterdayCurrent{
  public void main(String[] args){
    Calendar cal = Calendar.getInstance();
    cal.add(Calendar.DATE, -1);
    System.out.println(cal.getTime());
  }
}

2.文件读写,实现一个计数器
  public int getNum(){
        int i = -1;
        try{
            String stri="";
            BufferedReader in = new BufferedReader(new FileReader(f));
            while((stri=in.readLine())!=null){
                i = Integer.parseInt(stri.trim());
            }
            in.close();
        }catch(Exception e){
            e.printStackTrace();
        }
        return i;
    }
    public void setNum(){
        int i = getNum();
        i++;       
        try{
            PrintWriter out=new PrintWriter(new BufferedWriter(new FileWriter(f,false))); 
            out.write(String.valueOf(i));            //可能是编码的原因，如果直接写入int的话，将出现java编码和windows编码的混乱，因此此处写入的是String
            out.close() ;
        }catch(Exception e){
            e.printStackTrace();
        }
    }
3. 指出下面程序的运行结果:
class A{
    static{
        System.out.print("1");
    }
    public A(){
        System.out.print("2");
    }
}
class B extends A{
    static{
        System.out.print("a");
    }
    public B(){
        System.out.print("b");
    }  
}
public class Hello{
    public static void main(String[] ars){
        A ab = new B(); //执行到此处,结果: 1a2b
 ab = new B(); //执行到此处,结果: 1a2bab
    }
}
注:类的static 代码段,可以看作是类首次加载(被虚拟机加载)执行的代码,而对于类的加载,首先要执行其基类的构造,再执行其本身的构造
4.写一个Singleton模式的例子
public class Singleton{
 private static Singleton single = new Singleton();
 private Singleton(){}
 public Singleton getInstance(){
  return single;
 }
}

[数据库]
1.删除表的重复记录
如果记录完全相同才算重复记录,那么:  (sql server2000下测试通过)
select distinct * into #tmpp from tid
delete from tid     
insert into tid select * from #tmpp
drop table #tmpp
如果有id主键(数字,自增1的那种),那么:(sql server2000下测试通过)
delete from tableA where id not in
(select id = min(id) from tableA group by name)

    是不是已经被这些名字弄糊涂了，我们现在来看J2ME平台的结构。J2ME平台是本着Configuration和Profile结合来设计的。 Configuration是提供支持最大范围设备的最小的平台。Profile是针对特定的设备提供相应的开发包集合。在J2ME的两个基本配置CDC 和CLDC是按照如下的标准进行区分的。
CLDC：

512 KB 以下内存
有限能源供应（通常使用电池）
有限或非持续网络连接
简单的用户界面
16位或者32位的处理器
CDC：

2M以上内存
具有网络连接能力，通常为无线网络
需要实现java虚拟机规范的全部功能
32位或者64位的处理器

    从上述的要求中我们不难看出CLDC主要针对那些资源非常受限的设备比如手机、PDA、双工寻呼机等。而CDC主要面对那些家电产品，比如机顶盒、汽车导航系统等。
    下面我们来看看J2ME平台的结构图：

         
    我们可以看出J2ME的核心是Configuration，在它里面定义了java的虚拟机，通过它来和底层的Host OS打交道。Profile提供了访问设备的IO或者图形界面的能力，这样Configuration和Profile共同构成了J2ME的运行环境。比 如CLCD/MIDP可以提供给你开发手机程序的环境。在Profile之上针对不同的设备还可以提供不同的可选开发包。
    由于CLDC/MIDP大家都比较熟悉了，我们下面主要介绍一下基于CDC的J2ME系统构架，同样还是看它的系统图：
      

由于移动终端的类型成千上万，而且计算能力差异非常大，不可能像桌面系统那样仅仅两三个版本的JVM即可满足Windows，Linux和Unix 系统，因此，J2ME不是一个简单的微型版的JVM。为了满足千差万别的移动设备的需求，SUN定义了一系列的针对不同类型设备的规范，因此，J2ME平 台便是由许多的规范组成的集合。

最重要的移动终端当然是手机了，因此，我们主要讨论手机相关的J2ME规范。

Configuration

SUN把不同的设备按照计算能力分为CLDC（Connected Limited Device Configuration）和CDC（Connected Device Configuration）两大类，这两个Configuration是针对设备软硬件环境严格定义的，比如CLDC1.0定义了内存大小为64- 512k，任何设备如果支持CLDC1.0，就必须严格满足定义，不能有可选的或者含糊的功能。

CLDC1.0是针对计算能力非常有限的设备定义的，只支持整数运算，不支持浮点运算，早期的Java手机大部分都支持CLDC1.0，如Nokia 3650，Siemens 6688i。

CLDC1.1则增加了浮点运算，因此，在支持CLDC1.1的设备上，可以使用float和double类型的变量。现在的Java手机很多都能支持CLDC1.1，如Nokia 9500，Siemens S65。

CDC则是针对计算能力比较强的设备定义的，如PPC等，CDC平台的JVM基本上和桌面的JVM很接近了，只是可以使用的Package大大少于J2SE的包。支持CDC的非常高端的Java手机也会很快上市。

Profile

和Configuration相比，Profile更多是针对软件接口的定义，Profile有必须实现的，也有可选的功能，因此，Profile更灵活。

最重要的Profile当然是MIDP（Micro Information Device Profile），MIDP定义了能在Java手机上运行的Java程序的规范，包括应用程序生命周期，各种UI界面组件，支持Record存储和 Http连接等等，符合MIDP规范的Java小程序被称为MIDlet，可以直接通过无线网络下载到手机并运行。

早期的MIDP1.0规范使我们能在手机上运行有UI界面的Java程序，但是MIDP1.0对游戏的支持不够，必须自己实现许多代码，因此，MIDP2.0规范大大加强了对游戏开发的支持，使开发者能编写更少的代码来创建游戏。

MIDP规范的图形界面基本上都是独立于J2SE的AWT和Swing组件，因为目前手机的计算能力还比较有限，但是，随着手机的CPU越来越快，使得AWT和Swing移植到手机上也将成为可能，因此，基于CDC规范的最新的PBP 1.0（Personal Basic Profile）和PP 1.0（Personal Profile）提供了部分AWT和Swing的支持，目前，部分高端PDA已经可以运行PBP和PP的Java程序了。可以预见，将来大部分的AWT和Swing组件都能移植到手机上。

前面已经说过，和Configuration相比，Profile有许多可选包，比较实用的Profile还有在JSR135定义的MMAPI（Mobile Media API），实现多媒体播放功能；在JSR184定义的M3G API（Mobile 3D Graphics API），实现3D功能；在JSR120定义的WMA（Wireless Messaging API），实现短消息收发。如果你的手机支持某一Profile，如M3G，那么便可以在MIDlet中使用M3G的3D API实现3D游戏。

如果你准备在手机上开发J2ME应用，选择手机时就需要注意厂商支持的CLDC规范，支持MIDP1.0还是2.0，是否支持MMAPI，M3G，WMA等可选包。

Profile虽然定义了Java API接口，但是底层如何实现是由各厂商自己决定的，如M3G定义了3D接口，但是底层实现既可以使用硬件加速，也可以由C程序模拟，或者部分由硬件实现，部分由软件实现。

比J2ME更精简的Java平台被SUN称为JavaCard，运行在信用卡等芯片中，实现电子支付等功能，目前SUN还没有把JavaCard并入J2ME平台。

对于这个系列里的问题，每个学Java的人都应该搞懂。当然，如果只是学Java玩玩就无所谓了。如果你认为自己已经超越初学者了，却不很懂这些问题，请将你自己重归初学者行列。内容均来自于CSDN的经典老贴。

问题一：我声明了什么！

String s = "Hello world!";

许多人都做过这样的事情，但是，我们到底声明了什么？回答通常是：一个String，内容是“Hello world!”。这样模糊的回答通常是概念不清的根源。如果要准确的回答，一半的人大概会回答错误。
这个语句声明的是一个指向对象的引用，名为“s”，可以指向类型为String的任何对象，目前指向"Hello world!"这个String类型的对象。这就是真正发生的事情。我们并没有声明一个String对象，我们只是声明了一个只能指向String对象的引用变量。所以，如果在刚才那句语句后面，如果再运行一句：

String string = s;

我们是声明了另外一个只能指向String对象的引用，名为string，并没有第二个对象产生，string还是指向原来那个对象，也就是，和s指向同一个对象。

问题二："=="和equals方法究竟有什么区别？

==操作符专门用来比较变量的值是否相等。比较好理解的一点是：
int a=10;
int b=10;
则a==b将是true。
但不好理解的地方是：
String a=new String("foo");
String b=new String("foo");
则a==b将返回false。

根据前一帖说过，对象变量其实是一个引用，它们的值是指向对象所在的内存地址，而不是对象本身。a和b都使用了new操作符，意味着将在内存中产生两个内容为"foo"的字符串，既然是“两个”，它们自然位于不同的内存地址。a和b的值其实是两个不同的内存地址的值，所以使用"=="操作符，结果会是 false。诚然，a和b所指的对象，它们的内容都是"foo"，应该是“相等”，但是==操作符并不涉及到对象内容的比较。
对象内容的比较，正是equals方法做的事。

看一下Object对象的equals方法是如何实现的：
boolean equals(Object o){

return this==o;

}
Object 对象默认使用了==操作符。所以如果你自创的类没有覆盖equals方法，那你的类使用equals和使用==会得到同样的结果。同样也可以看出， Object的equals方法没有达到equals方法应该达到的目标：比较两个对象内容是否相等。因为答案应该由类的创建者决定，所以Object把这个任务留给了类的创建者。

看一下一个极端的类：
Class Monster{
private String content;
...
boolean equals(Object another){ return true;}

}
我覆盖了equals方法。这个实现会导致无论Monster实例内容如何，它们之间的比较永远返回true。

所以当你是用equals方法判断对象的内容是否相等，请不要想当然。因为可能你认为相等，而这个类的作者不这样认为，而类的equals方法的实现是由他掌握的。如果你需要使用equals方法，或者使用任何基于散列码的集合（HashSet,HashMap,HashTable），请察看一下java doc以确认这个类的equals逻辑是如何实现的。

问题三：String到底变了没有？

没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。请看下列代码：

String s = "Hello";
s = s + " world!";

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

问题四：final关键字到底修饰了什么？

final使得被修饰的变量"不变"，但是由于对象型变量的本质是“引用”，使得“不变”也有了两种含义：引用本身的不变，和引用指向的对象不变。

引用本身的不变：
final StringBuffer a=new StringBuffer("immutable");
final StringBuffer b=new StringBuffer("not immutable");
a=b;//编译期错误

引用指向的对象不变：
final StringBuffer a=new StringBuffer("immutable");
a.append(" broken!"); //编译通过

可见，final只对引用的“值”(也即它所指向的那个对象的内存地址)有效，它迫使引用只能指向初始指向的那个对象，改变它的指向会导致编译期错误。至于它所指向的对象的变化，final是不负责的。这很类似==操作符：==操作符只负责引用的“值”相等，至于这个地址所指向的对象内容是否相等，==操作符是不管的。

理解final问题有很重要的含义。许多程序漏洞都基于此----final只能保证引用永远指向固定对象，不能保证那个对象的状态不变。在多线程的操作中,一个对象会被多个线程共享或修改，一个线程对对象无意识的修改可能会导致另一个使用此对象的线程崩溃。一个错误的解决方法就是在此对象新建的时候把它声明为final，意图使得它“永远不变”。其实那是徒劳的。

问题五：到底要怎么样初始化！

本问题讨论变量的初始化，所以先来看一下Java中有哪些种类的变量。
1. 类的属性，或者叫值域
2. 方法里的局部变量
3. 方法的参数

对于第一种变量，Java虚拟机会自动进行初始化。如果给出了初始值，则初始化为该初始值。如果没有给出，则把它初始化为该类型变量的默认初始值。

int类型变量默认初始值为0
float类型变量默认初始值为0.0f
double类型变量默认初始值为0.0
boolean类型变量默认初始值为false
char类型变量默认初始值为0(ASCII码)
long类型变量默认初始值为0
所有对象引用类型变量默认初始值为null，即不指向任何对象。注意数组本身也是对象，所以没有初始化的数组引用在自动初始化后其值也是null。

对于两种不同的类属性，static属性与instance属性，初始化的时机是不同的。instance属性在创建实例的时候初始化，static属性在类加载，也就是第一次用到这个类的时候初始化，对于后来的实例的创建，不再次进行初始化。这个问题会在以后的系列中进行详细讨论。

对于第二种变量，必须明确地进行初始化。如果再没有初始化之前就试图使用它，编译器会抗议。如果初始化的语句在try块中或if块中，也必须要让它在第一次使用前一定能够得到赋值。也就是说，把初始化语句放在只有if块的条件判断语句中编译器也会抗议，因为执行的时候可能不符合if后面的判断条件，如此一来初始化语句就不会被执行了，这就违反了局部变量使用前必须初始化的规定。但如果在else块中也有初始化语句，就可以通过编译，因为无论如何，总有至少一条初始化语句会被执行，不会发生使用前未被初始化的事情。对于try-catch也是一样，如果只有在try块里才有初始化语句，编译部通过。如果在 catch或finally里也有，则可以通过编译。总之，要保证局部变量在使用之前一定被初始化了。所以，一个好的做法是在声明他们的时候就初始化他们，如果不知道要出事化成什么值好，就用上面的默认值吧！

其实第三种变量和第二种本质上是一样的，都是方法中的局部变量。只不过作为参数，肯定是被初始化过的，传入的值就是初始值，所以不需要初始化。

问题六：instance of是什么东东？

instance of是Java的一个二元操作符，和==，>，<是同一类东东。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。举个例子：

String s = "I AM an Object!";
boolean is Object = s instance of Object;

我们声明了一个String对象引用，指向一个String对象，然后用instanc of来测试它所指向的对象是否是Object类的一个实例，显然，这是真的，所以返回true，也就是isObject的值为True。
instance of有一些用处。比如我们写了一个处理账单的系统，其中有这样三个类：

public class Bill {//省略细节}
public class PhoneBill extends Bill {//省略细节}
public class GasBill extends Bill {//省略细节}

在处理程序里有一个方法，接受一个Bill类型的对象，计算金额。假设两种账单计算方法不同，而传入的Bill对象可能是两种中的任何一种，所以要用instanceof来判断：

public double calculate(Bill bill) {
if (bill instanceof PhoneBill) {
//计算电话账单
}
if (bill instanceof GasBill) {
//计算燃气账单
}
...
}
这样就可以用一个方法处理两种子类。

然而，这种做法通常被认为是没有好好利用面向对象中的多态性。其实上面的功能要求用方法重载完全可以实现，这是面向对象变成应有的做法，避免回到结构化编程模式。只要提供两个名字和返回值都相同，接受参数类型不同的方法就可以了：

public double calculate(PhoneBill bill) {
//计算电话账单
}

public double calculate(GasBill bill) {
//计算燃气账单
}

所以，使用instanceof在绝大多数情况下并不是推荐的做法，应当好好利用多态。