1. hibernate中离线查询去除重复项怎么加条件？
dc.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
2. http协议及端口,smtp协议及端口
http：超文本传输协议 端口 80
smtp：简单邮件传输协议 端口25
3. 编写程序，完成文件复制功能
4. Servlet创建过程及生命周期Servlet 在容器中运行时，其实例的创建及销毁等是由容器进行控制。
Servlet 的创建有两种方法。
1）. 客户端请求对应的 Servlet 时，创建 Servlet 实例;大部分Servlet 都是这种 Servlet 。
2）. 通过在web.xml 中设置load-on-startup来创建servlet实例，这种实例在Web 应用启动时，立即创建Servlet 实例
Servlet 的运行都遵循如下生命周期：
1）. 创建 Servlet 实例。
2）. Web 容器调用 Servlet 的 init() 方法，对Servlet 进行初始化。
3）. Servlet 初始化后，将一直存在于容器中，用于响应客户端请求。根据客户端的请求方式通过Servlet中service()方法去相应的doXXX()方法；
4）. Web 容器销毁Servlet 时，调用 Servlet 的 destroy() 方法，通常在关闭Web容器之时销毁Servlet。
5. 用sql语句分页：
Mysql数据库：
查询第3-5条记录
select * from stu limit 2,3;
(说明：limit n,m表示区间查询，N表示从第几条开始，M表示要返回的记录条数。第3-5条记录，是从第二条记录开如，故N为2; 3-5之间有3条记录，所以是从第2要记录开始，返回3条记录，返回的正是3-5条记录。)
Sqlserver数据库：
SELECT TOP 页大小 * FROM table1 WHERE id NOT IN (
SELECT TOP 页大小*(页数-1) id FROM table1 ORDER BY id
) ORDER BY id
select top 3 * from TDJYXX where recid not in (
select top ((2-1)*3) recid from TDJYXX order by recid
) order by recid
Oracle数据库：
在ORACLE大数据量下的分页解决方法。一般用截取ID方法，还有是三层嵌套方法。
截取ID的方法
select * from emp a, (select empno,rownum as num from emp)b where a.empno=b.empno and b.num between 5 and 7;
三层嵌套
SELECT * FROM ( SELECT A.*, rownum r FROM ( SELECT * FROM emp ) A WHERE rownum <=7 ) B WHERE r >5）;
6. list.map.set的存储特点?
List 以特定次序来持有元素,可有重复元素.
Set 无法拥有重复元素,内部排序.
Map 保存key-value值,value可多值
7. final,finally,finaliz的区别
final—修饰符（关键字）
如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。
将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改 ，被声明为final的方法也同样只能使用，不能重载。
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 ；finalize() 方法以整理系统资源或者执行其他清理工作 finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。
8. arraylist和vector的区别?
1).同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程不安全的，不是同步的
2).数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
9. 说出ArrayList,Vector, LinkedList的存储性能和特性？
1）. ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦 LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引 但是缺点就是查找非常麻烦 要丛第一个索引开始
2）. ArrayList和Vector都是用数组方式存储数据,此数组元素数要大于实际的存储空间以便进行元素增加和插入操作,他们都允许直接用序号索引元素,但是插入数据元素涉及到元素移动等内存操作,所以查询数据快而插入数据慢.
3）. Vector使用了sychronized方法(线程安全),所以在性能上比ArrayList要差些.
4）. LinkedList使用双向链表方式存储数据,按序号索引数据需要前向或后向遍历数据，所以查询数据慢,是插入数据时只需要记录前后项即可,所以插入的速度快.
10. HASHMAP,HASHTABLE区别
1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；
2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。
3.在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。
11. .描述Cookie和Session的作用，区别和各自的应用范围，Session工作原理
Session用于保存每个用户的专用信息. 每个客户端用户访问时，服务器都为每个用户分配一个唯一的会话ID（Session ID) . 她的生存期是用户持续请求时间再加上一段时间(一般是20分钟左右).Session中的信息保存在Web服务器内容中,保存的数据量可大可小.当 Session超时或被关闭时将自动释放保存的数据信息.由于用户停止使用应用程序后它仍然在内存中保持一段时间,因此使用Session对象使保存用户数据的方法效率很低.对于小量的数据,使用Session对象保存还是一个不错的选择
Cookie 用于保存客户浏览器请求服务器页面的请求信息,程序员也可以用它存放非敏感性的用户信息，信息保存的时间可以根据需要设置.如果没有设置Cookie失效日期,它们仅保存到关闭浏览器程序为止.如果将Cookie对象的Expires属性设置为Minvalue,则表示Cookie永远不会过期.Cookie存储的数据量很受限制,大多数浏览器支持最大容量为4K,因此不要用来保存数据集及其他大量数据.由于并非所有的浏览器都支持Cookie,并且数据信息是以明文文本的形式保存在客户端的计算机中,因此最好不要保存敏感的,未加密的数据,否则会影响网站的安全性
session工作原理
(1)当有Session启动时，服务器生成一个唯一值，称为Session ID（好像是通过取进程ID的方式取得的）。
(2)然后，服务器开辟一块内存，对应于该Session ID。
(3)服务器再将该Session ID写入浏览器的cookie。
(4)服务器内有一进程，监视所有Session的活动状况，如果有Session超时或是主动关闭，服务器就释放改内存块。
(5)当浏览器连入IIS时并请求的ASP内用到Session时，IIS就读浏览器Cookie中的Session ID。
(6)然后，服务检查该Session ID所对应的内存是否有效。
(7)如果有效，就读出内存中的值。
(8)如果无效，就建立新的Session。
12. String和stringbuffer进行字符串连接时的区别？
String对项内容是不可改变的，StringBuffer是可以改变的，且高效；
13. 什么叫项目？
用有限的资源、有限的时间为特定客户完成特定目标的一次性工作
14. .J2EE J是什么意思？ 2是什么意思 EE是什么意思？ Struts的拦截器你是怎么做的，是独立开发的，能够独立开发的到。然后问有哪几种拦截？
Java 2 Platform，Enterprise Edition
继承AbstractInterceptor类，覆盖intercept()方法
有struts自己的拦截器 如timer ,i18n,scop,servletconfig,token
还有自定义拦截器
15. 简单介绍下java？Spring的AOP，IOC的讲述 对struts2的了解，1，2的比较 xml的了解 J2ee的webserviced的协议？
Spring AOP:代理机制 Spring提供的自动代理机制
Spring的IoC来实组件之间的依赖关系注入, 使控制层与业务实现分离，即客户通过
调用业务委托接口来调用具体的业务组件的实例，避免控制层与业务层的藕合带来的维护
或升级困难。由Spring为DAO生成代理对象来为DAO添加事务服务，由IoC容器DAO的代理实例注入到业务组件中,业务组件通过DAO的委托接口调用DAO对象，使得上层组件不直接依赖于DAO的实现类，使得持久层更换或修改不影响上层组件。
16. Collections,collection的区别
Collection是个java.util下的接口，它是各种集合结构的父接口。Collections是个java.util下的普通类，它包含有各种有关集合操作的静态方法。Collections是针对集合类的一个帮助类，它提供一系列的静态方法实现对各种集合的搜索，排序，线程安全化等操作
17. 如何释放过度使用的undo表空间
1. 启动SQLPLUS，并用sys登陆到数据库。 2. 查找数据库的UNDO表空间名3. 确认UNDO表空间；SQL> select name from v$tablespace; 4. 检查数据库UNDO表空间占用空间情况以及数据文件存放位置； 5. 查看回滚段的使用情况，哪个用户正在使用回滚段的资源，如果有用户最好更换时间 6. 检查UNDO Segment状态
18. 数据库里面游标，索引是怎么用的？ 在oracle数据库中，用get 和load方法 这2个方法来查没有的数据 那么分别会反馈什么样的结果？
declare cur cursor keyset for
get返回null,load classnotfoundException
19. .在Oracle中数据库中的一个表中，这个表没有主键id也没有特定标示来查数据，怎么查？
rowid
20. 简述private、proteced、public、internal修饰符的访问权限
同一个类 同一个包 不同包的子类 不同包非子类
private *
default * *
protected * * *
public * * * *
21. 概述反射和序列化
Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。本文借由实例，大面积示范Reflection APIs。
22. 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流
23. ORACLE中not和and和or优先级由高到低？
not and or
24. java 是如何进行异常处理的
Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理
25. struts2 必备包
commons-fileupload-1.2.1.jar
freemarker-2.3.13.jar
ognl-2.6.11.jar
struts2-core-2.1.6.jar
xwork-2.1.2.jar
26. dao 是什么及作用
dao 是数据访问对象 DAO负责管理与数据源的连接来获取和储存其中的数据
27. ibatis 中的#与$的区别
在Ibatis中我们使用SqlMap进行Sql查询时需要引用参数，在参数引用中遇到的符号#和$之间的区分为，#可以进行与编译，进行类型匹配，而$不进行数据类型匹配，例如：
select * from table where id = #id# ，其中如果字段id为字符型，那么#id#表示的就是'id'类型，如果id为整型，那么#id#就是id类型。
select * from table where id = $id$ ，如果字段id为整型，Sql语句就不会出错，但是如果字段id为字符型，那么Sql语句应该写成 select * from table where id = '$id$'
28. struts的实现原理
1、客户端初始化一个指向Servlet容器（例如Tomcat）的请求
2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）；
3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action；
4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；
5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类；
6、ActionProxy创建一个ActionInvocation的实例。
7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。
8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2框架中继承的标签。在这个过程中需要涉及到ActionMapper
29. 简述spring 的事务传播行为和 隔离级别
spring 的事务传播行为： Spring在TransactionDefinition接口中规定了7种类型的事务传播行为，它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播：
PROPAGATION_REQUIRED： (propagation_required)如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
PROPAGATION_SUPPORTS：(propagation_supports)支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY：(propagation_mandatory)使用当前的事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW：(propagation_requires_new)新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED：(propagation_not_supported)以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER：(propagation_enver)以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED：(propagation_ensted)如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。
Spring 的隔离级别
1、Serializable：最严格的级别，事务串行执行，资源消耗最大；
2、REPEATABLE READ：(repeatable read)保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。
3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。
4、Read Uncommitted：保证了读取过程中不会读取到非法数据。
30. 写一段把本地文件formfile拷贝到本地文件tofile的程序
public class ChangeJtdToJava {
public static void main(String[] args) {
File dir = new File("f:/jtd");
// 得到d:/jtd 下的所有文件对象
File[] files = dir.listFiles();
for (File file : files) {
String fileName = file.getName(); // 得到文件名
int index = fileName.indexOf(".");// .的索引位置
String fileName2 = fileName.substring(0, index); // 不带后缀名的文件名
String houZui = fileName.substrinxg(index);
if (houZui.equals(".jtd")) {
// "f:/java/" + fileName2 + ".java"
// 要移到的地方
file.renameTo(new File("f:/java/" + fileName2 + ".java"));
}
}
}
}
31. 写出删除表中重复记录的语句 oracle
delete from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1) and rowid not in (select min(rowid) from people group by
32. java 类实现序列化的方法（二种）？如在collection框架中，要实现什么样的接口
java.io.Serializable接口
Collection框架中实现比较要实现Comparable 接口和 Comparator 接口
33. Struts2实现拦截器的原理？
实现原理：Struts2拦截器是在访问某个Action或Action的某个方法、字段之前或之后实施拦截，并且Struts2拦截器是可插拔的，拦截器是ＡＯＰ的一种实现。当请求struts2的action时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表，最后一个一个地调用列表中的拦截器。
34. sleep()和wait()区别
sleep() 方法：线程主动放弃CPU，使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。
wait( ) ：与notify()配套使用，wait()使得线程进入阻塞状态，它有两种形式，一种允许指定以毫秒为单位的一段时间作为参数，另一种没有参数，当指定时间参数时对应的 notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用
个阶段:? 和CGI的区别？
Servlet的生命周期主要由3个过程组成。
(1)init()方法：服务器初始化servlet。
(2)service()方法：初始化完毕，servlet对象调用该方法响应客户的请求。
(3)destroy()方法：调用该方法消灭servlet对象。
其中，init()方法只在servlet第一次被请求加载的时候被调用一次，当有客户再请求servlet服务时，web服务器将启动一个新的线程，在该线程中，调用service方法响应客户的请求。
与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
36. forward与redirect 的区别?有哪些方式实现
1）. <jsp:forward>重定向后url地址栏地址不变还是原来的地址；而response.sendRedirect()重定向后url地址栏地址显示的请求后的新地址。
2）. <jsp:forward>重定向的时候可以保存回话信息，因此可以使用request来进行参数传递，在新页面可以使用request.getAttribute ()来得到参数。而response.sendRedirect()不支持此通过request进行参数传递。它唯一的传值方式为response.sendRedirect(“example.jsp?aa=123”)，在新的页面通过request.getParameter(“aa”)来得到参数值
37. 多线程、同步实现方法？
1）实现线程有两种方法： 继承Thread类或者实现Runnable接口
2） 实现同步也有两种,一种是用同步方法,一种是用同步块.. 同步方法就是在方法返回类型后面加上synchronized, 比如:
public void synchronized add(){...}
同步块就是直接写:synchronized (这里写需要同步的对象){...}
38. 集合类有哪些？有哪些方法？
集合类 ArrayList LinkedList HashSet HashMap
方法：add(),remove(),put(),addAll(),removeAll()
39. java中实现多态的机制是什么
重写，重载
方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。
果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
40. 静态的多态和动态的多态的区别
静态的多态: 即为重载 ；方法名相同，参数个数或类型不相同。(overloading)
动态的多态: 即为重写；子类覆盖父类的方法，将子类的实例传与父类的引用调用的是子类的方法 实现接口的实例传与接口的引用调用的实现类的方法。
41. 作用域Public,private,protected.以及不写时的区别
public整个java程序中都可以访问
protected在其他包中不可以访问
friendly只有当前包或当前内可以访问，其他都不行
private只有当前内可以访问
不写的话默认是protected
42. extends和implement的不同
extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了 比如 class A extends B implements C,D,E
43. join与left join的区别：
inner join(等值连接) 只返回两个表中联结字段相等的行
left join(左联接) 返回包括左表中的所有记录和右表中联结字段相等的记录
right join(右联接) 返回包括右表中的所有记录和左表中联结字段相等的记录
44. DAO设计模式与DELEGATE(delegate)模式
DAO(Data Access Object)模式实际上是两个模式的组合，即Data Accessor 模式和 Active Domain Object 模式，其中 Data Accessor 模式实现了数据访问和业务逻辑的分离，而Active Domain Object 模式实现了业务数据的对象化封装，一般我们将这两个模式组合使用。
DAO 模式通过对底层数据的封装，为业务层提供一个面向对象的接口，使得业务逻辑开发员可以面向业务中的实体进行编码。通过引入DAO模式，业务逻辑更加清晰，且富于形象性和描述性，这将为日后的维护带来极大的便利。试想，在业务曾通过Customer.getName方法获得客户姓名，相对于直接通过SQL语句访问数据库表并从ResultSet中获得某个字符型字段而言，哪种方式更加易于业务逻辑的形象化和简洁化？
Business Delegate起到客户端业务抽象化的作用。它抽象化，进而隐藏业务服务的实现。使用Business Delegate，可以降低表示层客户端和系统的业务服务之间的耦合程度。根据实现策略不同，Business Delegate可以在业务服务API的实现中，保护客户端不受可能的变动性影响。这样，在业务服务API或其底层实现变化时，可以潜在地减少必须修改表示层客户端代码的次数。
45. 适配器模式与桥梁模式的区别
适配器模式把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。又称为转换器模式、变压器模式、包装模式（把已有的一些类包装起来，使之能有满足需要的接口）。适配器模式的用意是将接口不同而功能相同或者相近的两个接口加以转换，包括适配器角色补充一些源角色没有但目标接口需要的方法。就像生活中电器插头是三相的，而电源插座是两相的，这时需要一个三相变两相的转换器来满足。
比如，在Java I/O库中使用了适配器模式，象FileInputStream是一个适配器类，其继承了InputStrem类型，同时持有一个对FileDiscriptor的引用。这是将一个FileDiscriptor对象适配成InputStrem类型的对象形式的适配器模式。StringReader是一个适配器类，其继承了Reader类型，持有一个对String对象的引用。它将String的接口适配成Reader类型的接口。等等。
桥梁模式的用意是要把实现和它的接口分开，以便它们可以独立地变化。桥梁模式并不是用来把一个已有的对象接到不相匹配的接口上的。当一个客户端只知道一个特定的接口，但是又必须与具有不同接口的类打交道时，就应该使用桥梁模式。
比如，JDBC驱动器就是一个桥梁模式的应用，使用驱动程序的应用系统就是抽象化角色，而驱动器本身扮演实现化角色。应用系统和JDBC驱动器是相对独立的。应用系统动态地选择一个合适的驱动器，然后通过驱动器向数据库引擎发出指令就可以访问数据库中的数据。
工厂模式
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
46. 开发中都用到了那些设计模式?用在什么场合?
每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。
(1) MVC模式,在J2EE项目开发中主要用在表示层框架中，很好解决视图和流程控制。在项目中采用的Struts、WebWork等框架。
(2) DAO模式,在项目开发中主要用在数据层，封装数据的访问操作，为业务层提供数据服务。
(3) IoC模式,在项目开发中业务层有大量对象，他们之间存在依赖关系，可以使用IoC模式减少他们之间的代码耦合，提高系统的可扩展性。实际项目中使用的Spring框架来实现业务组件的装配。
(4) Observer模式，在Servlet的监听器中应用到了观察者模式。
(5) singleton单例模式和Factory工厂模式结合使用在项目中无需使用者了解过多的细节就可获取有关的对象实例。比如Hibernate项目中通过SessionFactory来获取Session。
(6) bridge模式，在项目中使用JDBC驱动访问数据库。
47. Hibernate中离线查询与在线查询的区别
Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，所以它是由 Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，创建时无需 Session，DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name) 进行DetachedCriteria 实例的创建。
48. C#数据类型有哪些 ？
int 整型 double 双精度型 string 字符串型 char 字符型 bool 布尔型
49. 抽象类能否被实例化 ？抽象类的作用是什么？
抽象类一般不能被实例化；
抽象类通常不是由程序员定义的，而是由项目经理或模块设计人 设计抽象类的原因通常是为了规范方法名 抽象类必须要继承，不然没法用，作为模块设计者，可以把让底层程序员直接用得方法直接调用，而一些需要让程序员覆盖后自己做得方法则定义称抽象方法
50. ASP.NET页面传递值的方式有哪些
1 通过URL链接地址传递 2 通过post方式。 3 通过session 4通过Application
5 通过Server.Transfersend.aspx:
51. 如何定义一个MDI(.NET技术)
定义MDI父窗口应该是设置窗体的MdiParent属性= true
52. WCF是什么？
Windows Communication Foundation (WCF) 是由微软发展的一组数据通信的应用程序开发接口，它是.NET框架的一部分，由 .NET Framework 3.0 开始引入，与 Windows Presentation Foundation 及 Windows Workflow Foundation 并行为新一代 Windows 操作系统以及 WinFX 的三个重大应用程序开发类库
53. 常用的包，类，接口，各举5个。
类String Integer Long File Date
包 java.lang.*;java.io.*;java.util.*;java.swt.*;java.math.*;
接口: Comparable ,Connection,Map,List,Runable,
54. 网上购物系统的类图，用例图。
用例图：
类图:
55. 给你一个整数类型的数组，按从小到大的顺序进行排列！
public static void fun(int [] a,int c){
for(int i=0;i<a.length-1;i++){
for(int j=i;j<a.length-1;j++){
if(a[i]<a[j]){
t=a[i];
a[i]=a[j];
a[j]=t;
}
}
System.out.print(a[i]+" ");
}
}
56. 查询出M 页的N行数据(分页的实现，求第M也的记录数)
Select top N from table where id not in (select top (M-1)*N id from table )
57. Linkedlist arraylist内部是如何实现的（更深入的问了LinkedList与ArrayList的区别）
ArrayList的内部实现是基于内部数组Object[]，所以从概念上讲，它更像数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更像一个链表结构，所以，它们在性能上有很大的差别。
在ArrayList的前面或中间插入数据时，必须将其后的所有数据相应的后移，这样必然要花费较多时间，所以，当你的操作是在一列数据的后面添加数据而不是在前面或中间，并且需要随机地访问其中的元素时，使用ArrayList会提供比较好的性能；
而访问链表中的某个元素时，就必须从链表的一端开始沿着连接方向一个一个元素地去查找，直到找到所需的元素为止，所以，当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。
如果在编程中，两种情形交替出现，这时，可以考虑使用List这样的通用接口，而不用关心具体的实现，在具体的情形下，它的性能由具体的实现来保证
58. new ArrayList(10)含义
在内存中连续分配了用来存在Object对象的数组；
59. 面向对象主要内容? 有什么作用？
就分析设计层面来说，面向对象技术提供了更高级的抽象能力以及更多的方法和工具，如设计模式； 就实现维护层面来说，面向对象技术使代码重用更容易，且使代码具有可扩展性，便于软件的维护和升级更新。
60. 如何移动一个数 使62-63=1成立
62-63=1如何移动 2的6次方等于64 2的6次方-63=1 把2移动到6的左下方
61. 递归实现1,1,2,3,5,8,….第30个数是多少？
public static int Foo(int i)
{
if (i <= 0)
return 0;
else if(i > 0 && i <= 2)
return 1;
else return Foo(i -1) + Foo(i - 2);
}
int i=Foo(30);
System.out.println(i);
62. JAVA实现向数据库添加一列
Connection con = null;
ResultSet rs = null;
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name";
Connection con = DriverManager.getConnection(url,"","");
StateManager sm =con.createStateMent();
String sql = " alter table student add age int ";
rs = sm.excute(sql);
63. 写出删除表中重复记录的语句 oracle
delete from people
where peopleId in (select peopleId from people group by peopleId having count(peopleId) > 1) and rowid not in (select min(rowid) from people p group by p.peopleId );
delete from test where rowid not in (select min(rowid) from test t group by t.tid)
64. 用什么方法使服务器关闭之后，session所保存的信息不会丢失？
使用cookie
65. 如果页面没有<html></html>标签，会出现什么错误代码？
没有什么变化
66. 抽象类是否可以没有抽象方法？为什么？
可以 在java中用abstract关键字来修饰一个类时，这个类叫做抽象类。
抽象类中不一定要包含abstract方法，但一个类中包含了abstract方法，则这个类必须声明为abstract类。
67. servlet中的init方法什么时候被调用？
容器首次创建实例的时候
68. 用4 个0，用你所知道的数学方法计算出24
0的阶乘等于1 即 0！＝１那么４个0就是４了
又4的阶乘为２４ ４！＝２４
69. linux中进程的查看和调度分别用什么命令？
ps -A 查看 renice top
70. 集合类有哪些？有哪些方法？
集合类 ArrayList LinkedList HashSet HashMap
方法：add(),remove(),put(),addAll(),removeAll()
71. OSI七层模型tcp四层模型是什么样的
OSI七层参考模型 ：物理层 、数据链路层 、网络层 、传输层、应用层、会话层、表示层
TCP/IP:第一层网络接口层第二层 第二层??网间层 第三层??传输层 第四层??应用层
72. JAVA测试模式(ZZ)：
模式（一） Main 模式
模式（二） toString 模式
模式（三） Equal 模式
模式（四） Internal Tester Class 模式
模式（五） Extern Tester Class 模式
73. 一学生表！有班及id，学号！成绩！一求平均成绩！二求比平均成绩高的学生的所有信息
select id,avg(成绩) from table group by id
select * from table where 成绩 > (select 成绩 from （select id,avg(成绩) 成绩 from table group by id）as a )
74. jdk的新特性
“JDK1.5”的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each 循环，自动装包/拆包，枚举，可变参数, 静态导入 。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。
75. j2ee的规范？
SUN公司定义的一个开发分布式企业级应用的规范。它提供了一个多层次的分布式应用模型和一系列开发技术规范。多层次分布式应用模型是指根据功能把应用逻辑分成多个层次，每个层次支持相应的服务器和组件，组件在分布式服务器的组件容器中运行（如Servlet组件在Servlet容器上运行，EJB组件在EJB容器上运行），容器间通过相关的协议进行通讯，实现组件间的相互调用 J2EE规范定义了以下四个层次。 1.客户端层(Client Tier) 2.Web层 3.业务层(Business Tier) 4.企业信息系统层
76. ajax的工作原理？
Ajax 基本上就是把 JavaScript 技术和 XMLHttpRequest 对象放在 Web 表单和服务器之间。当用户填写表单时，数据发送给一些 JavaScript 代码而不是 直接发送给服务器。相反，JavaScript 代码捕获表单数据并向服务器发送请求。同时用户屏幕上的表单也不会闪烁、消失或延迟。换句话说，JavaScript 代码在幕后发送请求，用户甚至不知道请求的发出。更好的是，请求是异步发送的，就是说 JavaScript 代码（和用户）不用等待服务器的响应。因此用户可以继续输入数据、滚动屏幕和使用应用程 序。
然后，服务器将数据返回 JavaScript 代码（仍然在 Web 表单中），后者决定如何处理这些数据。它可以迅速更新表单数据，让人感觉应用程序是立即完成的，表单没有提交或刷新而用户得到了新数据。JavaScript 代码甚至可以对收到的数据执行某种计算，再发送另一个请求，完全不需要用户干预！这就是 XMLHttpRequest 的强大之处。它可以根据需要自行与服务器进行交互，用户甚至可以完全不知道幕后发生的一切。结果就是类似于桌面应用程序的动态、快速响应、高交互性的体验，但是背后又拥有互联网的全部强大力量。
77. .Xml特点？
XML是一种可扩展标记语言 (XML) 是 Web 上的数据通用语言。它使开发人员能够将结构化数据，从许多不同的应用程序传递到桌面，进行本地计算和演示。XML 允许为特定应用程序创建唯一的数据格式。它还是在服务器之间传输结构化数据的理想格式。
XML主要具有以下几个特点：
① 简洁有效
XML是一个精简的SGML，它将SGML的丰富功能与HTML的易用性结合到Web应用种，它保留了SGML的可扩展功能，这使得XML从根本上有区别于HTML。并且XML种还包括可扩展格式语言XSL（Extensible Style Language）和可扩展链接语言XLL（Extensible Linking Language）使得XML的显示和解析更加方便快捷。
② 易学易用
XML对SGML进行了精简，它抛弃了SGML中不常用的部分，方便用户编写Web页面同时也给设计人员实现XML浏览器降低了困难。
③ 开放的国际化标准
XML是W3C正式批准的，它完全可用于Web和工具的开发。XML具有标准的名域说明方法，支持文档对象模型标准、可扩展类型语言标准、可扩展链接语言标准和XML指针语言标准。使用XML可以在不同的计算机系统间交换信息，而且还可以跨越国界和超越不同文化疆界交换信息。
④ 高效可扩充
XML支持复用文档片断，使用者可以发明和使用自己的标签，也可以与他人共享，可延伸性大。在XML中，可定义一组无限量的标准，可以有效地进行XML文件的扩充。
78. oracle中除了数据库备份，还有什么方法备份？
Oracle数据库有三种标准的备份方法，它们分别是导出/导入(EXP/IMP)、热备份和冷备份。导出备份是一种逻辑备份，冷备份和热备份是物理备份。
79. j2ee的常用设计模式
Factory（工厂模式）,Builder（建造模式）fFactory Method（工厂方法模式），Prototype（原始模型模式），Singleton（单例模式），（门面模式），Adapter（适配器模式），Bridge（桥梁模式）
80. 由aaa字符串得到1000个a写个程序
StringBuilder sBuilder = new StringBuilder();
for(int i=0;i<333;i++){
sBuilder.Append("aaa");
}
sBuilder.Append("aaa".subString(0,1));
81. servlet与cgi的区别
CGI应用开发比较困难，因为它要求程序员有处理参数传递的知识，这不是一种通用的技能。CGI不可移植，为某一特定平台编写的CGI应用只能运行于这一环境中。每一个CGI应用存在于一个由客户端请求激活的进程中，并且在请求被服务后被卸载。这种模式将引起很高的内存、CPU开销，而且在同一进程中不能服务多个客户。
Servlet提供了Java应用程序的所有优势——可移植、稳健、易开发。使用Servlet Tag技术，Servlet能够生成嵌于静态HTML页面中的动态内容
Servlet对CGI的最主要优势在于一个Servlet被客户端发送的第一个请求激活，然后它将继续运行于后台，等待以后的请求。每个请求将生成一个新的线程，而不是一个完整的进程。多个客户能够在同一个进程中同时得到服务。一般来说，Servlet进程只是在Web Server卸载时被卸载
82. SOCKET中有几中连接方式，区别？
Sockets有两种主要的操作方式:面向连接的和无连接的。无连接的操作使用数据报协议，无连接的操作是快速的和高效的,但是数据安全性不佳. 面向连接的操作使用TCP协议.面向连接的操作比无连接的操作效率更低,但是数据的安全性更高
83. Socket如何获取本地ip地址？
public InetAddress getLocalAddress()
84. truncate与delete的区别？（delete from table和truncate table tablea的区别！）
truncate是DDL語言.delete是DML語言 DDL語言是自動提交的.命令完成就不可回滾.truncate的速度也比delete要快得多.
详细说明：
相同点:truncate和不带where子句的delete, 以及drop都会删除表内的数据
不同点:
1. truncate和 delete只删除数据不删除表的结构(定义)
drop语句将删除表的结构被依赖的约束(constrain),触发器(trigger),索引(index); 依赖于该表的存储过程/函数将保留,但是变为invalid状态.
2.delete语句是dml,这个操作会放到rollback segement中,事务提交之后才生效;如果有相应的trigger,执行的时候将被触发.
truncate,drop是ddl, 操作立即生效,原数据不放到rollback segment中,不能回滚. 操作不触发trigger.
3.delete语句不影响表所占用的extent, 高水线(high watermark)保持原位置不动
显然drop语句将表所占用的空间全部释放
truncate 语句缺省情况下见空间释放到 minextents个 extent,除非使用reuse storage; truncate会将高水线复位(回到最开始).
4.速度,一般来说: drop> truncate > delete
5.安全性:小心使用drop 和truncate,尤其没有备份的时候.否则哭都来不及
使用上,想删除部分数据行用delete,注意带上where子句. 回滚段要足够大.
想删除表,当然用drop
想保留表而将所有数据删除. 如果和事务无关,用truncate即可. 如果和事务有关,或者想触发trigger,还是用delete.
************************************************************************************************
85. xml有哪些解析技术，及区别？
有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
86. 文件和目录(i/o)操作，怎么列出某目录下所有文件？某目录下所有子目录，怎么判断文件或目录是否存在？如何读写文件？
列出某目录下所有文件：调用listFile()，然后判断每个File对象是否是文件可以调用 isFile（），判断是否是文件夹可以调用isDirectory（），判断文件或目录是否存在：调用exists() 方法，读写文件使用FileReader和FileWriter两个类即可
87. 怎么用java反射得到一个类的私有方法？
package test;
public class TestClass {
private String testMethod(String value){
return "test:"+value;
}
}
|
try { //得到test.TestClass类 Class c=Class.forName("test.TestClass"); //得到testMethod的方法 Method m=c.getDeclaredMethod("testMethod", new Class[]{String.class}); //打印完整的方法表示字符串 System.out.println(m.toGenericString()); //调用这个方法 Object obj=m.invoke(c.newInstance(), new Object[]{"method"}); //打印返回结果 System.out.println(obj); } catch (SecurityException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalArgumentException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (NoSuchMethodException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InvocationTargetException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (InstantiationException e) { // TODO Auto-generated catch block e.printStackTrace(); } |
88. 写一个单例模式？描述工厂模式和单例优缺点 举例在什么情况下用
|
class Single{} public class SingleFactory { private SingleFactory(){}; private static Single single; public static Single getSingle(){ if(single==null){ single=new Single(); } return single; } } |
· 简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。通过它，外界可以从直接创建具体产品对 象的尴尬局面中摆脱出来。
· 外界与具体类隔离开来，偶合性低。
· 明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
缺点：工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则 虽然简单工厂模式能够适应一定的变化，但是它所能解决的问题是远远有限的。它所能创建的类只能是事先教考虑到的，如果需要添加新的类，则就需要改变工厂类了。（这个问题在工厂方法模式将得到很好的解决）
应用情景 工厂类负责创建的对象比较少 客户只知道传入了工厂类的参数，对于始何创建对象（逻辑）不关心
89. JVM加载class文件原理？
所谓装载就是寻找一个类或是一个接口的二进制形式并用该二进制形式来构造代表这个类或是这个接口的class对象的过程.
在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化,其中链接又可以分成校验、准备、解析
装载：查找和导入类或接口的二进制数据；
链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的；
校验：检查导入类或接口的二进制数据的正确性；
准备：给类的静态变量分配并初始化存储空间；
解析：将符号引用转成直接引用；
初始化：激活类的静态变量的初始化Java代码和静态Java代码块
JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类
一个Java应用程序使用两种类型的类装载器：根装载器(bootstrap)和用户定义的装载器(user-defined)。
根装载器以某种默认的方式将类装入，包括那些Java API的类。在运行期间一个Java程序能安装用户自己定义的类装载器。根装载器是虚拟机固有的一部分，而用户定义的类装载器则不是，它是用Java语言写的，被编译成class文件之后然后再被装入到虚拟机，并像其它的任何对象一样可以被实例化。 Java类装载器的体系结构如下所示：
Bootstrap(根装载器)
|
Extension (扩展装载器)
|
System
|
UserDefine1
/ \
UserDefine2 UserDefine3
|
UserDefine4
Java的类装载模型是一种代理(delegation)模型。当JVM 要求类装载器CL(ClassLoader)装载一个类时,CL首先将这个类装载请求转发给他的父装载器。只有当父装载器没有装载并无法装载这个类时,CL才获得装载这个类的机会。这样, 所有类装载器的代理关系构成了一种树状的关系。树的根是类的根装载器(bootstrap ClassLoader) , 在JVM 中它以"null"表示。除根装载器以外的类装载器有且仅有一个父装载器。在创建一个装载器时, 如果没有显式地给出父装载器, 那么JVM将默认系统装载器为其父装载器
下面针对各种类装载器分别进行详细的说明：
根(Bootstrap) 装载器:该装载器没有父装载器，它是JVM实现的一部分，从sun.boot.class.path装载运行时库的核心代码。
扩展(Extension) 装载器:继承的父装载器为根装载器，不像根装载器可能与运行时的操作系统有关，这个类装载器是用纯Java代码实现的，它从java.ext.dirs (扩展目录)中装载代码。
系统(System or Application) 装载器:装载器为扩展装载器，我们都知道在安装JDK的时候要设置环境变量(CLASSPATH )，这个类装载器就是从java.class.path(CLASSPATH 环境变量)中装载代码的，它也是用纯Java代码实现的，同时还是用户自定义类装载器的缺省父装载器。
小应用程序(Applet) 装载器: 装载器为系统装载器，它从用户指定的网络上的特定目录装载小应用程序代码。
90. Tomcat的class加载的优先顺序一览
1.最先是$JAVA_HOME/jre/lib/ext/下的jar文件。
2.环境变量CLASSPATH中的jar和class文
3.$CATALINA_HOME/common/classes下的class
4.$CATALINA_HOME/commons/endorsed下的jar文件。
5.$CATALINA_HOME/commons/i18n下的jar文件。
6.$CATALINA_HOME/common/lib 下的jar文件。
（JDBC驱动之类的jar文件可以放在这里，这样就可以避免在server.xml配置好数据源却出现找不到JDBC Driver的情况。）
7.$CATALINA_HOME/server/classes下的class文件。
8.$CATALINA_HOME/server/lib/下的jar文件。
9.$CATALINA_BASE/shared/classes 下的class文件。
10.$CATALINA_BASE/shared/lib下的jar文件。
11.各自具体的webapp /WEB-INF/classes下的class文件。
12.各自具体的webapp /WEB-INF/lib下的jar文件。
91. CS与BS联系区别
1）java适合开发bs结构，cs不是它的强项 C/S 服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。B/S 客户机上只要安装一个浏览器（Browser），如Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Web Server 同数据库进行数据交互 1．硬件环境不同: C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务. B/S 建立在广域网之上的
2）对安全要求不同 C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息. B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户
3）对程序架构不同 C/S 程序可以更加注重流程, 可以对权限多层次校验 B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上
92. Error和 exception的区别与联系
error 表示恢复不是不可能,但很困难的情况下的一种严重问题。比如说内存溢,网络故障等。不可能指望程序能处理的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，就不会发生的情况。程序可以捕获到这些异常，并进行处理。
93. 在编写页面的会用到哪些技术？
美化页面需要用到CSS、页面交互使用JavaScript、动态页面需要用到JSP、XML等动态网页技术。
94. 手写个程序在本页面中心弹出一个窗体，里面有学生的成绩，可以修改学生的成绩，并且可以关闭窗口，把每个要用的jsp页面显示出来。（用 JavaScript）
到显示页面的ShowStudentServlet
|
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setCharacterEncoding("gbk"); response.setCharacterEncoding("gbk"); response.setContentType("text/html"); StudentDao dao=new StudentDao(); List<Student> sts=dao.stlist(); request.setAttribute("sts", sts); request.getRequestDispatcher("/showStu.jsp").forward(request, response); } |
学生成绩的显示页面：showStu.jsp
|
<table> <tr> <th>学号</th> <th>姓名</th> <th>成绩</th> <th>修改</th> </tr> <c:forEach items="${sts}" var="st"> <tr> <td>${st.sid}</td> <td>${st.name}</td> <td>${st.score}</td> <td><button onclick="window.showModalDialog('UpdateStudentServlet?sid=${st.sid }&rand='+Math.random());location.reload();">修改</button></td> </tr> </c:forEach> </table> |
请求修改的UpdateStudentServlet
|
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setCharacterEncoding("gbk"); response.setCharacterEncoding("gbk"); response.setContentType("text/html"); String s=request.getParameter("sid"); if(s!=null&&!s.equals("")){ StudentDao dao=new StudentDao(); Integer sid=Integer.parseInt(s); Student st=dao.findById(sid); request.setAttribute("st", st); request.getRequestDispatcher("/updateStu.jsp").forward(request, response); }else{ throw new ServletException("需要传递一个名为sid的int类型参数"); } } |
可以修改成绩的页面:updateStu.jsp
|
<base href="<%=basePath%>" target="_self"> <form action="UpdateScoreServlet" method="post"> <table> <tr> <th>编号</th> <td><input type="text" name="sid" value="${st.sid }" readonly="readonly"/></td> </tr> <tr> <th>姓名</th> <td><input type="text" name="name" value="${st.name }" readonly="readonly"/></td> </tr> <tr> <th>分数</th> <td><input type="text" name="score" value="${st.score }"/></td> </tr> <tr> <td colspan="2"><input type="submit" value="修改"/></td> </tr> </table> </form> |
负责修改成绩的UpdateScoreServlet
|
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setCharacterEncoding("gbk"); response.setCharacterEncoding("gbk"); response.setContentType("text/html"); String sid=request.getParameter("sid"); String score=request.getParameter("score"); if(sid!=null&&!sid.equals("")&&score!=null&&!"".equals(score)){ StudentDao dao=new StudentDao(); Student st=new Student(); st.setSid(Integer.parseInt(sid)); st.setScore(Double.parseDouble(score)); dao.update(st); response.getWriter().println("<script type='text/javascript'>alert('修改成功');window.close();</script>"); } } |
95. 用main涵数输出一到一百的和。
#include <stdio.h>
int main() {
printf("sum:%d\n", sum());
return 0;
}
int sum() {
int i;
int sum = 0;
for (i = 1; i <= 100; i++)
sum += i;
return sum;
}
96. 查一下每门课程都大于80的学生姓名
学生表student 分数表grade
select s.name from student s where s.id not in(select g.studentid from grade g where g.marks<=80)
或者
select s.name from student s where not exists(select 1 from grade g where g.studentid=s.id and g.marks<=80)
97. LIUNIX如何查看CPU,IP,内存？
cat /proc/cpuinfo 查看CPU
cat /proc/meminfo 查看内存
/sbin/ifcong 查看 IP的
98. j2EE系统访问速度慢.从哪些方面可以优化
J2EE性能的优化包括很多方面的，要达到一个性能优良的系统，除了关注代码之外，还应该根据系统实际的运行情况，从服务器软硬件环境、集群技术、系统构架设计、系统部署环境、数据结构、算法设计等方面综合考虑
99. J2EE访问速度慢，怎么样优化
1 使用缓冲标记 对于代码逻辑复杂的页面，利用缓冲标记提高性能的效果比较明显；反之，效果可能略逊一筹。
2 始终通过会话Bean访问实体Bean一些时候，使用实体Bean会导致程序性能不佳。如果实体Bean的惟一用途就是提取和更新数据，改成在会话Bean之内利用JDBC访问数据库可以得到更好的性能
3 选择合适的引用机制
4 在部署描述器中设置只读属性 实体Bean的部署描述器允许把所有get方法设置成“只读”。当某个事务单元的工作只包含执行读取操作的方法时，设置只读属性有利于提高性能，因为容器不必再执行存储操作
5 缓冲对EJB Home的访问
100. haShtable的原理
原理:通过节点的关键码确定节点的存储位置,即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),将此值解释为该节点的存储地址
101. struts中的prepare怎么用？
prepare是在validate拦截器之前执行
<s:checkboxlist list="users" listKey="id" listValue="name" name="userid"></s:checkboxlist>
在使用struts2 checkboxlist,select绑定list时，有时候会出现 以下异常
The requested list key 'users' could not be resolved as a collection/array/map/enumeration/iterator type. Example: people or people.{name} - [unknown location]这样的错误。是因为list的值为空
解决办法是把初始化list的工作放到prepare拦截器中
public class RoleAction extends ActionSupport implements Preparable{
@Override
public void prepare() throws Exception {
//初始化list
} }
102. C#题目conetextmenu控件如何使用.. listview
ContextMenu 组件提供与选定对象相关的常用命令的菜单。可以通过向 MenuItems 集合中添加 MenuItem 对象来向快捷菜单中添加项。可以从快捷菜单中永久地移除项；但是在运行时隐藏或禁用项可能更为妥当。 ListView的ContextMenu属性设置为ContextMenu对象
103. 写一条SQL语句，查询姓张学生中平均成绩大于75的学生信息
select * from student where name in (select name from student
where name like '张%' group by name having avg(score) > 75)
104. 从以下方面比较strut1和strut2:线程模式、依赖、可测性、表达式语言、捕获输入、绑钉值到页面、类型转换
线程模式: Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
• Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）
Servlet 依赖:
• Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
• Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。
可测性:
• 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API（这使得测试要依赖于容器）。一个第三方扩展－－Struts TestCase－－提供了一套Struts1的模拟对象（来进行测试）。
• Struts 2 Action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。
捕获输入:
• Struts1 使用ActionForm对象捕获输入。所有的ActionForm必须继承一个基类。因为其他JavaBean不能用作ActionForm，开发者经 常创建多余的类捕获输入。动态Bean（DynaBeans）可以作为创建传统ActionForm的选择，但是，开发者可能是在重新描述(创建)已经存 在的JavaBean（仍然会导致有冗余的javabean）。
• Struts 2直接使用Action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。Action属性能够通过 web页面上的taglibs访问。Struts2也支持ActionForm模式。rich对象类型，包括业务对象，能够用作输入/输出对象。这种 ModelDriven 特性简化了taglib对POJO输入对象的引用。
表达式语言：
• Struts1 整合了JSTL，因此使用JSTL EL。这种EL有基本对象图遍历，但是对集合和索引属性的支持很弱。
• Struts2可以使用JSTL，但是也支持一个更强大和灵活的表达式语言－－"Object Graph Notation Language" (OGNL).
绑定值到页面（view）:
• Struts 1使用标准JSP机制把对象绑定到页面中来访问。
• Struts 2 使用 "ValueStack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。
类型转换：
• Struts 1 ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。
• Struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。
105. struts的工作原理可分为如下8步。
1.读取配置（初始化ModuleConfig对象）
Struts框架总控制器（ActionServlet）是一个Servlet，在web.xml中被配置成一个自动启动的Servlet。读取配置文件struts-config.xml的配置信息，为不同的Struts模块初始化相应的ModuleConfig对象。
2.用户请求
用户提交表单或调用URL向WEB应用程序服务器提交一个请求，请求的数据用HTTP协议上传给WEB服务器。
3.填充FormBean
（*.do请求）从ActionConfig中找出对应该请求的Action子类，如有对应的Action且这个Action又一个相应的ActionForm，ActionForm被实例化并用HTTP请求的数据填充其属性，并保存在ServletContext中，这样他们就可以被其它Action对象或JSP调用。如果没有对应的Action，控制器则直接转发给JSP或静态页面。
4.派发请求
控制器根据配置信息ActionConfig将请求派发到具体的Action，相应的FormBean一并传给这个Action的execute()方法。
5.处理业务
Action一般只包含一个execute方法，它负责执行相应的业务逻辑。执行完毕后返回一个ActionFoward对象，控制器通过该ActionFoward对象来进行转发工作。
6.返回响应
Action根据业务处理的不同结果返回一个响应对象给总控制器，该目标响应对相对应一个具体的JSP页面或另一个Action。
7.查找响应
总控制器根据业务功能Action返回的目标响应对象找到对应的资源对象，通常是一个具体的JSP页面。
8.响应用户
JSP将结果展现给用户。
106. Spring工作原理
内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射,反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的 还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象 进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的 模块）从而达到对一个模块扩充的功能。这些都是通过配置类达到的
Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明 管理的（Spring根据这些配置 内部通过反射去动态的组装对象）要记住：Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能
107. Hibernate 的初始化.
读取Hibernate 的配置信息-〉创建Session Factory
1)创建Configeration类的实例。
它的构造方法：将配置信息(Hibernate config.xml)读入到内存。
一个Configeration 实例代表Hibernate 所有Java类到Sql数据库映射的集合。
2)创建SessionFactory实例
把Configeration 对象中的所有配置信息拷贝到SessionFactory的缓存中。
SessionFactory的实例代表一个数据库存储员源，创建后不再与Configeration 对象关联。
缓存(cache):指Java对象的属性(通常是一些集合类型的属性－－占用内存空间。
108. 在main方法中将字符串中的。数字排序并输出 STRING A="56.89.5.3.75.98.98.26.15.44"
String s=” 56.89.5.3.75.98.98.26.15.44”;
String s1[]=s. split (“.”);
Integer ii[]=new Integer[s1.length];
For(int i=0;i<s1.length;i++){
ii[i]=Integer.parseInt(s1[i]);
}
Arrays.sort(ii);
for(Integer o: ii){
System.out.println(o+” s”);
}
96Oracle冷备份的通常步骤
1 正常关闭数据库 2 备份所有重要的文件到备份目录（数据文件、控制文件、重做日志文件等）
3 完成备份后启动数据库用冷备份进行恢复时，只需要将所有文件恢复到原有位置，就可以启动数据库了
4 关闭数据库 SQL>shutdown 5 备份文件到备份的目录 6 然后启动数据库 ＃sqlplus "/as sysdba"SQL>startup 冷备份完毕！！
109. servlet 创建过程以及ruquest，response，session的生命周期？
Servlet的创建过程：
第一步
public class AAA extends HttpServlet{
实现对应的doxxx方法
}
第二步:
在web.xml中配置
<servlet>
<servlet-name></servlet-name>
<servlet-class></servlet-class>
</servlet>
<servlet-mapping>
<servlet-name></servlet-name>
<url-pattern></url-pattern>
</servlet-mapping>
servlet的生命周期：
servlet容器创建servlet的一个实例
容器调用该实例的init()方法
如果容器对该servlet有请求，则调用此实例的service()方法
容器在销毁本实例前调用它的destroy()方法
销毁并标记该实例以供作为垃圾收集
一旦请求了一个servlet，就没有办法阻止容器执行一个完整的生命周期。
容器在servlet首次被调用时创建它的一个实例，并保持该实例在内存中，让它对所有的请求进行处理。容器可以决定在任何时候把这个实例从内存中移走。在典型的模型中，容器为每个servlet创建一个单独的实例，容器并不会每接到一个请求就创建一个新线程，而是使用一个线程池来动态的将线程分配给到来的请求，但是这从servlet的观点来看，效果和为每个请求创建一个新线程的效果相同。
一旦请求提交给容器，容器会自动创建相应的request、response，一旦回应完毕则request、response自动销毁。客户端第一次请求时，容器会建立相应的会话，直到会话超时，会话随即销毁。
110. 手写个单例模式？每个公司基本都考
public class danli {
private static danli dl;
private danli(){
System.out.println("单例模式");
}
public static danli getconnection()
{
if(dl==null)
{
dl=new danli();
}
return dl;
}
}
111. 解释一下mvc以及熟悉的mvc框架
答:m代表模型层，v 代表视图层，c代表控制层，也就是把一个整体分割成不同的模块，各负责自己的功能，分工明确，提高代码的重用性和方便维护。
在jsp设计模式二中，jsp用来做视图层，servlet是控制器，dao则处理相关业务成为模型层。
在struts2.0,其中m是action,c是拦截器，v是jsp.
112. 解释一下IOC,以及spring的举例
IOC称为控制反转，也叫依赖注入，ioc是Spring的核心组件，它通过配置文件，将需要创建的对象以池的方式管理，将实例注入到需要的对象中区，是对象依赖于注入而不依赖于实现，解决了各个组件的耦合度，使得项目在后期的维护和扩展上非常方便。 如在ssh框架整合中，我们将datasource对象注入给sessionFactory，再将sessionFactory注入给dao组件，再将dao组件注入给struts的Action组件，在将action对象注入给struts的拦截器。
113. Oracle和Sqlserver的区别？数据库里面的语言符号表示？
a)体系结构：
ORACLE的文件体系结构为：
数据文件 .DBF (真实数据) / 日志文件 .RDO / 控制文件 .CTL / 参数文件 .ORA
SQL SERVER的文件体系结构为：
.MDF (数据字典) / .NDF (数据文件) /.LDF (日志文件)
b)存储结构：
ORACLE存储结构：在ORACLE将存储单位分为块、区、段、表等；块的大小可设置(OLTP块和DSS块)；将连续的块组成区，可动态分配区(区的分配可以是等额的也可以是自增长的)可减少空间分配次数；ORACLEl里表可以分为多个段，段由多个区组成，每个段可指定分配在哪个表空间里(段的类型分为：数据段、索引段、回滚段、临时段、CASH段。ORACLE里还可对表进行分区，可按照用户定义的业务规则、条件或规范，物理的分开磁盘上的数据。这样大大降低了磁盘争用的可能性。
SQL SERVER 存储结构：以页为最小分配单位，每个页为8K(不可控制，缺乏对页的存储情况的分析机制),可将8个连续的页的组成一个‘扩展’，以进一步减少分配时所耗用的资源。(分配缺乏灵活性)，在SQL SERVER里数据以表的方式存放，而表是存放在数据库里。真实数据与数据字典存放在一起。对系统参数信息无安全机制。
c)操作系统：
Oracle可在所有主流平台上运行；但SQL Sever只在Window平台上的表现很好；
d)运行速度与安全性：Oracle高于SQLServer;
e)价格：Oracle高于SQLServer;
114. 浏览器页面与T0MCat的交互过程？
当一个JSP页面第一次被访问的时候，JSP引擎将执行以下步骤：
（1）将JSP页面翻译成一个Servlet，这个Servlet是一个java文件，同时也是一个完整的java程序
（2）JSP引擎调用java编译器对这个Servlet进行编译，得到可执行文件class
（3）JSP引擎调用java虚拟机来解释执行class文件，生成向客户端发送的应答，然后发送给客户端
以上三个步骤仅仅在JSP页面第一次被访问时才会执行，以后的访问速度会因为class文件已经生成而大大提高。当JSP引擎街道一个客户端的访问请求时，首先判断请求的JSP页面是否比对应的Servlet新，如果新，对应的JSP需要重新编译。
115. 用C编写将一个100以内的自然数分解质因数
/* 100以内素数 */
#include<stdio.h>
main()
{
int i,j;
for(i=2;i<100;i++)
{
for(j=2;j<i;j++)
{
if(i%j==0)
break;
}
if(i==j)
{
printf("%d ",i);
}
}
}
/* 分解质因数*/
main()
{
int n,i;
printf( "please input a number:\n ");
scanf( "%d ",&n);
printf( "%d= ",n);
for(i=2;i <=n;i++)
while(n!=i)
{
if(n%i==0)
{
printf( "%d* ",i);
n=n/i;
} else{ break; }
}
printf( "%d ",n);
getch();
}
116. 用一个方法查出宜个数值类型数组的最大值，用递归方式实现
方法1
public class Test1 {
public static int a(int[] i,int j){
if(i.length-1>j){
if(i[j]>i[j+1]){
i[j+1]=i[j];
}
return a(i,j+1);
}else{
return i[i.length-1];
}
}
}
方法2 -- 非递归
public static int test(int []num) { int x=0; int log = num.Length;for(intt=0;t<log;t++){ if(num[t]>x){ x=num[t]; } }return x;}
方法3 --- 递归 不改变原数组中的元素
public static int getMax(int[]a, int index,int max){
int len = a.length;
if(len==1){
return a[len-1];
}
if(index==0){
max = a[index];
}
if(index==len){
return max;
}
if(max<a[index]){
max = a[index];
}
index++;
return getMax(a,index,max);
}
// 测试
int max = getMax(new int[]{2,5,18,3,38,10,2},0,0);
System.out.println(max);
117. JSP与SERVLET区别
JSP在本质上就是SERVLET,但是两者的创建方式不一样.Servlet完全是JAVA程序代码构成，擅长于流程控制和事务处理，通过Servlet来生成动态网页很不直观.JSP由HTML代码和JSP标签构成，可以方便地编写动态网页.因此在实际应用中采用Servlet来控制业务流程，而采用JSP来生成动态网页.在struts框架中，JSP位于MVC设计模式的视图层，而Servlet位于控制层.JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。JSP编译后是“类servlet”。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP是Java和HTML组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。
118. xmlhttprequest.open()里面有几个方法?
XMLHttpRequest.open()
初始化 HTTP 请求参数
语法
open (method, url, async, username, password)
method 参数是用于请求的 HTTP 方法。值包括 GET、POST 和 HEAD。
( 大小写不敏感 。
POST：用"POST"方式发送数据,可以大到4MB
GET：用"GET"方式发送数据,只能256KB
如果请求带有参数的化实用POST方式，POST方式将参数放置在页面的隐藏控件内
没有参数使用GET方式
对于请求的页面在中途可能发生更改的，也最好用POST方式
)
url 参数是请求的主体。大多数浏览器实施了一个同源安全策略，并且要求这个 URL 与包含脚本的文本具有相同的主机名和端口。
async 参数指示请求使用应该异步地执行。如果这个参数是 false，请求是同步的，后续对 send() 的调用将阻塞，直到响应完全接收。
如果这个参数是 true 或省略，请求是异步的，且通常需要一个 onreadystatechange 事件句柄。
username 和 password 参数是可选的，为 url 所需的授权提供认证资格。如果指定了，它们会覆盖 url 自己指定的任何资格。
119. java优缺点
先说优点吧,比较显见一点
1.指针.
任何一个学过C或者C++的人都知道指针的操作对于他们是很重要的,为什么,指针能够支持内存的直接操作,这样的直接操作能够带来的是效率上的提高.但是任何一个东西都是有副作用的,指针给程序员带了的混乱也是无可比拟的.对于一个不是很强劲的C程序员而言,指针是要命的(对我而言也是,我几乎不会写C代码).而JAVA就为我们省去了这样的麻烦,或者说JAVA完整的限制了对内存的直接操作,让程序员能够安心去搞业务逻辑,而不用管自己后院的那堆内存有没有人来收拾.
2.垃圾回收
其实垃圾回收也是JAVA对于内存操作的限制之一,也大大解放了程序员的手脚.但是也正是这样的一个内存保姆的存在导致JAVA程序员在内存上几乎没有概念...一个纯粹的JAVA程序员对于内存泄露这样的问题是从来没有概念的,因为他从来不用担心,因为大多数情况下即便他大手大脚也不会有什么问题
3.平台无关性
平台无关性的真正意义在于程序的可移植性高，能够在多个平台平滑迁移。这点就特别适合网络应用。
好吧,然后我们再来看看缺点吧:
1效率
1.1当然首先就是内存操作限制带来安全的同时带来的副面效果了.....
1.2 其次呢,就是面对对象的一个很重要的特点所带来的——多态导致的。
1.3平台无关性带来的。由于需要平台无关，所以JAVA是不能直接调用OS的API的，JAVA需要调用自己的API来隐式地调用OS的API，大家可想而知这样的效果。多一层调用，必然多一层代码需要加载到栈内了。
2逆向编译问题
由于JAVA程序是动态连接的，从一个类到另外一个类的引用是符号化的。在静态连接的可执行程序中，类之间的只是直接的指针或者偏移量，。相反地，在JAVA class文件中，指向另一个类的引用通过字符串清楚地标明了所指向的类的名字。如果引用指向一个字段的话，这个字段的名字和描述符会被详细说明。如果引用指向一个成员变量，这个成员变量的名字和描述符（方法的返回类型，方法参数的数量和类型）也会被详细说明。
3 线程调度问题
Java虽然是一个总进程下的多线程，但是线程间的调度没有非常的清晰，由于为了能够支持多种系统的不同的线程支持策略，JAVA只能采取这样笼统而又松散的线程规范。
120. 写一个单例Signleton代码
public class Singleton {
private Singleton(){};
private static Singleton singleton;
@SuppressWarnings("unused")
private static Singleton getSingleton(){
if(singleton==null){
singleton=new Singleton();
}
return singleton;
}
}
121. Mvc各部分用什么实现？
视图层用jsp，javascript
作用--显示数据，接受用户输入数据
控制层用servlet
作用--接收视图层数据，传输 给业务逻辑层（即模型层）
模型层用普通javaBean
作用--业务类的实现，如：数据库操作
122. ejb是基于哪些技术实现的，和javabean的区别？
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现 EJB是一个关于用JAVA语言开发的可部署的服务器端组件的组件体系结构。它是一个技术协议，能使组件运行于任何应用服务器,专门用来解决商务问题JAVABEANS是JAVA类，是由属性、事件和方法组成的JAVA组件，它们可以用来组成JAVA应用程序
123. 适配器模式解释：
把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类 能够一起工作。适配类可以根据参数返还一个合适的实例给客户端
124. 进程和线程的区别：
线程是一种操作系统对象，代表着一个进程中要被执行的代码的路径。每一个WIN32应用程序至少有一个线程--通常称为住线程或默认线程--但应用程序可以*地创建其他线程来执行其他任务！
进程是程序的一次动态执行过程，它对应了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到消亡的过程 线程是比进程更小的执行单位。一个进程在其执行过程能够中，可以产生 多个线程，形成多条执行线索。每条线索，即每个线程也有它自身的产生、存在和消亡过程，也是一个动态的概念
125.
short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，需要强制转换类型）
short s1 = 1; s1 += 1;（可以正确编译）
126. 写一个程序,把一个文件的数组按对角线做对称变换,并输出!
一个正方形里面全数字,写一个程序,成对角线转变! 我做的这个是3行3列的对角互换，也许转换规则不一样
public class testMain {
public static void main(String[] args) {
int a[][]=new int[3][3];
int c=1;
//初始化数据
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
a[i][j]=c++;
}
}
System.out.println("转换之前：");
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
System.out.print("a["+i+"]["+j+"]="+a[i][j]+" ");
}
System.out.println("\n");
}
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if((i+1<3&&j+1<3)&&i==j&&i!=0&&i!=3-i){
int temp=a[i-1][j-1];
a[i-1][j-1]=a[i+1][j+1];
a[i+1][j+1]=temp;
temp=a[i-1][j+1];
a[i-1][j+1]=a[i+1][j-1];
a[i+1][j-1]=temp;
}
}
}
System.out.println("转换之后：");
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
System.out
print("a["+i+"]["+j+"]="+a[i][j]+" ");
}
System.out.println("\n");
}
}
}
127. 再SSH框架中，用流程表示处理过程。从Request, Response
128. 人民币小写转成大写，写个java程序和思路（写10100.00转成汉字壹万零壹百整）
public class Money {
public static void main(String[] args) {
// 金额大小写转换
float money = 2038.0f;
int m1, m2, m3, m4, m5, m6, temp;
temp = (int) (money * 100);
System.out.println(money);
m1 = temp % 1000000 / 100000;
m2 = temp % 100000 / 10000;
m3 = temp % 10000 / 1000;
m4 = temp % 1000 / 100;
m5 = temp % 100 / 10;
m6 = temp % 10;
char c1, c2, c3, c4, c5, c6;
c1 = transe(m1);
c2 = transe(m2);
c3 = transe(m3);
c4 = transe(m4);
c5 = transe(m5);
c6 = transe(m6);
String str = "";
if (m1 != 0) {
str += c1 + "千";
}
if (m2 != 0) {
str += c2 + "百";
}
if (m1 != 0 && m2 == 0 && (m3 != 0 || m4 != 0)) {
str += "零";
}
if (m3 != 0) {
str += c3 + "十";
}
if (m2 != 0 && m3 == 0 && m4 != 0) {
str += "零";
}
if (m4 != 0) {
str += c4;
}
str += "元";
if (m5 == 0 && m6 == 0) {
str += "整";
}
if (m5 != 0) {
str += c5 + "角";
}
if (m5 == 0 && m6 != 0) {
str += "零";
}
if (m6 != 0) {
str += c6 + "分";
}
System.out.print(str + "\n");
System.out.println("..........................");
}
public static char transe(int m) {
char r = ' ';
switch (m) {
case 0:
r = '零';
break;
case 1:
r = '壹';
break;
case 2:
r = '贰';
break;
case 3:
r = '叁';
break;
case 4:
r = '肆';
break;
case 5:
r = '伍';
break;
case 6:
r = '陆';
break;
case 7:
r = '柒';
break;
case 8:
r = '捌';
break;
case 9:
r = '玖';
break;
}
return r;
}
}
129. 针对一个分期付款，总期为1年，给定分期金额，期数和开始还款时间，计算出各期还款日期。
package demo;
import java.util.Calendar;
import java.util.Date;
public class TestDemo {
// 分期付款，总期为1年，给定分期金额，期数和开始还款时间
// 计算出各期还款日期
public void huankuan(double amount,int num,Date start){
int period = 365/num; // 一年中分期间隔天数
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR, start.getYear()+1900);
cal.set(Calendar.MONTH, start.getMonth());
cal.set(Calendar.DATE, start.getDate());
for(int i=1;i<=num;i++){
System.out.println(" 第" + i + "期还款日期: " + cal.getTime().toLocaleString());
cal.add(Calendar.DATE, period);
}
}
public static void main(String[] args) {
TestDemo demo = new TestDemo();
demo.huankuan(20000.00, 1, new Date());
}
}
130. 用java写从1加到100
sum=(1+i)*i/2
i=100
最简单的方法
public class Hello5050{
public static void main(String[] args){
for (int i=1;i<=100;i=i++)
}
131. SSH的优点和缺点
优点： ssh把数据库，实体，配置都整合，封装
层次的结构（偏于mvc模式）
而且框架的融合，代码的耦合都很不错
对于编程的持续化，扩展化，维护化都很棒 ，SSH已经把底层实现封装好了，开发人员可以更专注于业务处理，
缺点： 出现错误容易搞的复杂
如果某个框架不是很熟悉的话（特别是spring）那就很麻烦
运行速度比较慢
132. 用JDBC来实现访问数据库记录可以采用下面的几个步骤：
1、 通过驱动器管理器获取连接接口。
2、 获得Statement或它的子类。
3、 限制Statement中的参数。
4、 执行Statement。
5、 查看返回的行数是否超出范围。
6、 关闭Statement。
7、 处理其它的Statement
8、 关闭连接接
133. overload和override的区别
override是方法重载，用在同一个类中，是几个方法的名字相同，返回值相同，但是参数列表不同，举例来说就像构造函数，可以后多个构造函数，并且每个的参数列表都不同，这样可以用多种方式构造对象。
overload是方法覆盖，用在父子类中，是方法名字相同，参数列表也相同，声明形式都相同，但是子类方法的权限不允许小于父类，不允许抛出比父类更多的异常
134. 最常见的runtime exception运行时异常？
数字转换异常，类异常ClassCastException NumberFormatException ArrayIndexOutOfBoundsException:数组越界 ClassCastException:类型转换错误
ArithmeticException：算术错误，典型的就是0作为除数的时候。IllegalArgumentException：非法参数 IndexOutOfBoundsException NullPointerException
SystemException ArrayStoreException
135. 描述工厂模式和单例优缺点 举例在什么情况下用。
单例 保证一个类只有单一的实例，也就是说你无法通过New或CreateInstance来创建这个类的一个新实例 好处：当一个对象在程序内部只能有一个实例的时候，它可以保证我们不会重复创建，而是始终指向同一个对象。 缺点就是 它就是在内存上共享，都可以去访问它，而且多个用户访问的都是同一个实例，会造成线程不安全。
/** *//**
* IOC模式简单实例
*/
/** *//**
* 运行类
*/
public class MainClass {
/** *//**
* 主函数
*/
public static void main(String[] args) {
try {
PrinterFactory.createPrinter().printByString("Hello World~!");
} catch (Exception ex) {
System.out.println(ex.toString());
}
}
}
/** *//**
* Printer接口
*/
interface IF_Printer {
/** *//**
* 接口printByString方法声明
*/
public void printByString(String str);
}
/** *//**
* MyPrinter实现Printer接口
*/
class MyPrinter implements IF_Printer {
public void printByString(String str) {
System.out.println(str);
}
}
/** *//**
* IF_Printer对象工厂,用于创建实现接口的类对象
*/
class PrinterFactory {
/** *//**
* 工厂方法,返回IF_Printer接口实例
*/
public static IF_Printer createPrinter() throws InstantiationException,
ClassNotFoundException, IllegalAccessException {
String str = "MyPrinter";//通过字符串寻找实现接口的类,字符串可从文件中读取获得,从而实现IOC模式
return (IF_Printer) Class.forName(str).newInstance();//返回IF_Printer接口实例
}
}
136. 创建一个序列号,从1000开始,每次增加1,最大到999999
create sequence newstudno increment by 1
start with 10001 maxvalue 99999
137. 设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
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); //???这个前面不要加Thread吗
t.start();
}
}
private synchronized void inc(){ //???为什么要加锁呢 不加可以吗
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
} //???currentThread()有什么作用呢是什么方法
//???getname呢
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(); } } } }
138. 十六进制的216转换十进制是多少：
216是16进制，转10进制:
＝2*16^2+1*16^1+6*16^0
=512+16+6
=536
139. Java中的XML解析方式： dom和jdom解析
Java中处理XML文档的标准API有两种，即XML的简单API（SAX，Simple API for XML）和文档对象模型（DOM， Document Object Model），其他的API，如JDOM，dom4j等。
基于DOM的XML分析器将一个XML文档转换成一个对象模型的集合（通常称DOM树），应用程序正是通过对这个对象模型的操作，来实现对XML文档数据的操作。通过DOM接口，应用程序可以在任何时候访问XML文档中的任何一部分数据。
n 基于树的处理的优点和缺点
l 优点
Ø 树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改
Ø 可以在任何时候在树中上下导航，而不是像 SAX 那样是一次性的处理
Ø DOM API是读写的，而不象SAX那样是只读的。
l 缺点
Ø 在内存中构建一个DOM树开销比较大
Ø 创建一棵 DOM 树可能是一个缓慢的过程
Ø DOM不象SAX那样可以提供很多XML文档中的信息。比如非分析实体、标记、属性类型和DTD中的声明。
SAX是一个基于事件的 API。解析器向一个事件处理程序发送事件，比如元素开始和元素结束，而事件处理器则处理该信息。应用程序本身就能够处理该数据。原始的文档仍然保留完好无损
n 优点：
l 可以解析任意大小的文件；
l 适合创建自己的数据结构；
l 适合小信息子集；
l 简单；
l 快速
n 缺点：
l 不能对文档做随机存取；
l 难以实现复杂的查询；
l 不能使用文档类型定义（DTD）；
l 不可获取词法信息；
l SAX是只读的；
l 当前的浏览器不支持SAX；
JDOM是java document object model的简称，JDOM兼顾了DOM和SAX的优点，它会提供适配器用来选择具体的XML解析器。JDOM是一个源代码开发的项目，它基于树型结构，利用纯Java的技术对XML文件实现解析、生成、序列化以及多种操作。在 JDOM 中，XML 元素就是 Element 的实例，XML 属性就是 Attribute 的实例，XML 文档本身就是 Document 的实例。因此创建一个新 JDOM 对象就如在 Java 语言中使用 new 操作符一样容易。JDOM 使用标准的 Java 编码模式。只要有可能，它使用 Java new 操作符而不故弄玄虚使用复杂的工厂化模式，使对象操作即便对于初学用户也很方便。
140. UML几种图及用途？
单一的图形不可能包含系统所学的所有信息，更不可能描述系统的整体结构，所以系统通常是从多个不同的方面来描述的，分别对应UML的几种视图：
§ 用例视图--从使用者角度描述系统功能
§ 逻辑视图—描述系统内部如何实现
§ 组件视图—描述系统有哪些组件/模块构成
§ 并发视图—描述系统内部的通信与并发问题
配置视图—描述系统软硬件的配置与位置关系
n 用例图—描述系统的参与者与用例之间的关系
n 类图—描述系统中的概念及它们之间的关系
n 对象图—描述系统中实例及它们之间关系
n 状态图—描述系统中对象所具备的状态，及触发状态改变的事件
n 时序图—描述对象之间发送消息的时间顺序
n 协作图—描述对象之间协作关系
n 活动图—描述执行过程中涉及的活动及状态变化
n 组件图—描述系统组件之间的关系
配置图—描述系统的硬件及软件的物理结构
141. 列举你接触过的框架，说明特点和原理
struts框架具有组件的模块化，灵活性和重用性的优点，同时简化了基于MVC的web应用程序的开发，缺点：Taglib是Struts的一大优势，但对于初学者而言，却需要一个持续学习的过程，甚至还会打乱你网页编写的习惯 Struts将MVC的Controller一分为三，在获得结构更加清晰的同时，也增加了系统的复杂度，工作原理 ：用一个servlet拦截用户的请求，并分发到具体的action中去处理，再将返回的response进行封装，这是处理页面流程的机制，另外还有一些标签，非常容易在页面进行显示。
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
Spring 也表示是一个开源框架，是为了解决企业应用程序开发复杂性由Rod Johnson创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
142. Struts Hibernate Spring 在程序中用到哪些
典型的J2EE三层结构，分为表现层、中间层（业务逻辑层）和数据服务层。三层体系将业务规则、数据访问及合法性校验等工作放在中间层处理。客户端不直接与数据库交互，而是通过组件与中间层建立连接，再由中间层与数据库交互。
表现层是传统的JSP技术，自1999年问世以来，经过多年的发展，其广泛的应用和稳定的表现，为其作为表现层技术打下了坚实的基础。
中间层采用的是流行的Spring+Hibernate，为了将控制层与业务逻辑层分离，又细分为以下几种。
Web层，就是MVC模式里面的“C”（controller），负责控制业务逻辑层与表现层的交互，调用业务逻辑层，并将业务数据返回给表现层作组织表现，该系统的MVC框架采用Struts。
Service层（就是业务逻辑层），负责实现业务逻辑。业务逻辑层以DAO层为基础，通过对DAO组件的正面模式包装，完成系统所要求的业务逻辑。
DAO层，负责与持久化对象交互。该层封装了数据的增、删、查、改的操作。
PO，持久化对象。通过实体关系映射工具将关系型数据库的数据映射成对象，很方便地实现以面向对象方式操作数据库，该系统采用Hibernate作为ORM框架。
Spring的作用贯穿了整个中间层，将Web层、Service层、DAO层及PO无缝整合，其数据服务层用来存放数据。
一个良好的框架可以让开发人员减轻重新建立解决复杂问题方案的负担和精力；它可以被扩展以进行内部的定制化；并且有强大的用户社区来支持它。框架通常能很好的解决一个问题。然而，你的应用是分层的，可能每一个层都需要各自的框架。仅仅解决UI问题并不意味着你能够很好的将业务逻辑和持久性逻辑和UI 组件很好的耦合。
143. 你对面向对象思想的理解？
面向对象(Object Oriented,OO)是当前计算机界关心的重点，它是90年代软件开发方法的主流。面向对象的概念和应用已超越了程序设计和软件开发，扩展到很宽的范围。如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。
面向对象的特征
(1)对象唯一性。
每个对象都有自身唯一的标识，通过这种标识，可找到相应的对象。在对象的整个生命期中，它的标识都不改变，不同的对象不能有相同的标识。
(2)分类性。
分类性是指将具有一致的数据结构(属性)和行为(操作)的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
(3)继承性。
继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
继承性是面向对象程序设计语言不同于其它语言的最重要的特点，是其他语言所没有的。
在类层次中，子类只继承一个父类的数据结构和方法，则称为单重继承。
在类层次中，子类继承了多个父类的数据结构和方法，则称为多重继承。
在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重性。
采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。
(4)多态性(多形性)
多态性使指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
多态性允许每个对象以适合自身的方式去响应共同的消息。
多态性增强了软件的灵活性和重用性。
数组和链表的理解，及优缺点？
144. 链表是一种常见的数据组织形式，它采用动态分配内存的形式实现。需要时可以用new分配内存空间，不需要时用delete将已分配的空间释放，不会造成内存空间的浪费。
A 从逻辑结构来看
A-1. 数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。
A-2. 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）
B 从内存存储来看
B-1. (静态)数组从栈中分配空间, 对于程序员方便快速,但是*度小
B-2. 链表从堆中分配空间, *度大但是申请管理比较麻烦.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
数组中的数据在内存中的按顺序存储的，而链表是随机存储的！
要访问数组中的元素可以按下标索引来访问，速度比较快，如果对他进行插入操作的话，就得移动很多元素，所以对数组进行插入操作效率很低！
由于连表是随机存储的，链表在插入，删除操作上有很高的效率（相对数组），如果要访问链表中的某个元素的话，那就得从链表的头逐个遍历，直到找到所需要的元素为止，所以链表的随机访问的效率就比数组要低
数组在内存中开辟连续的一块区域，如果一个数据要两个内存单元，一组5个数据10个单元就够了，无需标记其地址，因为数组定义时候标顶了第一个原许的地址，其他四个都知道了。
链表可可以是连续的，也可以是不连续的，但一般都是不连续的，尽管在内存中是连续的，我们也不把他当作是连续的，而是把他当作是不连续的，因为如果把他当作是连续的，不如当作是数组了，在某些情况下。一链5个数据，如果每个数据本身用2个内存单元，那么10个单元是不够的，因为每个数据都要表示出下个数据在哪里，所以一个数据本身用2个单元，再用1个单元表示此链下一个数据在什么地址。
145. 写几个java.lang.Object类中的方法名称
equals(); toString(); getClass(); hashCode(); clone() finalize() notify() wait() notify()
146. js中加VAR与不加VAR的区别？
在全局作用域中可以不使用var声明变量，但在声明局部变量时，一定要使用var语句.
加了var:在局部函数中加了var说明是局部变量,只对该函数起作用.
不加var:在局部函数中不加的话,说明是给这个全局变量重新赋值.其结果为重新赋值后的.
147. Struts 1的Action类与Struts 2的Action类区别？
Struts 1要求Action类要扩展自一个抽象基类。Struts 1的一个共有的问题是面向抽象类编程而不是面向接口编程。
Struts 2的Action类实现了一个Action接口，连同其他接口一起实现可选择和自定义的服务。
Struts 1 Action类是单例类，因只有一个示例控制所有的请求。
Struts 2 Action对象每一个请求都实例化对象，所以没有程安全的问题。
148. jsp有哪些的动作？分别有什么作用？
答： jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。
149. 用oracle写向mine表中差入miname字段？
ALTER TABLE MINE ADD MINNAME VARCHAR2(10);
150. oracle有哪几个对象？
Oracle数据库对象有表、索引、视图、同义词、序列、存储过程、触发器、PL/SQL块等
151. 在oracle中，有4个大对象（lobs）类型可用
分别是blob,clob,bfile,nclob。
152. 定义两个变量a和b，不使用第三个变量，使两个值交换
public class testMain {
public void test(int a,int b){
System.out.println("交换前a = "+a);
System.out.println("交换前b = "+b);
a=a+b;
b=a-b;
a=a-b;
System.out.println("交换后a = " +a);
System.out.print("交换后b = "+b);
}
public static void main(String args[]){
new testMain().test(10,13);
}
}
153. 题目：JS树形菜单
<%@ page language="java" import="java.util.*" pageEncoding="gbk"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP 'scriptTree.jsp' starting page</title>
<script type="text/javascript">
function fun1(){
window.showModalDialog("${pageContext.request.contextPath}/user.do?method=login","700");
window.dialogHeight=800;
}
function fun(isd){
var tabIds=document.getElementById(isd);
if(tabIds.style.display=='none'){
tabIds.style.display='inline';
}else{
tabIds.style.display='none';
}
}
</script>
</head>
<body>
<table border="2" borderColor="green" width="75%">
<tr>
<td onclick="fun('tableId1');">树型菜单</td>
<td>菜单名称</td>
</tr>
<tr>
<td colspan="2">
<table id="tableId1" border="2" borderColor="red">
<tr style="display:inline">
<td> kongjian </td>
</tr>
<tr style="display:inline">
<td><a href=""> xiaoxin </a> </td>
</tr>
</table>
</td>
</tr>
</table>
</body>
</html>
154. 办公自动化系统用到的技术，分哪些层，有哪些包
使用技术:DWR + Struts + Hibernate + Spring+Ajax+JavaScript
系统架构分为: View层、WEB层、Serivce层、DAO层、持久层(po层)
155. 解释下mvc，客户端的请求被发送到哪?
.jsp是v层(视图层view) Servlet是c层(控制层,Control) Bean Bin都是M层(后台类,Model)
m层(模型层)
156. 使用了哪些数据库事务?
BeginTransaction、Commit 和 Rollback
.
157. 对数据库的访问是怎么实现的
将对持久层数据库的基本添加，修改，查找等操作提取到BaseDAO中,采用JavaBean对数据进行封装，以便对持久层的数据能够很好的处理，实现BaseDAO设计对数据库访问的便捷。业务组件通过DAO 的委托接口调用DAO对象，使得上层组件不 直接依赖于DAO的实现类.
140．接口与抽象类的区别
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。
接 口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有 程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。 然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到 接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。
158. 数据库优化的方案
建立主键，为数据库创建索引，建立存储过程，触发器，可提高查询速度。
159. 冒泡
public static void Bubble(int a[]){
for(int i=0;i<a.length-1;i++){
for(int j=a.length-1;j>i;j--){
if(a[j]<a[j-1]){
a[j]=a[j]+a[j-1];
a[j-1]=a[j]-a[j-1];
a[j]=a[j]-a[j-1];
}
}
}
}
160. 常用的设计模式有哪些？并写出一段程序代码
Factory(工厂模式)，Adapter(适配器模式)，Singleton(单例模式)，State(状态模式)，Observer(观察者模式) 等。
单例模式
public class Singleton{
private static Singleton instance=null;
private Singleton(){}
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
}
161. 数据库有哪几种结构？
从数据管理的角度看，数据库通常采用三级模式结构，这是数据库管理系统的内部结构；从数据库最终用户的角度看，数据库的结构可分为集中式结构、分布式结构、客户/服务器结构、并型结构，这是数据库的外部的体系
162. css是什么？ABSTRACT是什么意思？（层叠样式表，抽象）
Css:（层叠样式表，抽象）
abstract 修饰符可以用于类、方法、属性、事件和索引指示器（indexer），表示其为抽象成员，abstract 不可以和 static 、virtual 一起使用 声明为 abstract 成员可以不包括实现代码，但只要类中还有未实现的抽象成员（即抽象类），那么它的对象就不能被实例化，通常用于强制继承类必须实现某一成员
163. 你对Oracle有哪些了解？ （大型数据库，安全性高，稳定性高，功能强大，效率低，价格贵，操作麻烦）
164. 你大学所学习的哪些课程？（会哪些JAVA技术？学过 C语言，c++,c#,java）
165. BBS论坛运用了那些技术，如果你单独开发需要多久，你能够独立完成整个代码的编写吗？（jsp技术，ajax技术，通信技术，）
166. 你对博客网有什么认识（典型的网络新事物，指网上写作的一种特定形式和格式。由按时间倒序排列的文档组成的栏目，两侧通常还可以有补充材料，频繁更新，一般大量使用链接）
167. 测试覆盖最强的是__d______,最弱的是____c___
A.条件覆盖 B.条件及判定覆盖 C.语句覆盖 D.条件组合覆盖
168. DFD是面向__c____分析方法的描述工具（DFD数据流程图）
A.数据结构 B.数据流 C.对象 D.构件
169. 从终端用户的角度来看,事务是一个__B_____
A.对象 B.原子 C.操作 D.子程序
170. 构造器是否可以被重写？ 不能
171. char是否可以装一个汉字？ 可以
172. public class Test {
public static void add(Integer i){
int val=i.intValue();
val+=3;
i=new Integer(val);
}
public static void main(String[] args) {
Integer i=new Integer(0);
add(i);
System.out.println(i.intValue());
}
}
打印的结果是0
173. outmermory是个什么问题？你是怎么解决的？
内存溢出 解决方法：手动设置Heap size修改TOMCAT_HOME/bin/catalina.bat
在“echo "Using CATALINA_BASE: $CATALINA_BASE"”上面加入以下行：
JAVA_OPTS="-server -Xms800m -Xmx800m -XX:MaxNewSize=256m"
174. &和&&的区别
&,按位与,是位运算符
&&,与，是逻辑运算符
175. 数组有没有length()这个方法，String有没有length()这个方
数组没有length()方法，但有length属性
String有length()方法。
176. String s=new String(“xyz”)创建了几个对象
2个string对象,一个是=null的s，一个是=“xyz”的string
177. 谈谈struts的整个体系？
Struts的目的是为了减少在运用MVC设计模型来开发Web应用的时间。你仍然需要学习和应用该架构，不过它将可以完成其中一些繁重的工作Struts跟Tomcat、Turbine等诸多Apache项目一样，是开源软件，这是它的一大优点，使开发者能更深入的了解其内部实现机制。
除此之外，Struts的优点主要集中体现在两个方面：Taglib和页面导航。Taglib是Struts的标记库，灵活动用，能大大提高开发效率。另外，就目前国内的JSP开发者而言，除了使用JSP自带的常用标记外，很少开发自己的标记，或许Struts是一个很好的起点。
关于页面导航，我认为那将是今后的一个发展方向，事实上，这样做，使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。
MVC即Model-View-Controller的缩写，是一种常用的设计模式。MVC 减弱了业务逻辑接口和数据接口之间的耦合，以及让视图层更富于变化。Struts 是MVC的一种实现，它将 Servlet和 JSP 标记（属于 J2EE 规范）用作实现的一部分。Struts继承了MVC的各项特性，并根据J2EE的特点，做了相应的变化与扩展
178. 域名格式要求
英文26个字母和10个阿拉伯数字以及横杠"－"可以用作域名。字母的大小写没有区别；每个层次最长不能超过26个字母；首字或结尾字不能是"."和"-"；域名不能包括有空格；中文暂时不能用作域名。
179. AjAX有什么好处？
用于需要查询数据库才能做的页面校验,再比如实时刷新,再比如良好的用户界面以及快速的响应等等 无刷新、减少网络流量
180. Webservice 有什么好处?
跨平台的可互操作性 跨防火墙的通信 应用程序集成 软件和数据重用
181. JAVA 的缓冲机制？ BufferdStream
182. 如何在javascript中实现继续？首先js是单线程的，现在基本除了XHR的callback可以另开一个线程以外，还无法实现多线程，其次timeout是在本次js代码运行完开始计时timeout的，所以在一个耗时的函数之外timeout或者interval一个函数运行本身就是荒谬的，ie下面alert，js函数执行也会阻塞interval执行
183. XMLHTTP的hibernate的save与saveOrUpdate的区别？get与load的区别？
答案: Transient状态--离线状态，Persient状态--持久状态，Detached状态--脱管状态
1.save（）方法，调用save方法时，首先会在session缓存中查找保存对象如果实体对象已经处于Persient状态，直接返回，否在实行sql操作，并将保存的实体对象加入session缓存（save方法不会把实体加入二级缓存的），最后对存在的级联关系进行递归处理。
2.saveOrUpdate（）方法：和save方法一样首先在session缓存中查找，判断对象是否为为保存状态，如果对象处于Persient，不执行操作，处于Transient执行save操作，处于Detached调用save将对象与session重新关联（简单的说就是该方法会先看该对象是否已经存在，如果已经存在就更新，否则新增保存）。
3.get与load的区别？load会先从缓存中查询，如果不存在再到数据库查询；而get是直接从数据库中查询；load的效率会快点（因为他从缓存中查询）
184. 连接池的原理
j2ee 服务器启动时会建立一定数量的池连接，并一直维持不少于此数量的池连接。当客户端程序需要连接时，吃驱动程序会返回一个未使用的池连接并将其标记为忙。如果当前 没有空闲连接，池驱动就建立一定新的 连接
185. 用javascript编写脚本小程序，实现点击全选（）
function selectAll(){
var item = document.getElementsByName("ids");
for( var j=0;j<item.length;j++){
if(!item[j].disabled){
item[j].checked = true
}
}
}
<input type="checkbox" name="ids" value="${N.oid}">
<input type=button value="全选" onclick="selectAll()">
186. 说一下垃圾回收的原理，可以直接从内存中回收吗?
垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收
187. java的异常有哪几种，有什么区别。
第一种方式：直接在函数头中throws SomeException，函数体中不需要try/catch
第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常
第三种方法：使用try/catch/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常
188. 通过部署描述文件（web.xml）可以配置哪些功能？
监听器。。过滤器。。也可以用来验证XML文件的正确性
189. 说一下mvc原理，（关于mvc）
1、模型（Model）
模型是应用程序的主体部分。模型表示业务数据，或者业务逻辑.
2、视图（View）
视图是应用程序中用户界面相关的部分，是用户看到并与之交互的界面。
3、控制器（controller)
控制器工作就是根据用户的输入，控制用户界面数据显示和更新model对象状态。
MVC 式的出现不仅实现了功能模块和显示模块的分离，同时它还提高了应用系统的可维护性、可扩展性、可移植性和组件的可复用性
190. servlet 在MVC中充当的角色: 中心控制器
191. 什么是BS和CS
B/S结构是Browser/Server的简称
即浏览器/服务器结构，程序和数据库放在SERVER端，客户端通过
浏览器来访问数据，进行数据交换。
B其实就是BROWSE即浏览器，S就是SERVER,即服务器
也就是说,用户可以用浏览器就可以享受SERVER提供的服务,也就是我们上网的啦
而CS呢,C就是CLIENT即客户端,S就是SERVER,服务端,
也就是说,用户要使用SERVER的服务,需要装上相应的客户端软件,像QQ就是这样的.
C/S又称Client/Server或客户/服务器模式。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。
B/S是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安装。Oracle、Sybase、Informix或 SQL Server等数据库。浏览器通过Ｗeb Server 同数据库进行数据交互。
C/S的优点是能充分发挥客户端ＰＣ的处理能力，很多工作可以在客户端处理后再提交给服务器。对应的优点就是客户端响应速度快。缺点主要有以下几个：
只适用于局域网。而随着互联网的飞速发展，移动办公和分布式办公越来越普及，这需要我们的系统具有扩展性。这种方式远程访问需要专门的技术，同时要对系统进行专门的设计来处理分布式的数据。客户端需要安装专用的客户端软件。首先涉及到安装的工作量，其次任何一台电脑出问题，如病毒、硬件损坏，都需要进行安装或维护。特别是有很多分部或专卖店的情况，不是工作量的问题，而是路程的问题。还有，系统软件升级时，每一台客户机需要重新安装，其维护和升级成本非常高。
对客户端的操作系统一般也会有限制。可能适应于Win98, 但不能用于win2000或Windows XP。或者不适用于微软新的操作系统等等，更不用说Linux、Ｕnix等。
B/S最大的优点就是可以在任何地方进行操作而不用安装任何专门的软件。只要有一台能上网的电脑就能使用，客户端零维护。系统的扩展非常容易，只要能上网，再由系统管理员分配一个用户名和密码，就可以使用了。甚至可以在线申请，通过公司内部的安全认证（如ＣＡ证书）后，不需要人的参与，系统可以自动分配给用户一个账号进入系统。
192. 页面中使用javascript的利与弊？（益端：能减少一些简单的逻辑业务，提高页面的效率，弊端：对于有些不能识别Javascript的浏览器存在一定的安全隐患）
193. 在Liniux/Uinix下创建一个角色帐号，自己拥有一切权限，系统用户拥有访问权限，其他用户没有任何权限.
194. SQL中有个PrepardStatement对象，用Java实现连接Oracle数据库，运用PrepardStatement对象。ConnDB.java
package demo.bean;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
public class ConnDB {
public static void main(String[] args) {
try{
String driver = "oracle.jdbc.driver.OracleDriver";
String url="jdbc:oracle:thin:@localhost:1521:yf";
String username = "scott";
String password = "tiger";
DriverManager.registerDriver( new oracle.jdbc.OracleDriver());
Connection con = DriverManager.getConnection(url, username, password);
PreparedStatement stm = con.prepareStatement("select sysdate from dual");
ResultSet rs = stm.executeQuery();
while(rs.next()){
System.out.print(rs.getString(1));
}
}catch(Exception e){
e.printStackTrace();
}
}
}
195. 数据库索引的优点和缺点
一、为什么要创建索引呢（优点）？
这是因为，创建索引可以大大提高系统的性能。
第一， 通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二， 可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
第三， 可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四， 在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五， 通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
二、建立方向索引的不利因素（缺点）但是，为表中的每一个列都增加索引，是非常不明智的缺点：
1 创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
2 索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚 簇索引，那么需要的空间就会更大。
3 当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
196. struts2.0中几种常用的标签
<s:if test=""></s:if> <s:form action=""></s:form>
<s:checkbox></s:checkbox>-----复选框 <s:url></s:url>-----创建url <s:textarea></s:textarea>-----文本域输入框
<s:autocompleter></s:autocompleter> <s:a href=""></s:a>-----超链接，类似于html里的<a></a>
197. 介绍下spring
Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯.Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器是一个解决了许多在J2EE开发中常见的问题的强大框架，还提供了可以和总体的IoC容器集成的强大而灵活的MVC web框.
198. 介绍下ajax
AJAX全称为“Asynchronous JavaScript and XML”（异步JavaScript和XML），是指一种创建交互式网页应用的网页开发技术
199. 介绍下hibernate
Hibernate是连接 Java 应用程序和关系数据库的中间件。它对 JDBC API 进行了封装，负责Java对象的持久化。在分层的软件架构中它位于持久化层，封装了所有数据访问细节，使业务罗基层可以专注于实现业务逻辑
200. servlet和jsp页面过滤器Filter的作用及配置
过滤器可附加到一个或多个servlet或JSP页面上，并且可以检查进入这些资源的请求信息 过滤器要好处。1它以一种模块化的或可重用的方式封装公共的行为 2 利用它能够将高级访问决策与表现代码相分离
201. 学JAVA的都看了什么书？
基础很差的人我建议用那本JavaSE 6.0编程指南 《最新Java2 核心技术 卷1、卷2》了，不要怕代码难懂，这个一定要克服，当然某些代码(比如经常提及的画小球、你又不是搞图象的:))就可以跳过去。这当中可以穿插阅读《Java实效编程百例》，最后建议大家阅读《Java编程思想》 thinking in JAVA第三版中文版 Core Java（java核心技术）
202. 函数和过程的区别？
过程和函数区别如下：
1、标识符不同:函数的标识符为FUNCTION，过程为：PROCEDURE。
2、话法不同：函数中一般不用变量形参，用函数名直接返回函数值；而过程如有返回值，则必须用变量形参返回。
3、函数在定义时一定要进行函数的类型说明，过程则不进行过程的类型说明。
4、调用方式不同:函数的调用出现在表达式中，过程调用，由独立的过程调用语句来完成。
5、过程一般会被设计成求若干个运算结果，完成一系列的数据处理，或与计算无关的各种
操作；而函数往往只为了求得一个函数值。
203. Javascript如何实现继承？
1.采用对象冒充方式:
原理: 构造函数使用this关键字给所有属性和方法赋值, 因为构造函数只是一个函数,所以可以使ClassA的构造函数成为classB的方法,然后调用它.这样classB就会收到classA的构造函数中定义的属性和方法.例子:
2.例:
function classA(name)
{
this.name=name;
this.showName=function(){alert(this.name);}
}
function classB(name)
{
this.newMethod = classA;
this.newMethod(name);
}
obj = new classA("hero");
objB = new classB("dby");
obj.showName(); // print hero
objB.showName(); // print dby 说明classB 继承了classA的方法.
204. 将字符串str（例：”abcrepefd”）中的”rep”部分替换成”with”字符串(不能用jdk自带的replace方法)
答案如下:
public void replace(String str,String rep,String with){
try{
int i = str.indexOf(rep);
String s1 = str.substring(0, i);
String s2 = str.substring(i, rep.length()+i);
String s3 = str.substring(rep.length()+i, str.length());
s2 = with;
String mes = s1+s2+s3;
System.out.println("替换前："+str);
System.out.println("替换后："+mes);
}catch(Exception e){
System.out.println("字符串"+str+"中不含有"+rep+"字符串！");
}
}
205. Java Reflection是什么？
答：
1.JAVA反射，Reflection是Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说"自审"，并能直接操作程序的内部属性。例如，使用它能获得 Java 类中各成员的名称并显示出来;
2.一个简单的例子
import java.lang.reflect.*;
public class DumpMethods {
public static void main(String args[]) {
try {
Class c = Class.forName(args[0]);
Method m[] = c.getDeclaredMethods();
for (int i = 0; i < m.length; i++)
System.out.println(m.toString());
}
catch (Throwable e) {
System.err.println(e);
}
}}
206. 1到11相加是奇数还是偶数?
偶数
207. 一个圆上有6个点，可以连多少条直线？
15条线段
208. Stack堆栈，实现进栈，出栈
package t1;
public class mystack {
private Object[] data;
private int top=-1;
private int size;
public mystack()
{
data=new Object[5];
size=5;
}
public mystack(int size)
{
data=new Object[size];
this.size=size;
}
public void push(Object obj)
{
if(this.isfull())
{
return ;
}
top++;
data[top]=obj;
}
public Object pop() {
if(this.isempty())
{
return null;
}
Object obj=data[top];
top--;
return obj ;
}
public boolean isfull()
{
if(top==data.length)
{
return true;
}
else
{
return false;
}
}
public boolean isempty()
{
if(top==-1)
{
return true;
}
else
{
return false;
}
}
}
209. 每周的工作效率要提高24％，每周工作6天，那么每天工作效率要提高多少？（6％，4%,24%）
答：24%
210. .前一天是星期一，又是第二个工作日，那么今天是星期几？
答：星期三
211. Hibernate 中的HQL和 criteria的区别？
答：
1.QBC(Query by Criteria)查询对查询条件进行了面向对象封装，符合编程人员的思维方式;
2．HQL(Hibernate Query Language)查询提供了更加丰富的和灵活的查询特性，在涵盖Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更加面向对象的封装;
212. Web service 是什么？它是采用什么通信机制，它的通信协议是什么？
答： Webservice是跨平台，跨语言的远程调用技术;
1. 它的通信机制实质就是xml数据交换;
2. 它采用了soap协议（简单对象协议）进行通信
213. Struts 是怎么实现MVC的？
Struts提供MVC三层模式:
MVC就是 model view controller.
1、view视图层一般运用jsp或者html进行实现，展现给用户看；
2、controller控制层struts有个文件叫struts-config.xml，该文件里面定义个处理后的跳转页面；
3、model模型层理解不深，可能是逻辑模型
214. j a v a 对象初始化顺序
1.类的初始化（initialization class & interface）
2.对象的创建（creation of new class instances）
顺序：应为类的加载肯定是第一步的，所以类的初始化在前。大体的初始化顺序是：
类初始化 -> 子类构造函数 -> 父类构造函数 -> 实例化成员变量 -> 继续执行子类构造函数的语句
215. 一个字符串中可能存在A-Z的全角字符，写一个方法把里面的全角字符转变成半角字符？
答：采用建立字典表进行查找转换
public static String translate(String s){
String qj = "ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ";
String bj = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
StringBuffer sb = new StringBuffer();
for(int i=0;i<s.length();i++){
char c = s.charAt(i);
int pos = qj.indexOf(c);
if(pos>=0){
System.out.println(c + "," + pos);
sb.append(bj.charAt(pos));
}else{
sb.append(c);
}
}
return sb.toString();
}
216. 写一个方法，传入一个int 型的数字，把它的四个字节码取出来，并且把它按大小顺序通过控制台输出？
public static void main(String[] args) {
int num = -800000000;
String str = Integer.toBinaryString(num); //获得num 的二进制
if(num>=0) { //如果输入的数为正数,位数可能不足32位，要补0；负数肯定是32位
if(str.length()<32) { //二进制不足32位，就在前面补0
int n0 = 32-str.length(); //看差几个0
String temp = "";
for(int i=0;i<n0;i++) {
temp = temp + "0"; //拼0
}
str = temp + str;
}
}
String s1 = str.substring(0, 8);
String s2 = str.substring(8, 16);
String s3 = str.substring(16, 24);
String s4 = str.substring(24, 32);
System.out.println(str);
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);
int n1=Integer.parseInt(s1,2);//以二进制把字符串解析为 10进制的数
int n2=Integer.parseInt(s2,2);
int n3=Integer.parseInt(s3,2);
int n4=Integer.parseInt(s4,2);
System.out.println(n1);
System.out.println(n2);
System.out.println(n3);
System.out.println(n4); //整数大小自己比较吧
}
217. ．类的工厂模式怎么实现？
首先确定这些类的父类或共同的接口，担任抽象产品的角色，比如
public interface IServer{
public void calc(int a,int b);
}
然后，这些类的具体实现继承某个父类或实现共同的接口,担任具体产品角色，比如
AddServer类和SubServer类
public class AddServer implements IServer{
public void calc(int a,int b){
System.out.println(a+b);
}
}
public class SubServer implements IServer{
public void calc(int a,int b){
System.out.println(a-b);
}
}
最后，涉及一个类充当工厂的角色，根据客户端的要求，提供具体的产品，比如
public class ServerFactory {
private static ServerFactory factory;
private ServerFactory(){}
public static ServerFactory getInstance(){
if(factory == null)
factory = new ServerFactory();
return factory;
}
//根据客户给出的名字返回对应的产品
public IServer getServer(String name){
if("Add".equals(name)){
return new AddServer();
}else if("Sub".equals(name)){
return new SubServer();
}else{
return null;
}
}
public static void main(String args[]){
IServer addserver = ServerFactory.getInstance().getServer("Add");
addserver.calc(5,3);
}
}
218. Web容器里面的对象存活周期？
Web容器里面的对象的存活周期由JVM控制。某个对象有容器负责实例化或应用负责实例化，如果某个对象得不到任何引用，
则由JVM的垃圾收集器负责销毁。
219. struts2中action的对象的生命周期？
用spring来控制action的生命周期Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。
220. annotation的使用方法和用途主要分为几类？
答 1、内建Annotation——Java5.0版在java语法中经常用到的内建Annotation：
2、开发者自定义Annotation：由开发者自定义Annotation类型；
3、使用第三方开发的Annotation类型
221. 说说你对IOC的理解
答：1.控制反转（Inversion of Control，英文缩写为IoC）是一种设计模式；
2.控制反转还有一个名字叫做依赖注入（Dependency Injection）。简称DI；
应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。
222. 从action类，servlet依赖，action执行的控制、线程模式几个方面谈struts1和struts2的区别。
答：从action类上分析:
1.Struts1要求Action类继承一个抽象基类。Struts1的一个普遍问题是使用抽象类编程而不是接口。
2. Struts 2 Action类可以实现一个Action接口，也可实现其他接口，使可选和定制的服务成为可能。Struts2提供一个ActionSupport基类去实现常用的接口。Action接口不是必须的，任何有execute标识的POJO对象都可以用作Struts2的Action对象。
从Servlet 依赖分析:
3. Struts1 Action 依赖于Servlet API ,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
4. Struts 2 Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest 和 HttpServletResponse的必要性。
从action线程模式分析:
5. Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
6. Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）
223. 如何理解struts,jsf,struts2的工作原理
答：1.JSF和STRUTS工作原理大致相同,有一个中心控制器即一个servlet,
2.JSF:用一个JAVABENA里的属性绑定页面表单值,而struts用ActionFrom对应表单值;
3.JSF在一个JAVABEAN里处理从页面送来的个值,而struts则是把actionFrom的值送给对象的ACTION来处理,两者都是MVC模式的.
224. 整合spring 与struts的方法，那种最好，为什么？
答：1.第一种方法:
Struts的Action继承Spring的ActionSupport类，并在Action中获取Spring的ApplicationContext。这是最简单的一种整合方式，但有三个缺点：第一，Struts与Spring紧密耦合，不能改换到其他IoC容器；第二，难以使用Spring AOP特性；第三，对于需要使用DispatchAction的Struts应用无能为力。
2.第二种方法:
在Struts的配置文件中，以Spring的DelegatingRequestProcessor类代替Struts的RequestProcessor类，并在Spring的配置文件中定义与Struts配置文件中<action-mappings>对应的bean，从而将Struts的Action与Spring分开，并把Struts的动作置于Spring的控制之下。这种整合方式的优点是将不再依赖Spring这个特定的IoC容器，但必须依赖Struts的RequestProcessor类。
3.第三种方法:
通过Spring的DelegatingActionProxy类代理Struts的动作，即在Struts配置文件中，定义<action-mappings>的type属性全部改为DelegatingActionProxy，而不是具体的类名，并在Spring配置文件中定义与Struts动作映射对应的bean，从而将Struts的Action与Spring分开，并把Struts的动作置于Spring的控制之下。无疑，这是最灵活的一种整合方式。
225. springframework与struts的不同之处
答：1. SpringFramework是一个采用了反转控制（InversionofControl,Ioc）策略的基于J2EE 的轻量级应用框架。核心是IoC容器，对于其它应用，如数据库访问，日志等，SpringFramework多使用现有的、成熟的框架。它采用了模块化的方式，各模块可以共同使用，也可以单独使用其中的一个模块。
2． struts2利用成熟的struts1和webwork整合使之操作更加方便;
226. spring使用了哪些设计模式，这样用有什么好处？
Dao模式 通过实现DAO,我们达到了解耦合的目的,使的程序更加的健壮,但复杂性增加了；
227. spring对多种ORM 框架提供了很好的支持，结合事务管理描述spring中使用Hibernate的方法。
答：spring中采用aop模式注入hibernate的sessionfactory和事务管理,在dao中调用.Spring集成hibernate有两种方式,一是dao层只与hibernate有关, 不使用任何spring 的api, 然后把dao注入到ioc容器.二是使用spring的hibernateDaoSupport.事务管理也可以只使用hibernate的事务管理.
228. struts中action是全局的还是局部的，为什么？
是全局
229. Hibernate有哪几种查询数据的方法？
答:hibernate在查询方式上有三种方式:HQL SQL QBC
230. http和ftp的默许使用端口是什么？
答：http：80 ftp：21
231. Ping命令的作用？
答：Ping命令的主要作用是通过发送数据包并接收应答信息来检测两台计算机之间的网络是否连通。当网络出现故障的时候，可以用这个命令来预测故障和确定故障地点
232. 构造器的名能不能和类的名字相同？
答：可以！并且一定要相同
233. 在一个主方法类可不可以调用一个非静态的方法？
答：可以
234. 一个类中可不可以有2个公共的方法？
答：可以
235. Internet的最*的商业域名叫什么？
答： .com
236. GC是什么，为什么要使用它？
垃圾回收 (garbage collection, GC) 一个跟踪过程，它传递性地跟踪指向当前使用的对象的所有指针，以便找到可以引用的所有对象，然后重新使用在此跟踪过程中未找到的任何堆内存。公共语言运行库垃圾回收器还压缩使用中的内存，以缩小堆所需要的工作空间 因为你没有足够多内存,并且,你挺懒,不去自己清理内存,所以就有了 GC
237. 编程题:有一个数据文件:123 34 17 651234 345....这些数据都是随机产生的,编写程序读出该文件.并将其以从大到小的顺序输出到另一个文件中.
public void readtext(){
File file = new File("D:\test.txt");
List list= new ArrayList();
try {
BufferedReader br=new BufferedReader(new FileReader(file));
String data = "";
String line = null;
while ( (line = br.readLine()) != null) {
data = data.concat(line);
}
StringTokenizer stoken = new StringTokenizer(data, " ");
while (stoken.hasMoreTokens()) {
int i = Integer.parseInt(stoken.nextToken());
list.add(i);
}
} catch(Exception ex) {}
String[] str = new String[list.size()];
for(int i=0;i<list.size();i++){
str[i]=list.get(i);
}
Object iTemp= null;
for(int i=1;i<list.size();i++) {
for(int j=list.size()-1;j>=i;j--) {
if(str[j]>str[j-1]) {
iTemp = str[j-1];
str[j-1] = str[j];
str[j] = iTemp;
}
}
String result = "";
for(int i=0;i<str.length;i++){
result +=str[i]+" ";
}
//将result写入另外一个文件即可。
}
238. 从一到十九共十九个数,打印出利用这十九个整数任意多个相加等于20所以可能性,每个数字在同一个算式中只出现一次.
public void test(){
Integer[] a = new Integer[19];
for(int i=1;i<20;i++){
a[i-1]=i;
}
for(int i=0;i<18;i++){
for(int j=18-i;j<18;j++)
if(a[i]+a[j]==20)
System.out.println(a[i]+"+"+a[i+1]+"="+20);
}
}
239. JSP内置对象作用，如何取Cookie的方法
使用request对象的getCookies()方法取cookies
(1) HttpServletRequest类的Request对象
作用：代表请求对象，主要用于接受客户端通过HTTP协议连接传输到服务器端的数据。
(2) HttpServletResponse类的Respone对象
作用：代表响应对象，主要用于向客户端发送数据
(3) JspWriter类的out对象
作用：主要用于向客户端输出数据;
Out的基类是JspWriter
(4) HttpSession类的session对象
作用：主要用于来分别保存每个用户信息，与请求关联的会话；
会话状态维持是Web应用开发者必须面对的问题。
(5) ServletContext类的application对象
作用：主要用于保存用户信息，代码片段的运行环境；
它是一个共享的内置对象，即一个容器中的多个用户共享一个application对象，故其保存的信息被所有用户所共享.
(6) PageContext类的PageContext对象
作用：管理网页属性,为JSP页面包装页面的上下文，管理对属于JSP中特殊可见部分中已命名对象的访问，它的创建和初始化都是由容器来完成的。
(7) ServletConfig类的Config对象
作用：代码片段配置对象，表示Servlet的配置。
(8) Object类的Page（相当于this）对象
作用：处理JSP网页，是Object类的一个实例，指的是JSP实现类的实例，即它也是JSP本身，只有在JSP页面范围之内才是合法的。
(9)Exception
作用：处理JSP文件执行时发生的错误和异常
240. 写几个线程安全类，不安全的，支持排序的类名？
线程安全类：Vector 、Hashtable、
不安全的类：ArrayList、HashMap、Linkedlist
支持排序的类：TreeSet
JDK也提供一个对集合类进行线程安全处理的类Collections类，可以对一些非结程安全的类进行同步处理。
241. 将ISO8859-1字符串转成GB2312编码，语句为？
String s=new String(text.getBytes(“iso8859-1”),”gb2312”).
242. 说出你用过的J2EE标准的WEB框架和他们之间的比较？
答：用过的J2EE标准主要有：JSP&Servlet、JDBC、JNDI、JavaMail、JTA、XML、RMI、WebServices等。这些标准主要提供了对于WEB框架的全方位的支持与整合，通过Web容器来管理这些中间件，使得Web框架开发实现者，只需注重应用系统的实现，而不必关注与业务不相关的逻辑，大大降低了开发成本和开发周期。同时这些中间年良好的扩展性、平台不相关性，也使得这个标准成为大多数Web框架所采用。
243. 类库有哪些？
Xerces ，JDOM dom4j XOM jConfig XStream
244. <jsp:include>与<%@include>的区别
动态INCLUDE用jsp:include动作实现 它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面，不能实现参数共享。
245. 怎么样手动启动Oracle数据库？
答：第一步：启动Oracle在OS下的监听程序。第二步：启用OS下的实例服务。第三步打开数据库。
246. WEB SERVICE 的理解
Web Service主要是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。 Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。注：SOAP协议（Simple Object Access Protocal,简单对象访问协议）,它是一个用于分散和分布式环境下网络信息交换的基于XML的通讯协议。在此协议下，软件组件或应用程序能够通过标准的HTTP协议进行通讯。它的设计目标就是简单性和扩展性，这有助于大量异构程序和平台之间的互操作性，从而使存在的应用程序能够被广泛的用户访问。
247. 写一个递归编程
public class Test {
static int multiply(int n){
if(n==1||n==0)
return n;
else
return n*multiply(n-1);
}
public static void main(String[] args){
System.out.println(multiply(10));
}
248. AWT和Swing的区别？
一般swing组件是从awt组件扩展的,swing是轻量组件 而awt是重量组件， AWT是比较依赖操作系统组件，功能少，Swing不依赖，组件多，功能多 窗口风格更多样化 Swing是由纯JAVA CODE所写的，解决了JAVA因窗口类而无法跨平台的问题，使窗口功能也具有跨平台与延展性的特性，而且SWING不需占有太多系统资源，并且一些组件也采用一些更开放式的开发方式，支持更多的扩展。
249. 哪几个方法可以实现一个线程？
一种是声明 Thread 的子类,重载 Thread 类的方法 run。 另一种途径是声明一个类，该类实现 Runnable 接口。然后再实现方法 run。
250. STOP()和SUSPEND()不推荐使用的原因？
因为stop本质上就是不安全的。停止线程会导致解锁它已锁定的所有监视程序。suspend 从本质上就是易于死锁的一种操作。
251. JAVA事件有哪些模式？
1. 事件直接驱动模式。它的第一个要求就是性能的要求，需要直接而且快，是必须经常使用的，主要适合于迅速处理 前台的命令，往往是系统架构的重要部分，也是流程控制的主要模式。2.监控式事件模式是借助第三者来监控和触发事件，特点是： 有一个观察者置身事外在定期独立运行着。
252. 用javascript实现用户登录验证的代码.
<script language=javascript>
function checkSubmit()
{if ((document.form1.name.value)=='')
{
window.alert ('姓名必须填写');
document.form1.name.select();
document.form1.name.focus();
return false;
}
else
return true;
}
</script>
<form name="form1" onsubmit="javascript:return checkSubmit()">
<input type="text" name="name">
</form>
<%
253. uml三要素.
事物、关系、图
254. EJB规范规定的EJB禁止的操作有哪些？
1.不能操作线程和线程API(线程API指非线程对象的方法如notify,wait等)，
2.不能操作awt，
3.不能实现服务器功能，
4.不能对静态属生存取，
5.不能使用IO操作直接存取文件系统，
6.不能加载本地库.，
7.不能将this作为变量和返回，
8.不能循环调用。
255. TRUNCATE和DELETE有以下几点区别？
1、TRUNCATE在各种表上无论是大的还是小的都非常快。如果有ROLLBACK命令DELETE将被撤销，而TRUNCATE则不会被撤销。
2、TRUNCATE是一个DDL语言，向其他所有的DDL语言一样，他将被隐式提交，不能对TRUNCATE使用ROLLBACK命令。
3、TRUNCATE将重新设置高水平
256. http协议，tcpip协议解释
答：HTTP：超文本传输协议（Hypertext Transfer Protocol）
TCP/IP（Transmission Control Protocol/Internet Protocol)的简写，中文译名为传输控制协
257. //编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。
//但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6应该输出为“我ABC”而不是“我ABC+汉的半个”。
public static void main(String[] args) throws Exception{
String str = "我a爱中华abc def';
String str = "我ABC汉";
int num = trimGBK(str.getBytes("GBK"),5);
System.out.println(str.substring(0,num) );
}
public static int trimGBK(byte[] buf,int n){
int num = 0;
boolean bChineseFirstHalf = false;
for(int i=0;i<n;i++)
{
if(buf[i]<0 && !bChineseFirstHalf){
bChineseFirstHalf = true;
}else{
num++;
bChineseFirstHalf = false;
}
}
return num;
}
258. java程序每天12点打印”hello”
public static void main(String[] args) {
Date date = new Date();
System.out.println(date.getHours());
while (true) {
while (date.getHours() == 12) {
if (date.getMinutes() == 0) {
if (date.getSeconds() == 0) {
System.out.println("hello world!");
}
}
}
}
}
259. 编程题：读取一个文件在控制台打印出来
File file = new File("E:\\课件\\二期课件\\Java\\T09 src\\JRadioButtonDemo.java");
long file_length= file.length();
try {
//输入流
FileInputStream input = new FileInputStream(file);
byte b_data [] = new byte[(int)file_length];
input.read(b_data);
System.out.println(new String(b_data));
input.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
260. 解析XML的方法及对它的了解？
答：:有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
261. 你所熟悉的开源组件和框架，简单介绍下
答：FileUpload、 POI、WebWork、Struts1/2、hibernate、spring、Ajax、Ibatis
262. 要求WEB2。0是什么东西 ？
Web1.0 的主要特点在于用户通过浏览器获取信息。Web2.0 则更注重用户的交互作用，用户既是网站内容的浏览者，也是网站内容的制造者。所谓网站内容的制造者是说互联网上的每一个用户不再仅仅是互联网的读者，同时也成为互联网的作者；不再仅仅是在互联网上冲浪，同时也成为波浪制造者;在模式上由单纯的“读”向“写”以及“共同建设”发展；由被动地接收互联网信息向主动创造互联网信息发展，从而更加人性化
webservice和soap的区别？
Web ServiceWeb Service是基于网络的、分布式的模块化组件，它执行特定的任务，遵守具体的技术规范，这些规范使得Web Service能与其他兼容的组件进行互操作。
SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。 它是Webservice所采用的主要协议之一
。
263. 介绍几种WEB服务器，问Tomcat里面的文件组成？
IIS、apache、Tomcat
bin:启动,关闭Tomcat的命令.
common/lib:网络编程的jar文件.
conf:配置文件.
logs:日志文件.
server:自带的web应用(三个).
shared:所有web应用都可以访问的内容.
temp:临时.
webapps:默认站点文件夹.
work:jsp生成的类.
Tomcat是一个开放源代码、运行servlet和JSP Web应用软件的基于Java的Web应用软件容器。Tomcat Server是根据servlet和JSP规范进行执行的，因此我们就可以说Tomcat Server也实行了Apache-Jakarta规范且比绝大多数商业应用软件服务器要好。
264. ThreadLocal在项目中的实际意义？
ThreadLocal和其它同步机制相比从另一个角度来解决多线程的并发访问，它为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。还提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal
ThreadLocal可以大量减少参数的传递，可以使代码简洁，但一个线程会绑定多个自己定义的局部对象，ThreadLocal是抽象在线程上的对象创建工厂，目前的Tomcat5使用了线程池，一个线程处理一个request，这样ThreadLocal对象可以抽象的绑定在request生命周期，不会存在线程危机，而且线程池也平衡了这些ThreadLo
265. 不同的数据库里面有相同的表实现同步更新（从多方面考虑）
--用触发器可以实现两个数据表之间的数据同步更新
For Example:
Create Trigger room_texes_change_id
on room
for update
as if update(room.cstname)
set texes.cstname=room.cstname
where texes.id=room.id 。
266. ejb是基于哪些技术实现的，和javabean的区别？
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现 EJB是一个关于用JAVA语言开发的可部署的服务器端组件的组件体系结构。它是一个技术协议，能使组件运行于任何应用服务器,专门用来解决商务问题JAVABEANS是JAVA类，是由属性、事件和方法组成的JAVA组件，它们可以用来组成JAVA应用程序
267. 适配器模式解释：
把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类 能够一起工作。适配类可以根据参数返还一个合适的实例给客户端
268. Gc是什么，为什么要有GC
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。
269. switch可以作用于byte吗？可以作用于long，可以作用于string 吗？
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。
270. try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
也许你的答案是在return之前，但往更细地说，我的答案是在return中间执行，请看下面程序代码的运行结果：
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(new Test().test());;
}
static int test()
{
int x = 1;
try
{
return x;
}
finally
{
++x;
}
}
}
---------执行结果 ---------
运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。
271. 两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
对。
如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。
如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，我们没有理由不实现，通常都会去实现的。
272. 当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
引用传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。
273. 在Oracle中数据库中的一个表中，这个表没有主键id也没有特定标示来查数据，怎么查？
[题意不明：考虑从面试者的角度能是考伪列和rownum的内容]
考虑使用Oracle的伪列rowid来查询
274. 概述反射和序列化
反射Reflection 是Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查;能直接操作程序的内部属性和方法。
简单来说序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化，我们可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。而把Java对象转换为字节序列的过程称为对象的序列化。
275. 简述WebService和Remoting的特点和运用场景
Web Service主要是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。 Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。Remoting 依赖于特定语言的远程调用机制，比如Java的RMI/IIOP它的设计目标就是简单性和扩展性，这有助于大量异构程序和平台之间的互操作性，从而使存在的应用程序能够被广泛的用户访问。
276. dao 是什么及作用
DAO组件主要提供数据库访问操作，主要是对各自数据表的CRUD方法，在一般设计过程中为了考虑松耦合的问题，业务逻辑层中不应当牵涉到任何持久层实际操作，所以可以将各数据源表的操作特性封装到DAO组件中去，这样增强了系统的可读性、可维护性。
277. Inserted和deleted的含义？
SQLServer的DML触发器中两个临时表
inserted表反映插入或更新操作时插入的记录
deleted表反映删除或更新操作时删除的记录
278. 3个框架在项目在项目当中的用，basedao是用来做什么的。
DAO组件主要提供数据库访问操作，针对不同数据源表进行了封装，这样可以提供其它层的访问接口，使得组件之间解耦，而BaseDAO是这些所有不同DAO的公共特性的封装，针对一些可以进一步进行细化的DAO组行的进一步抽象，使组件的移值性更为灵活。
279. Orace中除了数据库[XX]备份，还有什么方法备份？
1.导出／导入（EXP/IMP）。
2.热备份。 热备份是在数据库运行的情况下，采用archivelog mode方式备份数据库的方法。所以，如果你有昨天夜里的一个冷备份而且又有今天的热备份文件，在发生问题时，就可以利用这些资料恢复更多的信息。热备份要求数据库在Archivelog方式下操作，并需要大量的档案空间。一旦数据库运行在archivelog状态下，就可以做备份了。
3.冷备份。冷备份发生在数据库已经正常关闭的情况下，当正常关闭时会提供给我们一个完整的数据库。冷备份时将关键性文件拷贝到另外的位置的一种说法。
280. jsp与servlet中请求转发的区别
forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址，但此转发是连续的转发，在转发过程中请求参数也连续转发到目标地址中。
redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求。前者对请求是连续的，后者是重新发送一个新的请求，所以只能重新发送新的请求参数，原有的请求参数将不再连续到目标页面。
281. 分页的优化需考虑哪些
sql语句的优化：ID排除法、三层嵌套等
表的优化：适当使用索引
282. web运用程序的稳定、安全需要考虑哪些
Web服务器的性能考虑主要有：并发用户数、事务安全、负载均衡、时段流量、网络带宽
安全性：
· 关键数据的保护，例如用户数据等
· 功能服务的正常提供。
· 网站的防攻击能力
· 对异常灾害的恢复能力
程序性能：
· 响应请求并运行得出结果的平均时间
· 错误的检测和拦截
· 扩展性
283. 问spring的AOP，mvc到底是怎么优化程序的结构？
SpringAOP主要提供了Pointcut、Aspects等以及它们如何被织入应用程序、代理的方式等等进行优化的控制。而Spring MVC里面前端控制器叫做DispatcherServlet。里面充当Action的组件叫做Controller，返回的视图层对象叫做ModelAndView，提交和返回都可能要经过过滤。从而提高程序可读性和稳定性。
284. 笔试：1.LinkedList和ArrayList内部是如何实现的？new ArrayList（10）意思
ArrayList的内部实现是基于内部数组Object[]，所以从概念上讲，它更像数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更像一个链表结构，所以，它们在性能上有很大的差别。
new ArrayList（10）构造一个初始容量为 10 的空列表
285. 定义一个变量，Var v =new Object (),用js编写的简便写法是什么？
var v = {};
286. 网上购物系统的类图，用例图。
主要的类有：商品分类 商品 订单 订单项 商品评论
主要用例有：查看商品详情 发表评论 登录 注册 购物车管理 订单生成 查询订单等
287. 给你一个整数类型的数组，按从小到大的顺序进行排列！
Array.sort(int a[]);//默认为升序排列
288. 查询出M 页的N行数据 。
答：
SQL实现：select top N from a where id not in
(select top 每页显示 * (M-1) id from students order by id) order by id
MYSQL:select * from a limit m,n
289. 把二叉树从小到大遍历出来怎么实现？
public class Node {
public int value;
public Node left;
public Node right;
public void store(int value)
{
if(value<this.value)
{
if(left == null)
{
left = new Node();
left.value=value;
}
else
{
left.store(value);
}
}
else if(value>this.value)
{
if(right == null)
{
right = new Node();
right.value=value;
}
else
{
right.store(value);
}
}
}
public boolean find(int value)
{
System.out.println("happen " + this.value);
if(value == this.value)
{
return true;
}
else if(value>this.value)
{
if(right == null) return false;
return right.find(value);
}else
{
if(left == null) return false;
return left.find(value);
}
}
public void preList()
{
System.out.print(this.value + ",");
if(left!=null) left.preList();
if(right!=null) right.preList();
}
public void middleList()
{
if(left!=null) left.preList();
System.out.print(this.value + ",");
if(right!=null) right.preList();
}
public void afterList()
{
if(left!=null) left.preList();
if(right!=null) right.preList();
System.out.print(this.value + ",");
}
public static void main(String [] args)
{
int [] data = new int[20];
for(int i=0;i<data.length;i++)
{
data[i] = (int)(Math.random()*100) + 1;
System.out.print(data[i] + ",");
}
System.out.println();
Node root = new Node();
root.value = data[0];
for(int i=1;i<data.length;i++)
{
root.store(data[i]);
}
root.find(data[19]);
root.preList();
System.out.println();
root.middleList();
System.out.println();
root.afterList();
}
}
290. mysql分页怎么实现，oracle分页怎么实现，他们之间的区别？
Ajax是一个RIA应用技术，解决富Web客户端问题，提高用户体验的
jms是Java的消息服务系统，解决Java分布式应用消息异步通信
mysql中的limit关键字查询出指定区间的记录进行分页。
oracle中通过rownum来记录结果集记录编号实现分页
291. 描述struts体系结构？对应各个部分的开发工作主要包含哪些？
按MVC设计的Web架构，
其中Model为ActionForm组件的设计
View为Struts标签的使用
Controller为Action组件的设计和ActionServlet的配置
292. 组合优于继承。你是否同意这句话，并说明
继承和组合都可以实现代码的重用（Reuse），为什么组合要优于继承呢？
通过继承，子类能够获得与父类相同的功能和属性，父类拥有了某种功能，子类就有了；但是如果子类需 要新的功能，直接在父类里面增加新的功能，那么会导致所有的子类同时拥有这种功能，这实际上是将类的功能与类紧紧的耦合在一起，是一种紧密耦合系统，由于 关系相当密切，导致改动一处而动全身，实际上不利于代码的重用。而组合恰好相反，她把类的各项功能分割开，互不干涉。一个类的功能，实际上是各种子功能的 组合，比如鸭子的功能就是飞行功能和发出叫声功能的组合，无论是何种鸭子，都是这样。同时到底是怎样飞行，怎样叫，又可以通过面向接口的编程实现多态。
51．javascript取浏览器的版本 里面还有哪些对象？
<script type="text/javascript">
function getBrowser(){
var bro = navigator.userAgent.toLowerCase();
if(/msie/.test(bro)) return 'IE' + bro.match(/msie ([\d.]*);/)[1]
else if(/navigator/.test(bro)) return 'NS' + bro.match(/navigator\/([\d.]*)/)[1]
else if(/chrome/.test(bro)) return 'CR' + bro.match(/chrome\/([\d]*)/)[1]
else if(/safari/.test(bro)) return 'SF' + bro.match(/version\/([\d]*)/)[1]
else if(/opera/.test(bro)) return 'OP' + bro.match(/version\/([\d]*)/)[1]
else if(/firefox/.test(bro)) return 'FF' + bro.match(/firefox\/([\d]*)/)[1]
}
</script>
293. 如何运行本地的EXE文件？
双击运行,或者在DOS窗口中通过命令运行
294. struts中的prepare怎么用？
首先Action组件实现Preparable接口的prepare()方法，在配置 Action组件时应用PrepareInterceptor拦截器。
295. Hrbernate的二级缓存讲述。
hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的时候，一级缓存就失效了。
二级缓存是SessionFactory级别的全局缓存，它底下可以使用不同的缓存类库，比如ehcache、oscache等。hibernate在执行任何一次查询的之后，都会把得到的结果集放到缓存中，缓存结构可以看作是一个hash table，key是数据库记录的id，value是id对应的pojo对象。当用户根据id查询对象的时候（load、iterator方法），会首先在缓存中查找，如果没有找到再发起数据库查询。
296. 如果做个招聘网站性别只招男的，年龄20-30，如果不匹配就不能让他投简历，怎么实现？ 填身份证时如何让该人信息全部显示出来？
使用JavaScript做客户端检验，填身份证时使用Ajax获取人员信息；
297. 软件的开发过程、以及角色？
软件立项 à 需求分析 à 概要设计 à 详细设计 à 编码测试 à 验收运行
| | | |
|------------ 分析员 ---------|--------------程序员---------------|------------测试员-------|
298. Io流 InputStream与Reader的区别 ,怎样将字符流转换成字节流
InputStream 字节输入流、Reader字符输入流
OutputStreamWriter 是字符流通向字节流的桥梁
InputStreamReader 是字节流通向字符流的桥梁
299. 启动线程调用那个方法 ？为什么要调用start（）方法？若调用run（）方法会出现什么情况？
面试题上有
300. Struts2.0 若在一个方法中返回的是null，表明什么?struts.xml还需要配置吗？为什么？struts有那些标签？struts.xml中有那些标签？
方法返回null，表示没有视图结果回应，当然自己通过流直接输出响应结果，则struts.xml只需对Action进行映射配置，而无须进行结果配置。
301. Hibernate 运行的流程？优缺点？为什么insert比select快？可以批量insert一些数据吗？
Hibernate应该是建立在JDBC基础上的一个开源的ORM映射框架，很好的封装了实体映射实现，提供友好的实体操作接口，以及基于HQL的查询接口，在开发中可以减少编写SQL相关代码，提高效率和减少出错。
以面向对象的方式操作数据库，进行增删改很方便，但执行复杂的查询时则很费事麻烦。
select查询可能需要执行多条SQL语句，牵涉到加载策略所以执行需要消耗很多时间，相比insert操作要慢些。
hibernate可批量insert一些数据，配置文件中设置hibernate.jdbc.batch_size参数，来指定每次提交SQL的数量。
302. sqlserver查询 怎样取得JAVA虚拟机默认的编码方式？
可通过Charset.defaultCharset()来获取
303. 智力题：
1、有一辆火车以15公里/小时从洛杉矶开往纽约，一辆火车以20公里/小时从纽约开往洛杉矶，一只鸽子以30公里/小时从洛杉矶开往纽约，鸽子和两辆火车同时出发，鸽子遇到火车转头，向另一辆火车飞，直到两辆火车相遇，问鸽子飞了多少公里？
假设洛杉矶到纽约的距离为s
那小鸟飞行的距离就是(s/(15+20))*30。
2、有两根不匀称的香，烧完1小时，问如何知道1 5分钟
把香称重，取出总重量的1/4
3一群人在一黑屋子，有黑白2种帽子，每人可以看其他人的帽子，至少1顶黑帽子。如果知道自己是黑帽子，打自己一巴掌。第一次开灯，无人，关灯。第二开灯，无人，关灯。第3次，听到劈劈啪啪的声音。问有几顶黑帽子。
304. 什么是 联通图的生成树？
什么是哈夫曼树？什么是平衡二叉树？写一个深度优先排序，写一个广度优先排序？写出 C语言对链表HEAD的排序？
连通图的生成树——是连通图的一个极小连通子图，它含有图中全部顶点，但只有足以构成一棵树的n-1条边。
哈夫曼树又称最优树（二叉树），是一类带权路径最短的树。构造这种树的算法最早是由哈夫曼(Huffman)1952年提出，这种树在信息检索中很有用。
如果任意节点的左右子树的深度相差不超过1，那这棵树就是平衡二叉树。
305. 哪些不是JAVA关键字：TRUE sizeof native是关键字
sizeof不是 大写的TRUE不是
306. 怎样知道给出的两条线段是否相交，用伪码实现。
假设线段AB,A(X1,Y1),B(X2,Y2);线段CD,C(X3,Y3),D(X4,Y4);
1。判断两斜率 相等则不相交
2。若斜率不等
307. ORACLE数据库用到了哪些方面，怎样优化数据库。SQL语句过长时，怎样优化？
(1) 使用分区这种手段。所谓分区就是动态地将表中的记录分离到若干不同的表空间上，使数据在物理上被分割开来，便于维护、备份、恢复、事务及查询性能。
(2) 重建索引，及时回收那些未使用空间，提高空间利用率。
(3) 调整SGA参数
sql语句长：用存储过程！
308. JAVASCRIPT的一些常用东西：如提示框如何实现的 ：MVC
使用jQuery等第三方的插件Dialog即可，无需重复造*。
309. 两个SQL语句 一个ArrayList里面存了一些Student对象，Student对象有Name和Age两人属性，此类里面有set和get方法，要求以Age来降序排序。
要求Student实现Comparable接口的compareTo()方法来按照age判断对象的大小，并且大于时返回-1，小于时返回1，相等则返回0。
310. 有一些奇数和偶数，无序的，要求写一个方法，实现将所有的奇数放在全部的偶数前面
主要代码如下：主要采用快速排序的算法。
int[] n = {1,2,5,6,4,7,10,9,3,8};
int m = n[0];
int j = n.length -1;
int i= 0;
while(i<j){
while(i<j && n[j]%2==0){j--;}
if(j>=i){
n[i++] = n[j];
}
while(i<j && n[i]%2!=0){i++;}
if(i<=j){
n[j--] = n[i];
}
}
n[i] = m;
for(int k=0;k<n.length;k++){
System.out.print(n[k] + " ");
}
311. 你对工作流和表单的理解
一个工作流包括一组活动及它们的相互顺序关系，还包括过程及活动的启动和终止条件，以及对每个活动的描述。一个完整的工作流管理系统通常由工作流引擎、可视工作流设计、流程操作、工作流客户端程序、流程监控、表单设计工具、与表单的集成以及与应用程序的集成八个部分组成。工作流引擎作为工作流管理系统的核心部分，主要提供了对于工作流定义的解析以及流程流转的支持。
表单用来显示查询或输入的业务数据。
312. Classpath怎么设置和它的意义是什么？
比如，set CLASSPATH=C:\Java\jdk1.6.0_10\lib\dt.jar;.
设置class文件的搜索路径
313. 用java写一个读取盘符的名字
new File("").getAbsolutePath().substring(0, 1);
314. Deprecated API 是什么意思？
deprecated是指已经过时，但是为了向前兼容起见仍然保留的方法，这些方法可能会在以后取消支持。你应当改用较新的方法。一般在API里面会说明你应当用什么方法来代替之。
315. 如何去掉JAVA的 内存机制？
是不是垃圾回收机制，使用System.gc()强制回收。
316. 缺少IDE如何编译JAVA代码？
使用JDK的javac.exe 直接手工编译
或使用Apache的ANT脚本构建
317. THHP与HTTPS有什么区别？
HTTP为普通WEB协议、HTTPS为加密WEB协议。默认http为tcp80端口。https为tcp443端口
318. Session的具体用法？
Session用来保存每一个用户的专有信息，比如像用户登录验证、购物车。
1.ibatis 中的#与$的区别
1.#是把传入的数据当作字符串，如#field#传入的是id,则sql语句生成是这样，order by "id",这当然会报错．．
2.$传入的数据直接生成在sql里，如#field#传入的是id,则sql语句生成是这样，order by id, 这就对了．
3.#方式能够很大程度防止sql注入．
4.$方式无法方式sql注入．
5.$方式一般用于传入数据库对象．例如传入表名.
6.一般能用#的就别用$.
319. 请裂举session、cookie、viewstated的应用范围
Session 服务器端维护， 某个用户活动时间 + 延迟时间（默认20分钟），
Cookie 客户端维护， 程序可指定生命周期，
ViewState 小量数据，一个web页面的生命期
320. 用什么方法使服务器关闭之后，session所保存的信息不会丢失？
将session信息保存到数据库中或文件中
321. B2C和C2C你们是怎么区别的？
Business（企业）、Customer（消费者）
B2C的B是Business企业，2则是to的谐音，C是Customer消费者，所以B2C是企业对消费者的电子商务模式。这种形式的电子商务一般以网络零售业为主，主要借助于Internet开展在线销售活动。B2C简而言之是就是商家与顾客之间的商务活动，也就是通常所说的“网上购物网站”，企业、商家可充分利用电子商城提供的网络基础设施、支付平台、安全平台、管理平台等共享资源有效地、低成本地开展自己的商业活动。
C2C就是消费者（consumer）与消费者（consumer）之间的电子商务。打个比方，比如一个消费者的有一台旧电脑，通过网上拍卖，把它卖给另外一个消费者，这种交易类型就称为c2c电子商务。主要是指网上拍卖。c2c模式的特点就是大众化交易，因为是个人与个人之间的交易！
322. 用最好效率写一个2*17等于多少？
（2<<4）+ 2
323. 用4 个0，用你所知道的数学方法计算出24
0的阶乘等于1 即 0！＝１那么４个0就是４了
又4的阶乘为２４ ４！＝２４
324. 10怎样计算等于24？ (10×10-4)÷4=24
325. 有一个长方形蛋糕,切掉长方形一块,怎样一刀切下去成大小相等两块
将完整的蛋糕的中心与被切掉的那块蛋糕的中心连成一条线。这个方法也适用于立方体
326. 九个球不知道哪个轻重，让你称？
4个和4个称，若相等则剩下一个是比较重要(2)若不相等，则往那边不相等的那4个球中取两个分为一组，则左2个，右2个，则有左边或右边右一个是比较重的，从任意一边取一个投入另一方，并记住这个球，从其它4个取两个放入另外一边，并记住这两个球，若从一边取走的放到另一边后，那边重，则这球比较重要，若从一边取走的放到另一边后，那边轻，则为另外一边所剩的一个球发
Java基础部分：
1. 怎样得到一个文件的后缀名，io的设计思路：
ü 调用File.getName()得到文件完整名fname
ü 得到文件名中的.号位置 int poc = fname.indexOf(".");
ü 得到后缀 ftype = fname.substring(poc+1);
2. int x=1 int y='a'<'A' ? x--:x++; , 求x 的最终值 ：2；
3. Integer a和int b运行之后a和b有什么不同？都没有赋值的情况下他们的初始值各是什么?
答：Integer a 定义为整型变量对象，默认值为null；int b 定义为整数变量，默认值为0；
4. 什么原因，怎么解决NullPointerException异常？
答：对没有赋值或为null的对象进行处理会导致NullPointerException异常，最好在使用对象变量之前对该变量进行非null判断
5. PHP中：echo和print的区别？
答：echo可以同时输出多个字符串，并不需要圆括号；print只可以同时输出一个字符串，需要圆括号。
6. （编程题）求一百以内质数
public class ZhiShu {
public static void main(String[] args) {
System.out.println("1~100的质数有：");
for (int n = 1; n <= 100; n++) {
boolean b = true;
if (n != 1) {
for (int i = 2; i < n; i++) {
if (n % i == 0) {
b = false;
break;
}
}
}
if (b) {
System.out.println(n );
}
}
}
}
7. 六行五列字符串数组（分别用C和java实现）
Java: int a[][]= new int[6][5]; //java申明不需要初始化，此时有默认值
C: int b[6][5]; //C申明必须要初始化值
8. （编程题）把int值保存在byte数组中〈高位在前〉
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
public class IntToByte {
public static void main(String[] args) throws Exception {
System.out.println(byteArrayToInt(intToByteArray1(456548)));
System.out.println(byteArrayToInt(intToByteArray2(456548)));
}
/**
*/
public static byte[] intToByteArray1(int i) {
byte[] result = new byte[4];
result[0] = (byte) ((i >> 24) & 0xFF);
result[1] = (byte) ((i >> 16) & 0xFF);
result[2] = (byte) ((i >> 8) & 0xFF);
result[3] = (byte) (i & 0xFF);
return result;
}
/**
*/
public static byte[] intToByteArray2(int i) throws Exception {
ByteArrayOutputStream buf = new ByteArrayOutputStream();
DataOutputStream out = new DataOutputStream(buf);
out.writeInt(i);
byte[] b = buf.toByteArray();
out.close();
buf.close();
return b;
}
｝
9. （编程题）写一个方法：输入的是文件名，输出的是文件内容字符串(FileToString.java 考察IO与String与StringBuffer的区别)
File f = new File("hello.txt");
StringBuffer sb = new StringBuffer();
try{
FileReader in = new FileReader(f);
char[] buf = new char[1024];
while(in.read(buf)!=-1){
//将每次读取的内容放到StringBuffer中
sb.append(new String(buf).trim());
}
System.out.println(sb.toString());
}
catch(Exception e){
System.out.println(e.getMessage());
e.printStackTrace();
}
10. （编程题）创建个静态方法，传个对象，循环打印对象的类名跟方法名，用代码（反射机制）
public static void display(Object clazz) throws ClassNotFoundException {
System.out.println("对象的类名....." + clazz.getClass().getName());
System.out.println();
// 得到构造方法
Constructor cons[] = clazz.getClass().getConstructors();
for (int i = 0; i < cons.length; i++) {
Constructor c = cons[i];
String name = c.getName();
Class cs[] = c.getParameterTypes();
System.out.print("对象的构造方法....." + c.getModifiers() + " " + name
+ "(");
for (int j = 0; j < cs.length; j++) {
System.out.print(" " + cs[j].getName() + " ");
}
System.out.println(" )");
}
System.out.println();
// 得到其他方法
Method method[] = clazz.getClass().getMethods();
for (int i = 0; i < method.length; i++) {
Method m = method[i];
String name = m.getName();
Class ms[] = m.getParameterTypes();
System.out.print("对象的其他方法....." + m.getModifiers() + " " + name
+ "(");
for (int j = 0; j < ms.length; j++) {
System.out.print(" " + ms[j].getName() + " ");
}
System.out.println(" )");
}
}
11. （编程题）写一个判断对称数的方法
/**
* 对称数就是顺读和反读都一样吗，你可以用一个String接受用户输入，
* 然后把它反转，判断前后是不是equals就可以了。
* 例如 123321就是对称数
*/
public static void RegularNumberTest() {
String num1 = new Scanner(System.in).nextLine();
String num2 = "";
for (int j = num1.length() - 1; j >= 0; j--) {
char a = num1.charAt(j);
num2 += a;
}
if (num2.equals(num1)) {
System.out.println(num1 + "是对称数.");
}else{
System.out.println(num1 + "不是对称数.");
}
}
12. String和StringBuilder的区
答：StringBuilder是一个可变的字符序列，该类提供一个与 StringBuffer 兼容的 API，但不保证同步，存储效率比StringBuffer高；而String 是不可变的对象；
13. String str=new String(“abc”)内存中怎么分配的？
答：先在栈中分配一块空间，存放str,然后会在堆中分配一块空间，存放abc，且栈中的str指向堆中的abc地址
14. （编程题）1.1.2.3.5.8.13.21.求N位是多少，用递归实现
// 1.1.2.3.5.8.13.21.求N位是多少
public static int amwih(int i) {
if (i <= 0)
return 0;
else if (i > 0 && i <= 2)
return 1;
else
return amwih(i - 1) + amwih(i - 2);
}
15. 128>>1和128<<1结果分别是多少？
答：128>>1 = 64;
128<<1 = 256;
16. （编程题）用程序打印出下面的金字塔:（杨辉三角）
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 n-1 ......n-1 1
import java.util.Scanner;
public class YangHuiSanJiao {
int array[][];
public void creat() {
for (int i = 0; i < array.length; i++)
for (int j = 0; j < array[i].length; j++) {
if (j == 0)
array[i][j] = 1;
else if (i == j)
array[i][j] = 1;
else if (j > i)
array[i][j] = 0;
else
array[i][j] = array[i - 1][j - 1] + array[i - 1][j];
}
}
public static void main(String args[]) {
int n, m;
System.out.println("请输入行数n:");
Scanner sc = new Scanner(System.in);
n = m= sc.nextInt();
YangHuiSanJiao aa = new YangHuiSanJiao();
aa.array = new int[n][m];
aa.creat();
for (int i = 0; i < aa.array.length; i++) {
for (int j = 0; j < aa.array[i].length; j++)
if (aa.array[i][j] == 0)
System.out.print(" ");
else
System.out.print(aa.array[i][j] + " ");
System.out.println();
}
}
}
17. （编程题）给出一个数字，如123456，输出123.456,输入1234567，输出123.456.7，但是输入如12，输出是12。(但是不能用format)即针对整数使用财会方式进行输出提示，考察对字符的使用技巧
public static String numberFormat(int num) {
StringBuffer sb = new StringBuffer(String.valueOf(num));
int sblen = sb.length();
int index = 0;
while (index + 3 < sblen) {
index = index + 3;
sb = sb.insert(index, ".");
index++;
sblen++;
}
return sb.toString();
}
18. 简要介绍java如何实现安全性
Java通过提供一个”安全沙箱“来保证从网络或者其他不信任的地方下载并运行的程序不会破坏本地数据，其中包括：
ü 类装载器结构
ü class文件检验器
ü 内置于Java虚拟机（及语言）的安全特性
ü 安全管理器及Java API
19. 为什么说java是解释性的？
答：java是由java源代码编译成字节码存放在 .class文件中的. 而执行时,是由java虚拟机(jvm)读取字节码文件翻译并执行的. 所以java是解释性的
20. （编程题） 1）实现从字符串"<text>你好，欢迎来到我们公司面试</text>",提取中文字符串 2）把上题中的"我们公司"改写成"玄武科技"
String str = "<text>你好，欢迎来到我们公司面试</text>";
int indexS = str.indexOf("<text>") + 6;
int indexE = str.lastIndexOf("</text>");
str = str.substring(indexS, indexE);
System.out.println(str);
str = str.replaceAll("我们公司", "玄武科技");
System.out.println(str);
21. （编程题）写一个流的读入程序，每次只能读一行
try {
BufferedReader br = new BufferedReader(new FileReader(new File("hello.txt")));
String s = null;
// readLine()包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
while ((s=br.readLine())!=null) {
System.out.println(s); // 转换成字符
}
} catch (Exception e) {
e.printStackTrace();
}
22. CURD是什么，怎么实现
CURD: Cread、Update、Read、Delete，就是对数据库记录的创建（添加insert）、修改、读取（select）、删除；
在java编程中主要是通过jdbc来实现的，但可以使用其他的中间件来简化jdbc的复杂操作，例如hibernate、ibatis等；
23. （编程题）求一个二叉树中值的和（考察遍历二叉树）
// 前序遍历,同时记录出所有节点值的和
private int firstRootSum(TreeNode root, int sum) {
if (root!= null){
sum = sum+root.getNum();
sum = firstRootSum(root.getLeft(),sum);// 左
sum = firstRootSum(root.getRight(),sum);// 右
}
return sum;
}
24. Java代码如下person p=new person（）；中p放在什么位置？
答：其中对象句柄p放在栈中
25. （编程题）字符串的分割如“abc|ddd||0dc”写一个类似split的方法分割输出出来
//Object[] obj = SplitString2.splitString("|abc|de||e|||", "|");
public static Object[] splitString(String str, String regex) {
ArrayList alist = new ArrayList();
StringBuffer sb = new StringBuffer(str);
int index = -1;
while ((index = sb.indexOf(regex)) != -1) {
if (index != 0) {
alist.add(sb.substring(0, index));
}
sb = sb.replace(0, index + 1, "");
}
alist.add(sb.toString());
alist.remove("");
return alist.toArray();
}
26. N个Integer的向量（Vector），可以为1到N+1之间任何一个，其中里面的值互不相同，即Vector中不包含重复值。因为有N个对象，可能的值有n+1个，有一个值没有包含在内，问是哪个值没有包含在内？（用Vector.get()或 Vector.size()实现）
Vector<Integer> data = new Vector();
// 初始化data的N个元素为1~ N+1之间的值，且不从重复
boolean isIn = false;
for (int i = 1; i <= N + 1; i++) {
isIn = false;
for (int j = 0; j < data.size(); j++) {
if (data.get(j).intValue() == i) {
isIn = true;
break;
}
}
if (!isIn) {
// 当前的i为要找的
}
}
27. （编程题）给你一组数据，如（1，3，5，5，2，6，1）写一个程序要求输出其中出现次数最多数值最大的数，并输出出现几次
int a[] = new int[] { 1, 3, 5, 5, 5, 6, 1,1 };
HashMap hmap = new HashMap();
// 统计每个数字出现的次数
for (int i = 0; i < a.length; i++) {
if (hmap.get(a[i]) == null) {
hmap.put(a[i], 1);
} else {
int num = (Integer) hmap.get(a[i]);
hmap.put(a[i], ++num);
}
}
// 分别存放出现次数最多的次数，及其对应的值
int maxNum = Integer.MIN_VALUE, maxCount = Integer.MIN_VALUE;
int num; // 存放从集合中得到的key值
Set kset = hmap.keySet();
Iterator ites = kset.iterator();
while (ites.hasNext()) {
num = (Integer) ites.next();
if ((Integer) hmap.get(num) > maxCount) {
maxNum = num;
maxCount = (Integer) hmap.get(num);
} else if ((Integer) hmap.get(num) == maxCount) {
if(num >maxNum){
maxNum = num;
}
}
}
System.out.println("出现次数最多数值最大的数"+maxNum+" 出现 "+maxCount+"次");
28. （编程题）如图：（其实就是个二叉树的存储方式；给个节点，输出该节点下的所有孩子节点）
A
B C
D E F G
（1）数据结构描述上面的图形结构: 二叉树
（2）按层次打印出上面图形的结构如输入B打出 B，D，H，I，E
public class BinaryTreeChar {
private CharTreeNode root;
public BinaryTreeChar(char num) {
this.root = new CharTreeNode(num);
}
/**
* 添加节点，默认是给树根添加节点
*
* @param num
*/
public void add(char num) {
this.addTreeNode(root, num);
}
private void addTreeNode(CharTreeNode node, char num) {
if (num >= node.getNum()) {
if (node.getRight() != null) {
addTreeNode(node.getRight(), num);
} else {
node.setRight(new CharTreeNode(num));
}
} else {
if (node.getLeft() != null) {
addTreeNode(node.getLeft(), num);
} else {
node.setLeft(new CharTreeNode(num));
}
}
}
// 遍历
private void printInfo(CharTreeNode node, boolean bool, char c) {
if (node == null)
return;
if (bool || node.getNum() == c) {
bool = true;
System.out.print(node.getNum() + " "); // 根
}
printInfo(node.getLeft(), bool,c);// 左
printInfo(node.getRight(), bool,c);// 右
}
public static void main(String[] args) {
BinaryTreeChar btree = new BinaryTreeChar('E');
btree.add('D');
btree.add('G');
btree.add('H');
btree.add('I');
btree.add('B');
btree.add('A');
btree.add('C');
btree.printInfo(btree.root,false,'D');
}
}
/**
* 树节点
*
* @author admin
*/
class CharTreeNode {
private char num; // 节点值
private CharTreeNode left; // 左孩子节点
private CharTreeNode right; // 右孩子节点
public CharTreeNode(char num) {
this.num = num;
this.left = null;
this.right = null;
}
public CharTreeNode getLeft() {
return left;
}
public void setLeft(CharTreeNode left) {
this.left = left;
}
public char getNum() {
return num;
}
public void setNum(char num) {
this.num = num;
}
public CharTreeNode getRight() {
return right;
}
public void setRight(CharTreeNode right) {
this.right = right;
}
}
29. 字符集与字符编码有什么区别？
字符集（Charset）：是一个系统支持的所有抽象字符的集合。字符是各种文字和符号的总称，包括各国家文字、标点符号、图形符号、数字等。
字符编码（Character Encoding）：是一套法则，使用该法则能够对自然语言的字符的一个集合（如字母表或音节表），与其他东西的一个集合（如号码或电脉冲）进行配对。即在符号集合与数字系统之间建立对应关系，它是信息处理的一项基本技术。
30. （编程题）写一个递归函数，输入一个整数，反序输出这个整数
// 写一个递归函数，输入一个整数，反序输出这个整数
public static void printOut(int n) {
System.out.print(n % 10);
if (n >= 10){
printOut(n / 10);
}
}
31. （编程题）小明一家五口信息都放在list中，每个对象包含姓名，出生，根据爸爸姓名查爸爸生日，程序题
public class PersonClass {
private String name;
private Date birthday;
public PersonClass(String name,Date birthday){
this.name = name;
this.birthday = birthday;
}
public static void main(String[] args) {
ArrayList<PersonClass> list = new ArrayList();
list.add(new PersonClass("小明",new Date()));
list.add(new PersonClass("小明姐",new Date()));
list.add(new PersonClass("小明弟",new Date()));
list.add(new PersonClass("小明妈",new Date()));
list.add(new PersonClass("小明爸",new Date()));
for(PersonClass pc:list){
if(pc.name.equals("小明爸")){
System.out.println(pc.birthday);
}
}
}
}
32. 有什么方法能将ArrayList list转为数组 ？
答： list.toArray()
33. Tread和threadlocal的作用及区别？
答：threadlocal是 线程局部变量（thread local variable），为每一个使用该线程的线程都提供一个变量值的副本，使每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本产生冲突；
34. 写一个普通优盘的测试用例，需要考虑那些方面
功能测试：
1 在windows xp比较流行的操作系统上是否可以识别（装了驱动后是否可以）
2 在电脑上显示的盘符是否正确
3 总空间，可用空间，已用空间是否显示正确
4 u盘中是否可以拷入各种格式的各类文件（图片，视频，文档，网页...）
5 是否可以拷入拷出大文件
6 正常操作拷入的文档等是否显示乱码
7 拷文件的过程中是否可以取消
8 拷文件的过程中拔掉u盘后，u盘是否损坏
9 拷文件的过程中电脑关机后，u盘是否损坏
10 u盘的开关是否起作用
12 正常操作，拷入的文件是否会丢失
13 空间已满是否有提示信息
14 是否支持格式化
15 u盘在各个状态时是否有相应的led灯提醒
兼容性测试：
1 在windows 98,windows 2000,windows me,windows 2000 server,windows 2003 server,windows xp,windows vista...是否可以识别
2 在usb1.0,usb2.0上是否能够识别
3 在笔记本上，台式电脑，服务器上是否可以识别
性能测试：
1 一次性拷贝删除多个文件，u盘是否正常
2 u盘连续使用比较长的时间，u盘是否正常
3 u盘摔地上多次后，是否正常
界面测试：
1 设计是否美观大方
2 图案，log是否正确显示
35. （编程题）求一个字符串中第一个无重复的字符
public static void getUniqueString(String str){
boolean bool = true;
for(int i=0;i<str.length()&&bool;i++){
String s1 = str.substring(i, i+1);
if(str.indexOf(s1, i+1)==-1){
System.out.println(s1);
bool = false;
}
}
}
36. 实现对象比较的接口有哪些
答：java.lang.Comparable；
37. （编程题）给你一个文本，里面给的是url，让找出url的文件名及其相同的文件名出现的次数(程序题)
try {
Hashtable<String, Integer> ht = new Hashtable<String, Integer>();
File f = new File("e:/url.txt");
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
String url = "", urls = "";
while ((url = br.readLine()) != null)
urls += url;// 把所有字符串读进来
String[] us = urls.split("http://");// 按照http://进行分割
for (int i = 1; i < us.length; i++) {
int ind = us[i].lastIndexOf("/");// 如果文件分隔符为\，则该方法参数为\\
String filename = us[i].substring(ind + 1);
int count = 1;
if (ht.containsKey(filename))
count = ht.get(filename) + 1;
ht.put(filename, count);
}
Iterator<String> it = ht.keySet().iterator();
System.out.println("文件名\t出现次数");
while (it.hasNext()) {
String key = it.next();
int value = ht.get(key);
System.out.println(key + "\t\t" + value);
}
br.close();
fr.close();
} catch (Exception e) {
}
38. Hashcode和Equals的联系
答：首先equals()和hashcode()这两个方法都是从object类中继承过来的 其次是hashcode() 方法，在object类中定义如下：a)如果两个对象相同，那么它们的hashCode值一定要相同；b)如果两个对象的hashCode相同，它们并不一定相同 上面说的对象相同指的是用eqauls方法比较
39. （编程题）提供一个方法判断任意一个没有数字的整数数组 是否为连续数字的数组？
public boolean test(int[] is){
boolean bool=true;
for(int i=0;i<is.length-1&&bool;i++){
if(Math.abs(is[i]-is[i+1])!=1){
bool=false;
}
}
return bool;
}
Web基础部分（JSP等）（第七次考试）
1. HTTP协议中Header有那些？
答：请求头包含请求的方法、URI、协议版本、以及包含请求修饰符、客户信息和内容的类似于MIME的消息结构。例如：Cache-Control指定请求和响应遵循的缓存机制；Date头域表示消息发送的时间；Pragma头域用来包含实现特定的指令，最常用的是Pragma:no-cache。在HTTP/1.1协议中，它的含义和Cache-Control:no-cache相同。Host头域指定请求资源的Intenet主机和端口号，必须表示请求url的原始服务器或网关的位置。Referer头域允许客户端指定请求uri的源资源地址，这可以允许服务器生成回退链表，可用来登陆、优化cache等。等等；
2. Web中过滤器的原理，能否过滤图片?
答：过滤器相当于在客户端与服务器间建立多业务程序，可对request、response进行各种处理操作；只有通过的请求才会顺利进入下一个过滤器的处理，最终到达服务器； 可以对图片进行过滤；
3. Javascript出现问题是怎么调试的？（该题主要考察你的js功底，并不强调准确唯一答案）
答：我常用的方法：根据提示异常提示信息，在IE窗口，右键单击 弹出的工具栏中 选择“查看源文件”，这样基本就能知道什么地方错了，如果麻烦点的问题，就通过alert()输出阶段性的结果，比较；
另外，通过专门的调试工具也行，例如frebug,javascript debug toolkit,aptana，我尝试过aptana;
4. 写一个邮箱校验的函数，返回布尔值
function fnCheckEmail() {
var re = /^(\w ((-\w )|(\.\w ))*)\ \w ((-\w )|(\.\w ))*\@[A-Za-z0-9] ((\.|-)[A-Za-z0-9] )*\.[A-Za-z0-9] $/;
var email = document.getElementById("emailid").value;
if (email != null && email.length > 0) {
if (re.test(email)) {
return true;
}
else {
alert("Sorry，你输入的Email不合法!");
return false;
}
}
else {
alert("请输入Email!");
return false;
}
}
5. 在JavaScript中写一个方法 如：function text(a,b,c){} 然后提供给你两个参数，如（2，3），请问这样调用会不会出错？
答：可以；
6. 在JavaScript中写两个方法 如：
function text(a,b){
alert(1);
}
function text(c,d,e){
alert(2);
}
然后提供给你两个参数，如text(2,3），请问这样调用会不会出错？调用之后会出现什么情况？
答： 不会出错，调用输出的是 2；
7. Http中Staus的code，200，301，400的意思
ü 1XX这一类型的状态码，代表请求已被接受，需要继续处.
ü 2xx代表请求已成功被服务器接收、理解、并接受;
200 请求已成功，请求所希望的响应头或数据体将随此响应返回。
ü 3xx 重定向,这类状态码代表需要客户端采取进一步的操作才能完成请求。
301 被请求的资源已永久移动到新位置，并且将来任何对此资源的引用都应该使用本响应返回的若干个 URI 之一。
ü 4xx 请求错误 ,代表了客户端看起来可能发生了错误，妨碍了服务器的处理
400 语义有误，当前请求无法被服务器理解 或者 请求参数有误
404请求失败，请求所希望得到的资源未被在服务器上发现。
ü 5xx 服务器错误
500服务器遇到了一个未曾预料的状况，导致了它无法完成对请求的处理。一般来说，这个问题都会在服务器的程序码出错时出现。
8. Web系统安全因素有哪些？
答：1)操作系统、后台数据库的安全问题：这里指操作系统和后台数据库的漏洞，配置不当，如弱口令等等，导致黑客、病毒可以利用这些缺陷对网站进行攻击。
2)Web发布系统的漏洞 ：Web业务常用的发布系统(即Web服务器)，如IIS、Apache等，这些系统存在的安全漏洞，会给入侵者可乘之机。
3)Web应用程序的漏洞：主要指Web应用程序的编写人员，在编程的过程中没有考虑到安全的因素，使得黑客能够利用这些漏洞发起对网站的攻击，比如SQL注入、跨站脚本攻击等等。
4)自身网络的安全状况：网站服务器所处的网络安全状况也影响着网站的安全，比如网络中存在的DoS攻击等，也会影响到网站的正常运营。
9. 在js编码中innerHTML,outhtml,innertext区别
ü innerHTML 设置或获取位于对象起始和结束标签内的 HTML
ü outerHTML 设置或获取对象及其内容的 HTML 形式
ü innerText 设置或获取位于对象起始和结束标签内的文本
ü outerText 设置(包括标签)或获取(不包括标签)对象的文本
10. 正则表达式＼d，＼s的含义。反斜杠喔
|
代码 |
说明 |
|
. |
匹配除换行符以外的任意字符 |
|
\w |
匹配字母或数字或下划线或汉字 |
|
\s |
匹配任意的空白符 |
|
\d |
匹配数字 |
|
\b |
匹配单词的开始或结束 |
|
^ |
匹配字符串的开始 |
|
$ |
匹配字符串的结束 |
|
代码/语法 |
说明 |
|
* |
重复零次或更多次 |
|
+ |
重复一次或更多次 |
|
? |
重复零次或一次 |
|
{n} |
重复n次 |
|
{n,} |
重复n次或更多次 |
|
{n,m} |
重复n到m次 |
|
代码/语法 |
说明 |
|
\W |
匹配任意不是字母，数字，下划线，汉字的字符 |
|
\S |
匹配任意不是空白符的字符 |
|
\D |
匹配任意非数字的字符 |
|
\B |
匹配不是单词开头或结束的位置 |
|
[^x] |
匹配除了x以外的任意字符 |
|
[^aeiou] |
匹配除了aeiou这几个字母以外的任意字符 |
11. jsp页面可直接用的变量和类型有哪些？
request : HttpServletRequest
response : HttpServletResponse
session : HttpSession
application : ServletContext
out : JspWriter
pageContext : PageContext
page : Object
config : ServletConfig
exception : ServletException
12. 实现点击页面上的一个链接，然后隐藏这个链接的javascript代码
<a href="#" onclick="hiddenHref()" id="ab">隐藏连接</a>
<script language="javascript">
function hiddenHref(){
document.getElementById("ab").style.display="none";
}
</script>
13. 使用js实现输入框以下功能 1)限制输入框最多只能输入15个字符；2）将输入的‘a’都换成‘b’；
<script type="text/javascript">
function rep(){
var s=document.getElementById("test").innerText;
if(s.length>15){
alert("长度超出");
document.getElementById("test").innerText=s.substring(0,15);
}else{
document.getElementById("test").innerText=s.replace("a","b");
}
}
</script>
</head>
<body>
<textarea id="test" onkeyup="rep()"></textarea>
</body>
</html>
14. 页面间对象传递有哪些方法？
答：1）Session （2）Cookie （3）Application （4）URL地址中的参数（5）通过隐藏字段来传递数据
（6）Server.Transfer （7）通过序列化对象
15. js中找出一个字符串中出现次数最多的一个字符？
<script type="text/javascript">
var str ="dddadadfdfseffserfefsefseeffffftsdg";
var maxLength = 0;
var result = '';
while( str != '' ){
oldStr = str;
getStr = str.substr(0,1);
eval("str = str.replace(/"+getStr+"/g,'')");
if( oldStr.length-str.length > maxLength ) {
maxLength = oldStr.length-str.length;
result = getStr + "=" + maxLength
}
}
alert(result)
</script>
框架部分：
1. ApplicationContext和BeanFactory有什么区别？
BeanFactory实际上是实例化，配置和管理众多bean的容器。 这些bean通常会彼此合作，因而它们之间会产生依赖。 BeanFactory使用的配置数据可以反映这些依赖关系中 （一些依赖可能不像配置数据一样可见，而是在运行期作为bean之间程序交互的函数）。
一个BeanFactory可以用接口org.springframework.beans.factory.BeanFactory表示， 这个接口有多个实现。 最常使用的的简单的eanFactory实现是org.springframework.beans.factory.xml.XmlBeanFactory。 （这里提醒一下：ApplicationContext是BeanFactory的子类， 所以大多数的用户更喜欢使用ApplicationContext的XML形式）。
ApplicationContext
beans包提供了以编程的方式管理和操控bean的基本功能，而context包增加了ApplicationContext，它以一种更加面向框架的方式增强了BeanFactory的功能。多数用户可以以一种完全的声明式方式来使用ApplicationContext，甚至不用去手工创建它，但是却去依赖像ContextLoader的支持类，在J2EE的Web应用的启动进程中用它启动ApplicationContext。当然，这种情况下还可以以编程的方式创建一个ApplicationContext。
Context包的基础是位于org.springframework.context包中的ApplicationContext接口。它是由BeanFactory接口集成而来，提供BeanFactory所有的功能。为了以一种更像面向框架的方式工作，context包使用分层和有继承关系的上下文类，包括：
1．MessageSource，提供对i18n消息的访问；
2．资源访问，比如URL和文件；
3．事件传递给实现了ApplicationListener接口的bean；
4．载入多个（有继承关系）上下文类，使得每一个上下文类都专注于一个特定的层次，比如应用的Web层
在ApplicationContext的诸多实现中，有三个经常用到：
1。ClassPathXmlApplicationContext:从类路径中的XML文件载入上下文定义信息，把上下文定义文件当作类路径资源。
2。FileSystemXmlApplicationContext:从文件系统中的XML文件载入上下文定义信息。
3。XmlWebApplicationContext：从Web系统中的XMl文件载入上下文信息。
2. struts2.0的session 和 servlet的session 有什么区别
servlet中的session:因为在doget或dopost方法会传递HttpServletRequest,可以直接通过request.getSession()得到sesion
Strutx 2.0你可以有两种方式获得这些对象：非IoC（控制反转Inversion of Control）方式和IoC方式。
非IoC方式
要获得上述对象，关键Struts 2.0中com.opensymphony.xwork2.ActionContext类。我们可以通过它的静态方法getContext()获取当前Action的上下文对象。 另外，org.apache.struts2.ServletActionContext作为辅助类（Helper Class），可以帮助您快捷地获得这几个对象。
HttpServletRequest request = ServletActionContext.getRequest();
HttpServletResponse response = ServletActionContext.getResponse();
HttpSession session = request.getSession();
如果你只是想访问session的属性（Attribute），你也可以通过ActionContext.getContext().getSession()获取或添加session范围（Scoped）的对象。
IoC方式
要使用IoC方式，我们首先要告诉IoC容器（Container）想取得某个对象的意愿，通过实现相应的接口做到这点
如implements SessionAware接口
3. Struts中的action是安全线程么？为什么
Servlet是在多线程环境下的。即可能有多个请求发给一个servelt实例，每个请求是一个线程。
struts下的action也类似，同样在多线程环境下。
为多线程环境编写代码。我们的controller servlet指挥创建你的Action 类的一个实例，用此实例来服务所有的请求。因此，你必须编写线程安全的Action类。遵循与写线程安全的servlet同样的方针。
4. EJB 是否继承home接口，怎么实现
Home对象是该类EJB对象的”工厂”或”代理”，管理EJB实例的生命周期，封装关于EJB的元信息，是所有EJB的客户间共享的，在部署或容器启动时，将其stub绑在JNDI中，必须继承EJBHome，方法必须符合RMI规则，必须提供没有参数的create()方法,返回Remote接口类型，必须抛出CreateException和RemoteException。
5. 应用服务器与Web server的区别
Web服务器(Web Server)
Web服务器可以解析(handles)HTTP协议。当Web服务器接收到一个HTTP请求，会返回一个HTTP响应，例如送回一个HTML页面。为了处理一个请求，Web服务器可以响应一个静态页面或图片， 进行页面跳转，或者把动态响应的产生委托给一些其它的程序例如CGI脚本，JSP脚本，servlets，ASP脚本，服务器端JavaScript，或者一些其它的服务器端技术。无论它们(译者 注:脚本)的目的如何，这些服务器端的程序通常产生一个HTML的响应来让浏览器可以浏览。
应用程序服务器
通过各种协议，可以包括HTTP，把商业逻辑暴露给客户端应用程序。Web服务器主要 是处理向浏览器发送HTML以供浏览，而应用程序服务器提供访问商业逻辑的途径以供客户端应用程序使用。应用程序使用此商业逻辑就象你调用对象的一个方法 (或过程语言中的一个函数)一样。
应用程序服务器的客户端(包含有图形用户界面(GUI)的)可能会运行在一台PC、一个Web服务器或者甚至是其它的应用程序服务器上。在应用 程序服务器与其客户端之间来回穿梭的信息不仅仅局限于简单的显示标记。相反，这种信息就是程序逻辑。 正是由于这种逻辑取得了数据和方法调用的形式而不是静态HTML，所以客户端才可以随心所欲的使用这种被暴露的商业逻辑。
在大多数情形下，应用程序服务器是通过组件的应用程序接口把商业逻辑暴露 (给客户端应用程序)的，例如基于J2EE应用程序服务器的EJB组件模型。此外，应用程序服务器可以管理自己的资源，例如看大门的工作包括安全，事务处理，资源池， 和消息。就象Web服务器一样，应用程序服务器配置了多种可扩展和容错技术。
6. 如何设置Hibernate二级缓存
1、首先要打开二级缓存，在hibernate.cfg.xml中添加如下配置：
<property name="hibernate.cache.use_second_level_cache">true</property>
2、Hibernate的二级缓存使用第三方的缓存工具来实现，所以我们需要指定Hibernate使用哪个
缓存工具。如下配置指定Hibernate使用EhCache缓存工具。
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
3、Hibernate在默认情况下并不会对所有实体对象进行缓存，所以，我们需要指定缓存哪些对象，
在实体对象的映射文件中（相应的<class>标签内部），添加如下配置：
<cache usage="read-only"/>
usage="read-only"是“只读”缓存策略。
注意，这个<cache>标签只能放在<class>标签的内部，而且必须处在<id>标签的前面！！！
这个<cache>标签放在哪些<class>标签下面，就说明会多这些类的对象进行缓存
4、对于第3步，有一个可选的方案是在hibernate.cfg.xml文件中指定哪些类的对象需要缓存，
而不需要使用<cache>标签来指定。如：
在hibernate.cfg.xml中添加如下配置：
<class-cache class="com.bjsxt.hibernate.Classes" usage="read-only" />
注意，这个<class-cache>标签必须放在<mapping>标签的后面！！
7. 什么是事物处理，J2EE提供哪两种事物处理方式
事务（Transaction）是数据库管理系统提供的基本功能之一，可以把完成用户一个特定工作的一组操作看作是一个不可拆分的工作单元，所以事务也就是作业或任务。
JDBC支持单一数据库连接.
JTA支持分布式事务.
8. J2EE是技术、平台、框架？包括哪些技术
J2EE本身是一个标准,一个为企业分布式应用的开发提供的标准平台.
J2EE也是一个框架,包括JDBC、JNDI、RMI、JMS、EJB、JTA等技术.
9. EJB规范中规定EJB中禁止的操作有那些
1.不能操作线程和线程 API(线程 API指非线程对象的方法如 notify,wait等)
2.不能操作awt
3.不能实现服务器功能
4.不能对静态属生存取
5.不能使用IO 操作直接存取文件系统
6.不能加载本地库
7.不能将this 作为变量和返回
8.不能循环调用
10. webservice和remoting区别
1、Remoting可以灵活的定义其所基于的协议，如果定义为HTTP，则与Web Service就没有什么区别了，一般都喜欢定义为TCP，这样比Web Service稍为高效一些
2、Remoting不是标准，而Web Service是标准；
3、Remoting一般需要通过一个WinForm或是Windows服务进行启动，而Web Service则需要IIS进行启动。
4、在VS.net开发环境中，专门对Web Service的调用进行了封装，用起来比Remoting方便
建议还是采用Web Service好些，对于开发来说更容易控制
Remoting一般用在C/S的系统中，Web Service是用在B/S系统中
11. Hiberbate优化方法有那些？
1) 尽量使用many-to-one，避免使用单项one-to-many
2) 灵活使用单向one-to-many
3) 不用一对一，使用多对一代替一对一
4) 配置对象缓存，不使用集合缓存
5) .一对多使用Bag 多对一使用Set
6) 继承使用显示多态 HQL:from object polymorphism="exlicit" 避免查处所有对象
7) 消除大表，使用二级缓存
12. Struts1.X 中ActionServlet、 ActionForm 、Action、 ActionMapping各起什么作用？
1) Actionservlet为控制器，接受用户请求并派发给相应的Action组件处理；
2) ActionForm主要用于封装请求中的数据和简单验证
3) Action组件具体对用户的请求进行处理
4) ActionMapping封装当前用户请求Action相关的配置信息
数据库部分：
1. 数据库系统是由哪几个部分组成的
数据库系统由数据库(DB),数据管理系统(DBMS),应用程序,用户和硬件组成,其中最关键的部分是数据库.
2. 什么是操作系统
操作系统（Operating System，简称OS）是一管理电脑硬件与软件资源的程序，同时也是计算机系统的内核与基石。操作系统是一个庞大的管理控制程序，大致包括5个方面的管理功能:进程与处理机管理、作业管理、存储管理、设备管理、文件管理。目前微机上常见的操作系统有DOS、OS/2、UNIX、XENIX、LINUX、Windows、Netware等
3. 解释乐观锁悲观锁及实现
乐观锁与悲观锁是对于并发性的限制。锁是具有排他性的。悲观锁，是悲观的认为自己在读取数据的时候别人也在对数据进行读写，所以在自己读写数据的时候对数据进行锁定，直到自己操作完毕。乐观锁正好是相反的，是乐观的认为在自己对数据进行读写的时候不会有其他人对数据进行读写，所以不进行数据库机制的限制，而是进行，版本的限制，而且乐观锁不光光只有版本限制，还有更新时间限制，与字段对比限制。用悲观锁机制制作的软件代表作品是VSS，用乐观锁机制制作的软件代表作品是CVS。
下面我们看看怎么调用悲观锁，我只写一个代码片段，其他地方没有大的改变，如果大家想尝试下结果的话，可以自己写下看看， session.load(User.class,1,LockMode.UPGRADE);通过这句话调用锁机制，如果其他人想要用的话呢，就要一直等到 Transaction commit以后才可以。
乐观锁，乐观锁其实并不是一种锁，而是一种冲突检测机制，他可以随时改变数据，但是在save和update的时候会进行检测，检测版本是否符合标准，如果版本小于等于新版本就不会对数据进行改动，相反还会报错，说是一个脏数据，说明数据有问题，这样也会造成更新丢失。
我们要怎么调用乐观锁呢，相对于悲观锁，乐观锁的调用还是比较麻烦的，我们需要在数据库中加入version，也需要在持久类中加入verison，这个version不用我们进行管理是由hibernate进行管理的。还要在*.hbm.xml中的class标签中配置上
optimistic-lock="verson"这里说明的是这个version不是字段，而是你乐观锁采用哪种机制，这里写成version意思就是采用版本判断这个机制，然后还要在主键id下面配置<version name=" "/>这个name后面跟的就是数据库中的字段名。
4. ORACKE创建表空间student
create tablespace student
logging
datafile 'E:\oracle\product\10.2.0\oradata\testserver\ student.dbf'
size 32m
autoextend on
next 32m maxsize 2048m
extent management local;
5. 在mysql中创建一个临时表 并说明临时表的使用限制
CREATE TEMPORARY TABLE tmp_table
ALTER DATABASE TEMPFILE ' tmp_table ' AUTOEXTEND ON MAXSIZE 8000M
6. Mysql支持事务吗
在缺省模式下，MYSQL是autocommit模式的，所有的数据库更新操作都会即时提交，所以在缺省情况下，mysql是不支持事务的。
7. 一张表有多个相同的id，查询出ID相同的，并显示出有多少个相同的？
Select eid,count(*) from employee group by eid having count(eid)>1
8. 一张学生表student，有字段班级classid，学号id，成绩grade
（1）求各个班的平均成绩
Select classid,avg(grade) from student group by classid
（2）查询出比该班平均成绩高的学生的所有信息
select w.id,w. grade,b.avg_ grade from student w,(
select classid,avg(grade) avg_grade from student group by classid) b
where w. classid =b. classid and w.grade >b.avg_grade;
9. 改错 select c1,c2,c3 from T1 group by c1,c2 having c1>1
C3不在group by 子句中
10. ORACLE数据库中系统全局区的简称是： 程序全局区是:
系统全局区的简称是：SGA 程序全局区是:PGA
11. 去年的今日是哪一天？SQL语句
select add_months(sysdate,-) from dual
12. 中国人事部想开发一个系统，纪录所有国民跳槽纪录，以及对企业信息，国民信息进行管理，中国人事部拥有的资源有:中国所有企业信息，中国国国民信息，根据以上信息，进行数据库设计
企业信息:eid,name…
国民信息:rid,name…
工作记录：id,eid,rid,startDate,endDate…
13. 在网络数据库中，其余各节点为终端向A发数据库请求属于什么式的数据库系统
集中式数据库系统：在这种系统中，整个DBMS的核心，数据库和应用程序都放在主机上，用户通过终端来并发地存取数据，共享数据资源，这种系统又称为主从式或主机／终端式系统。
14. 一个用户具有多个角色请查该表具有该用户的所有角色的其他用户
select distinct eid
from user_role scx
where not exists
(select *from user_role scy
where scy.eid='a00001' and
not exists
(select * from user_role scz
where scz.eid=scx.eid
and scz.rid=scy.rid));
15. 什么是oracle 的CBO？什么是RBO？什么情况下oracle 使用CBO
Rule Based Optimizer（RBO）基于规则
Cost Based Optimizer（CBO）基于成本，或者讲统计信息
ORACLE 提供了CBO、RBO两种SQL优化器。CBO在ORACLE7 引入，但在ORACLE8i 中才成熟。ORACLE 已经明确声明在ORACLE9i之后的版本中(ORACLE 10G )，RBO将不再支持。因此选择CBO 是必然的趋势。
CBO和 RBO作为不同的SQL优化器，对SQL语句的执行计划产生重大影响，如果要对现有的应用程序从RBO向CBO移植，则必须充分考虑这些影响，避免SQL 语句性能急剧下降；但是，对新的应用系统，则可以考虑直接使用CBO，在CBO模式下进行SQL语句编写、分析执行计划、性能测试等工作，这需要开发者对 CBO的特性比较熟悉。
16. 用SQL查出表中主键以及表之间的关系
select cu.* from user_cons_columns cu, user_constraints au where cu.constraint_name = au.constraint_name and au.constraint_type = 'P' and au.table_name ='EMP'
17. 获取某日期的当月最后一天
select last_day(sysdate) from dual;
18. 当数据库中数据存储数据很多时，应该怎样优化？
1、把数据、日志、索引放到不同的I/O设备上，增加读取速度，以前可以将Tempdb应放在RAID0上，SQL2000不在支持。数据量（尺寸）越大，提高I/O越重要.
2、纵向、横向分割表，减少表的尺寸(sp_spaceuse)
3、升级硬件
4、根据查询条件,建立索引,优化索引、优化访问方式，限制结果集的数据量。注意填充因子要适当（最好是使用默认值0）。索引应该尽量小，使用字节数小的列建索引好（参照索引的创建）,不要对有限的几个值的字段建单一索引如性别字段
5、提高网速;
19. 用一个SQL语句清楚XX子段的重复记录，保留主建最小的一条
delete from people where xx in (select xx from people group by xx having count(xx) > 1)
and id not in (select min(id) from people group by xx
20. How to avoid sql injection？ 翻译就是 如何避免SQL注入？
1， 使用参数化的过滤性语句 要防御SQL注入，用户的输入就绝对不能直接被嵌入到SQL语句中。相反，用户的输入必须进行过滤，或者使用参数化的语句
2， 还要避免使用解释程序，因为这正是黑客们借以执行非法命令的手段。
3， 防范SQL注入，还要避免出现一些详细的错误消息，因为黑客们可以利用这些消息。要使用一种标准的输入确认机制来验证所有的输入数据的长度、类型、语句、企业规则等
4， 还有很重要的一点 应该在Web应用程序开发过程的所有阶段实施代码的安全检查。首先，要在部署Web应用之前实施安全测试，还应当在部署之后用漏洞扫描工具和站点监视工具对网站进行测试
21. 项目中 出入库单据超过100万条,系统在单据调出,保存过程中速度较慢,原因有哪些？怎么提高速度？
答：慢有很多情况，
情况1：远程查询，其实可能查询不慢，由于数据量大，传输过程慢
情况2：WHERE 后面的比较数据太多，比如 like 类的语句
情况3：需要哪个字段只取那个字段就行了，比如select * from a与select b,c,d from a速度是有差距的
提高速度方案：数据库定期维护，压缩，把不常用的数据备份后放入备份库里，查询时查备份库等；索引约束过多会引起插入数据过慢、索引与检索无法起到作用；SQL优化很重要；存储的服务器性能也很重要，100万的数据量已经可以考虑分区存储数据了；（第七次考试）
操作系统、项目管理、前沿技术、软件测试、智力题
1. Ajax、jms、pojo名词的理解
Ajax：异步JavaScript和XML，是一种用于创建更好更快以及交互性更强的 Web 应用程序的技术。
Jms：（java message service）JAVA消息服务。是一个Java平台中关于面向消息中间件（MOM）的API。
主要实现各个应用程序之间的通讯。包括点对点和广播
Pojo：简单的Java对象，实际就是普通JavaBeans。POJO有一些private的参数作为对象的属性。然后针对每个参数定义了get和set方法作为访问的接口
2. 列举五个现在时髦的技术，并说明理由
struts struts2 ibatis hibernate spring ejb jquery extjs
3. 如果你同事犯了很大的错，但是在会议上，你的领导没有批评你的同事，却批评了你，你该怎么办？
开会的时候即使有再大的委屈也不能争吵或者在会上解释，因为这样往往会适得其反，可以事后找领导解释，这样既保证了领导的权威，并在他冷静后再解释也能达到我们想要的结果。
4. 刚才的办公室里有哪几中电器设备？考察学生对身边事务的观察力；
5. 医生交给你6个药丸，让你每隔半小时吃一次，多久才能吃完？
一次吃一颗：两个半小时吃完
一次吃两颗：一个小时吃完
一次吃三颗：30分钟吃完
一次吃6颗：几秒钟
6. 小明参加400米赛跑，他超过了第二名，那么他现在是第几名？
第二名
7. 如果你的项目程序运行很慢你估计是那点的问题
系统优化涉及到软件的各个方面：需求、模块划分、数据库设计、程序编码以及一些特殊的优化方法如缓存技术等。 在系统开发告一段落情况下，提高已有系统的性能，减少如内存、数据库、网络带宽等资源的占用。
硬件方面：CPU和风扇是否正常运转并足够制冷，是否有足够的内存和磁盘空间等
8. Linux在目录user下新建文件夹T和t1，在t1下新建T2
ü 强力删除t1目录及其下所有
ü 拷贝文件A.txt到/root/t2路径下
ü 修改/etc/profile文件后，除重启计算机外，如何即时生效？
ü 用命令的方法导出D:\mysql，Bin路径D:\mysql\bin
9. XP中IIS中是否可以同时安装2个wed?为什么？如何操作？
答：可以；
ü 建立第一个Web站点
比如本机的IP地址为192.168.0.1，自己的网页放在D:\Wy目录下，网页的首页文件名为Index.htm，现在想根据这些建立好自己的Web服务器。
对于此Web站点，我们可以用现有的“默认Web站点”来做相应的修改后，就可以轻松实现。请先在“默认Web站点”上单击右键，选“属性”，以进入名为“默认Web站点属性”设置界面。
1）．修改绑定的IP地址：转到“Web站点”窗口，再在“IP地址”后的下拉菜单中选择所需用到的本机IP地址“192.168.0.1”。
2）．修改主目录：转到“主目录”窗口，再在“本地路径”输入（或用“浏览”按钮选择）好自己网页所在的“D:\Wy”目录。
3）．添加首页文件名：转到“文档”窗口，再按“添加”按钮，根据提示在“默认文档名”后输入自己网页的首页文件名“Index.htm”。
4）．添加虚拟目录：比如你的主目录在“D:\Wy”下，而你想输入“192.168.0.1/test”的格式就可调出“E:\All”中的网页文件，这里面的“test”就是虚拟目录。请在“默认Web站点”上单击右键，选“新建→虚拟目录”，依次在“别名”处输入“test”，在“目录”处输入“E:\All”后再按提示操作即可添加成功。
5）．效果的测试：打开IE浏览器，在地址栏输入“192.168.0.1”之后再按回车键，此时就能够调出你自己网页的首页，则说明设置成功！
注：具体不同的电脑会有不同的选项名称，但大体上还是可以找到了（多试一下）。
ü 添加更多的Web站点
1）．多个IP对应多个Web站点
如果本机已绑定了多个IP地址，想利用不同的IP地址得出不同的Web页面，则只需在“默认Web站点”处单击右键，选“新建→站点”，然后根据提示在“说明”处输入任意用于说明它的内容（比如为“我的第二个Web站点”）、在“输入Web站点使用的IP地址”的下拉菜单处选中需给它绑定的IP地址即可；当建立好此Web站点之后，再按上步的方法进行相应设置。
2）．一个IP地址对应多个Web站点
当按上步的方法建立好所有的Web站点后，对于做虚拟主机，可以通过给各Web站点设不同的端口号来实现，比如给一个Web站点设为80，一个设为81，一个设为82……，则对于端口号是80的Web站点，访问格式仍然直接是IP地址就可以了，而对于绑定其他端口号的Web站点，访问时必须在IP地址后面加上相应的端口号，也即使用如 “http://192.168.0.1:81” 的格式。
很显然，改了端口号之后使用起来就麻烦些。如果你已在DNS服务器中将所有你需要的域名都已经映射到了此惟一的IP地址，则用设不同“主机头名”的方法，可以让你直接用域名来完成对不同Web站点的访问。
比如你本机只有一个IP地址为192.168.0.1，你已经建立（或设置）好了两个Web站点，一个是“默认Web站点”，一个是“我的第二个Web站点”，现在你想输入“www.enanshan.com”可直接访问前者，输入“www.popunet.com”可直接访问后者。其操作步骤如下：
（1）请确保已先在DNS服务器中将你这两个域名都已映射到了那个IP地址上；并确保所有的Web站点的端口号均保持为80这个默认值。
（2）再依次选“默认Web站点→右键→属性→Web站点”，单击“IP地址”右侧的“高级”按钮，在“此站点有多个标识下”双击已有的那个IP地址（或单击选中它后再按“编辑”按钮），然后在“主机头名”下输入“www.enanshan.com”再按“确定” 按钮保存退出。
（3）接着按上步同样的方法为“我的第二个Web站点”设好新的主机头名为“www.popunet.com”即可。
（4）最后，打开你的IE浏览器，在地址栏输入不同的网址，就可以调出不同Web站点的内容了。
ü 多个域名对应同个Web站点
你只需先将某个IP地址绑定到Web站点上，再在DNS服务器中，将所需域名全部映射向你的这个IP地址上，则你在浏览器中输入任何一个域名，都会直接得到所设置好的那个网站的内容。
10. excel中不需要显示单元格数值为0的数值时？如何操作
工具→选项→视图→选项卡里面下方有一个“零值”，前面的勾取消即可
11. excel是否可以隐藏网格线？
可以，工具→选项→视图→选项卡里面下方有一个“网格线”，前面的勾取消即可
12. 会计科目按性质分哪几类？
答：资产、负债、所有者权益、收入、费用。
13. 一份好的缺陷报告要那些关键要素？
1. 缺陷概要
2. 简单的缺陷描述
3. 产生缺陷的先决条件及重现步骤
4. 预期结果和实际结果，必要的截图
5. 严重性及优先级
6. 标记该缺陷出现的频率
14. 一个优秀的测试要那些素质
测试的目标是找出软件缺陷，软件测试员得基本素质是：打破砂锅问到底
测试员应具备的素质：
1. 探索精神：不会害怕进入陌生的环境
2. 故障排除能手：善于发现问题的症结
3. 不懈努力：不停的尝试。他们可能会碰到转瞬即逝或者难以重建的软件缺陷，不会心存侥幸，而是尽一切可能去寻找
4. 创造性：测试显而易见的事实那不是软件测试员，他们的工作是想出富有创意甚至超常的手段来寻找软件缺陷
5. 追求完美：力求完美，但是知道某些无法企及时不去苛求，而是尽力接近目标
6. 判断准确：软件测试员要决定测试内容、测试时间，以及看到的问题是否算真正的缺陷
7. 说服力：善于表达观点，表明软件缺陷为何必须修复，并通过实际演示力陈观点
8. 在编程方面受过教育
15. C语言：函数打开，关闭，随机读写问件
FILE *fp;/*定义文件类型的指针,它将指向你所要打开的文件,以后向文件写入数据或者是从文件中读取数据都需要用到他*/
Include “stdio.h”
Fp=fopen() //打开文件
fclose(fp) //关闭文件
fseek(FILE *stream, long offset, int fromwhere);
16. 黑盒，白盒测试是什么？区别？
黑盒：也称功能测试或数据驱动测试。把被测试对象看成一个黑盒子，测试人员完全不考虑程序内部结构和处理过程。只在软件的接口处进行测试，根据需求规格说明书检查程序是否满足功能要求。黑盒测试有以下几个方面，但主要还是功能部分测试。
1. 正确性：计算结果，命名等
2. 可用性：是否满足软件的需求说明
3. 边界值
4. 性能：正常使用时系统完成一个任务需要的时间是否在可以接受的范围内
5. 压力测试：多用户情况考虑使用
6. 错误恢复：错误处理，页面数据验证等
白盒：也称结构测试或逻辑驱动测试。把测试对象看作一个打开的盒子，测试人员须了解程序的内部结构和处理过程，以检查处理过程的细节为基础，对程序中尽可能多的逻辑路径进行测试，检查内部控制结构和数据结构是否有错，实际的运行状态和预期的状态是否一致。白盒测试主要特征是测试对象进入了代码内部，根据开发人员自己对代码的理解和接触所进行的软件测试，这一阶段测试以软件开发人员为主。
17. 3G的了解和看法
3G是一个比较热的话题，WCDMA,TDSCDMA,CDMA2000三种标准开启了三国争霸的序幕，对于电信行业的发展这是好事，毕竟竞争有利于消费者，但3G业务还是偏高。
3G是第三代移动通信技术的简称，是指支持高速数据传输的蜂窝移动通讯技术，3G服务能同时传送声音及数据信息。其代表特征是提供高速数据业务。3G是将无线通与国际互联网等多媒体通信结合的新一代移动通信系统。3代表3G时代下的移动+宽带+固网+手机+……融合。
18. 12个球，其中一个重量不一样，称三次，找出不一样的那个
12颗球分3组。
第一次使用天平：任意将两组至于天平上每边4颗，有两种情况：
A：如果天平任保持平衡，那么那一颗就在其余4颗里。
第二次，在其余4颗里任选两颗，放在天平上，即可排除掉两颗。
B：如果不平衡，则任意在天平一侧的盘子里拿两颗和其余4颗中的两颗互换。此为第二次使用天平。
如天平平衡，那么你拿走的那两颗就有一颗是要找的。如天平不平衡，那么放进去的那两颗就有一颗是
第三次，将其中一颗与已知的一颗标准球称，即可知道结果。
19. 美国有多少辆汽车？
答：（分析）这道试题并不难，我想它可能只是想考察一下应聘者的应变能力，即在短时间内快速应对不规范问题的能力。我当时的回答是：美国有多少人？这些人里又有多少人会开车？而会开车的人里又有多少有这样的经济能力可以购买汽车？可以购买汽车的人里是不是都已经买了？这些问题解决了，那答案自然就知道了。
企业回复：很明显，这是一道答案开放的试题。它是为了考察应聘者能否对一个问题进行符合逻辑的创造性思考，并迅速通过这种思考寻求到解决问题的办法。至于答案，我们显然并不关心。这道题的指向性很明显，应聘者是否能在很短的时间里对出其不意的问题做出反应，并能够合乎逻辑地回答这样的问题，我们同样希望能够得到出其不意的答案。有不少人通过在网上搜集这种试题来准备答案，显然违背了企业的本意，大家要记住：重复的答案都不是好答案。
同类型题目:
世界上一共有多少个钢琴调音师？ 调音师的人数取决于有多少钢琴需要调音。调音师的工作量由钢琴的数量和调音的频度决定。美国共有3亿人口，按三口之家计算，全美国共有1亿个家庭，如果一半家庭即5000万个家庭属于富裕阶层，拥有钢琴比例按10％这个比例可能有点偏高，但在推算大致比例时是允许的计算，那么就有500万个家庭拥有钢琴，这样，全美国就有500万架钢琴。如果每架钢琴一年调音一次，一个调音师一年调音1000架次的话，那么全美国调音师的数量就是500万除以1000，等于5000人。世界人口有60多亿，是美国的20倍，但调音师应该不足美国的20倍。大体推算一下可知，美国的调音师数量约占全世界的1／4，全世界的调音师应该有2万人。
深圳华为公司 笔试题
1. 单项选择题
1．Java是从（ ）语言改进重新设计。
A．Ada B．C++ C．Pasacal D．BASIC
答案：B
2．下列语句哪一个正确（ ）
A． Java程序经编译后会产生machine code
B． Java程序经编译后会产生byte code
C． Java程序经编译后会产生DLL
D． 以上都不正确
答案：B
3．下列说法正确的有（ ）
A． class中的constructor不可省略
B． constructor必须与class同名，但方法不能与class同名
C． constructor在一个对象被new时执行
D． 一个class只能定义一个constructor
答案：C
4．提供Java存取数据库能力的包是（ ）
A．java.sql B．java.awt C．java.lang D．java.swing
答案：A
5．下列运算符合法的是（ ）
A．&& B．<> C．if D．:=
答案：A
6．执行如下程序代码
a=0;c=0;
do{
--c;
a=a-1;
}while(a>0); 后，C的值是（ ）
A．0 B．1 C．-1 D．死循环
答案：C
7．下列哪一种叙述是正确的（ ）
A． abstract修饰符可修饰字段、方法和类
B． 抽象方法的body部分必须用一对大括号{ }包住
C． 声明抽象方法，大括号可有可无
D． 声明抽象方法不可写出大括号
答案：D
8．下列语句正确的是（ ）
A． 形式参数可被视为local variable
B． 形式参数可被字段修饰符修饰
C． 形式参数为方法被调用时，真正被传递的参数
D． 形式参数不可以是对象
答案：A
9．下列哪种说法是正确的（ ）
A． 实例方法可直接调用超类的实例方法
B． 实例方法可直接调用超类的类方法
C． 实例方法可直接调用其他类的实例方法
D． 实例方法可直接调用本类的类方法
答案：D
二、 多项选择题
1．Java程序的种类有（ ）
A．类（Class） B．Applet C．Application D．Servlet
答案：BC
2．下列说法正确的有（ ）
A． 环境变量可在编译source code时指定
B． 在编译程序时，所能指定的环境变量不包括class path
C． javac一次可同时编译数个Java源文件
D． javac.exe能指定编译结果要置于哪个目录（directory）
答案：BCD
3．下列标识符不合法的有（ ）
A．new B．$Usdollars C．1234 D．car.taxi
答案：ACD
4．下列说法错误的有（ ）
A． 数组是一种对象
B． 数组属于一种原生类
C． int number=[]={31,23,33,43,35,63}
D． 数组的大小可以任意改变
答案：BCD
5．不能用来修饰interface的有（ ）
A．private B．public C．protected D．static
答案：ACD
6．下列正确的有（ ）
A． call by value不会改变实际参数的数值
B． call by reference能改变实际参数的参考地址
C． call by reference不能改变实际参数的参考地址
D． call by reference能改变实际参数的内容
答案：ACD
7．下列说法错误的有（ ）
A． 在类方法中可用this来调用本类的类方法
B． 在类方法中调用本类的类方法时可直接调用
C． 在类方法中只能调用本类中的类方法
D． 在类方法中绝对不能调用实例方法
答案：ACD
8．下列说法错误的有（ ）
A． Java面向对象语言容许单独的过程与函数存在
B． Java面向对象语言容许单独的方法存在
C． Java语言中的方法属于类中的成员（member）
D． Java语言中的方法必定隶属于某一类（对象），调用方法与过程或函数相同
答案：ABC
9．下列说法错误的有（ ）
A． 能被java.exe成功运行的java class文件必须有main()方法
B． J2SDK就是Java API
C． Appletviewer.exe可利用jar选项运行.jar文件
D． 能被Appletviewer成功运行的java class文件必须有main()方法
答案：BCD
三、 判断题
1．Java程序中的起始类名称必须与存放该类的文件名相同。（ ） 正确
2．Unicode是用16位来表示一个字的。（ ）正确
3．原生类中的数据类型均可任意转换。（ ） 错误
1、给定如下JAVA 程序片断:
class A{
public A(){
system.out.println(“A”);
}
}
class B extends A{
public B(){
System.out.println(“B”);
}
public static void main(String[] args){
B b=new B();
}
} 上述程序将( ).(选择一项)
A、 不能通过编译
B、通过编译,输出为: A B
C、通过编译,输出为: B
D、通过编译,输出为: A
2、某一 java程序中有如下代码：
Datalnputstream din=new DataInputstream（
new BufferedInputstream (new FileInputstream(“employee.dat”) ));
假设在employee.dat文件中只有如下一段字符：abcdefg。则：System.out.println(din)在屏幕上打印（）．（选择一项）
A、A
B、B
C、97
D、98
3、给定java代码片段，如下：
int i=0,j=-1;
switch(i){
case 0,1:j=1;
case 2:j=2;
}
System.out.print("j="+j); 编译运行，正确的是（）。（选择一项）
A、程序编译出错
B、j=1
C、j=2
D、j=0
4、在Java中，下面关于构造函数的描述正确的是（）。（选择一项）
A、类必须有显式构造函数
B、它的返回类型是void
C、它和类有相同的名称，但它不能带任何参数
D、以上皆非
5、 在JAVA编程中，Swing包中的组件处理事件时，下面（）是正确的。（选择一项）
A、 Swing包中的组件也是采用事件的授权得理模型来处理事件的
B、 Swing包中组件产生的事件类型，也都带有一个Ｊ字母，如：JmouseEvent
C、Swing包中的组件也可以采用事件的传递处理机制
D、 Swing包的组件所对应的事件适配器也是带有Ｊ字母的，如：JmouseAdapter
6、public class EqTest {
public static void main(String args[]){
EqTest e=new EqTest();
}
EqTest(){
String s="Java"; String s2="java";
//在这儿放置测试代码
{
System.out.println("相等");
}else {
System.out.println("不相等");
}
}
} 在上面的Java代码的注释行位置，放置（）测试代码能输出“相等”结果。（选择一项）
A、if(s==s2)
B、if(s.equals(s2))
C、if(s.equalsIgnoreCase(s2))
D、if(s.noCaseMatch(s2))
7、 在类的说明符中，被指定为私有的数据可以被以下（）访问。（选择一项）
A、程序中的任何函数
B、其他类的成员函数
C、类中的成员函数
D、派生类中的成员函数
8、 在JAVA编程中，以下（）命令用来执行java类文件。（选择一项）
A、javac
B、java
C、appletviewer
D、以上所有选项都不正确
9、Java中，下面的方法可以正确的创建一个Swing标签组件是（）（选择两项）
A、ImageIcon icon = new ImageIcon(
B、ImageIcon icon = new ImageIcon(
C、ImageIcon icon=new ImageIcon(
D、JLabel label=new JLabel(SwingConstants.LEFT);
10、分析下面的用Java语言编写的trythis()方法：
public void trythis(){
try{
System.out.print("a");
problem();
}catch(RuntimeException e){
System.out.print("b");
}catch(Exception e){
System.out.print("c");
}finally{
System.out.print("d");
}
System.out.print("e");
} 当该方法被调用时，如果其中的problem()方法引发一个RuntimeException类的异常，那么输出结果将是（）。（选择一项）
A、abcde
B、abd
C、abde
D、abe
11、 public class MyClass1{
public static void main (String argv[]){
}
_____ class MyInner { }
} 在以上java代码中的横线上，可放置（）修饰符。（选择三项）
A、public
B、private
C、static
D、friend
12、public class test3{
public static void main(String args[]){
for(int i=0;i<3;i++){
for(int j=3; j>0;j--){
if(i==j)
continue;
System.out.println(“i=”+i+”j=”+j)
}
}
}
} 上面的JAVA代码编译运行后，下列选项中，（）会出现在输出结果中，（选择三项）
A、i=0 j=3
B、i=0 j=0
C、i=2 j=2
D、i=0 j=2
E、i=1 j=2
13、如下Java代码段，体现了（）概念。（选择一项）
.........
public void aMethod(String s){ .........}
public void aMethod(int i){.........}
public void aMethod(int I,float f){ .........}
.........
A、多继承
B、重载
C、重写
D、多态
14、java语言中，下列时处理输出操作的所有类的基础的是（）（选择一个）
A、DataOutput
B、OutputStream
C、BufferedOutputStream
D、IOStream
15、在jave中，类Worker是类Person的子类，Worker的构造方法中有一句”super()”, 该语句 （ ）。（选择一项）
A、调用类Worker 中定义的super()方法
B、调用类Person中定义的super()方法
C、调用类Person的构造函数
D、句法错误
16、在Java中，关于final关键字的说法正确的是（）。（选择两项）
A、如果修饰变量，则一旦赋了值，就等同一个常量
B、如果修饰类，则该类只能被一个子类继承
C、如果修饰方法，则该方法不能在子类中被覆盖
D、如果修饰方法，则该方法所在的类不能被继承
17、在Java中,下列选项表示字符”a”值的是().(选择一项)
A、'a'
B、"a"
C、new Character(a)
D、\000a
18、给定java代码片段，如下：
Integer a = new Integer(3);
Integer b = new Integer(3);
System.out.println(a==b); 运行后，这段代码将输出（）。（选择一项）
A、true
B、false
C、0
D、1
19、Java程序中读入用户输入的一个值，要求创建一个自定义的异常，如果输入值大于10，使用throw语句显式地引发异常，异常输出信息为“something’s wrong！”，语句为（）。（选择一项）
A、if (I>10) throw Exception(“something’s wrong！”);
B、if (I>10) throw Exception e (“something’s wrong！”);
C、if (I>10) throw new Exception(“something’s wrong！”);
D、if (I>10) throw new Exception e (“something’s wrong！”);
20、42.给定两个java程序,如下:Text.java的编译运行结果是(). (选择一项)
pubilc interface Face{ int count=40; }
pubilc class Text implements Face{
private static int counter;
pubilc static void main(String[]args){
System.out.println(++counter);
}
}
A、40
B、41
C、0
D、1
21、给定一个Java程序代码，如下：运行编译后，输出结果是(). (选择一项)
pubilc class Test{
int count = 9;
pubilc void count1(){
int count = 10;
System.out.println("count1"+count);
}
pubilc void count2(){
System.out.println("count2"+count);
}
pubilc static void main(String args[]){
Test t =new Twst();
t.count1();
t.count2();
}
}
A、count1=9 count2=9
B、count1=10 count2=9
C、count1=10 count2=10
D、count1=9 count2=10
22、给定java代码如下：要使用这段代码能够编译成功，横线处可以填入().(选择两项)
pubilc int count(char c,int i,double d){ return______; }
A、c*i
B、c*(int)d
C、(int)c*d
D、i*d
23、 在 JAVA编程中，Java编译器会将Java程序转换为（）。（选择一项）
A、字节码
B、可执行代码
C、机器代码
D、以上所有选项都不正确
24、在J2EE中，下列元素经过排序的集合类是（）。（选择一项）
A、LinkedList
B、Stack
C、Hashtable
D、TreeSet
25、分析下面的Java程序：
public class yy {
public static void main(String[] ards) throws Exception {
try {
throw new Exception();
}catch(Exception e){
System.out.println("Caught in main()");
}
System.out.println("nothing");
}
} 输出结果为（）。（选择一项）
A、Caught in main() nothing
B、Caught in main()
C、nothing
D、没有任何输出
26、编译并运行下面的Java代码段：
char c='a'; switch (c) {
case 'a': System.out.println("a");
default: System.out.println("default");
} 输出结果是（）。（选择一项）
A、代码无法编译，因为switch语句没有一个合法的表达式
B、a default
C、a
D、default
27、在Java中，执行下面的语句后，c的值为（）。（选择一项）
String s= "Jessica "; char c=s.charAt(6);
A、null www.87717.com
B、' '
C、'c '
D、'a '
28、在J2EE中，下面的代码中出现编译错误的是（）。（选择一项）
A、File f = new File("/","autoexec.bat");
B、DataInputStream din = new DataInputStream(new FileInputStream("autoexec.bat"));
C、InputStreamReader in = new InputStreamReader(System.in);
D、OutputStreamWriter out = new OutputStreamWriter(System.in);
29、在JavaSwing编程中，要获取每次选择的JComboBox对象的选项值，可以使用()类型的监听器. (选择两项)
A、ActionListener
B、ltemListener
C、KeyListener
D、SelectionListener
30、在Java中，下面关于包的陈述中正确的是（）。（选择两项）
A、包的声明必须是源文件的第一句代码
B、包的声明必须紧跟在import语句的后面
C、只有公共类才能放在包中
D、可以将多个源文件中的类放在同一个包中
31、在Java中，要想使只有定义该类所在的包内的类可以访问该类，应该用（ ）关键字。（选择一项）
A、不需要任何关键字
B、private
C、final
D、protected
32、包pack1的类class1中有成员方法：
protected void method_1(){…}
private void method_2(){…}
public void method_3(){…}
void method_4(){…}, 在包pack2中的类class2是class1的子类，你在class2中可以调用方法（）。（选择两项）
A、method_1
B、method_2
C、method_3
D、method_4
33、在Java语言中，小明在他的包mypackage中定义了类My_Class，在mypackage的子包mysubpackage中也有个类My_Class。小明用.import mypackage：引入包，执行其中的语句：My_Class NewClass=New My_Class();时，将发生（）。（选择一项）
A、创建一个类mypackage.My_Class对象
B、创建一个类mypackage. Mysubpackage.My_Class的对象
C、该语句是错误的
D、创建一个类mypackage.My_Class的对象和一个类mypackage. Mysubpackage.My_Class的对象
34、在JavaSwing编程中，给定一个java程序main方法的代码片段如下:
JFrame jf=new JFrame();
jf.getContentpane().setLayout(null);
jf.setSize(200,200);
jf.setVisible(true); //a
要在界面上显示如下组件，则应在A处填入(). (选择一项)
A、JTextArea text = text JTextArea(100,100);
text.setBounds(10,10,150,100); jf.getContentpane().add(text);
B、JTextField text = text JTextField(100,100); JScrollpane text=new JScrollpane(text);
jf.setBounds(10,10,150,100);jf.getContentpane().add(jp);
C、JTextArea text = new JTextArea(100,1); JScrollpane jp=new JScrollpane(text);
jp.setBounds(10,10,150,100); jf.getContentpane().add(jp);
D、JTextArea text = new JTextArea(100,100);JScrollpane
jp=new JScrollpane(text); jp.setBounds(10,10,150,100);
jf.getContentpane().add(jp);
35、在JAVA语言中，你的按钮要实现下面的功能：当鼠标按下按钮时，显示“鼠标已按下”；当释放按键时，显示“鼠标已释放”。你必须具体定义接口MouseListener的（）方法。（选择两项）
A、mouseClicked
B、mouseEntered
C、mouseExited
D、mousePressed
E、mouseReleaseed
36、JAVA中，为了辨别用户关闭窗口的时间，要实现监听器接口（）。（选择一项）
A、MouseListener
B、ActionListener
C、WindowListener
D、以上都要
37、在Java语言中，当一个类的某个变量声明为protected时下列说法正确的是（）。（选择两项）
A、只有同一类中的成员才能访问它
B、不同包中的任何其他类都能够访问它
C、同包中的任何其他类能够访问它
D、不同包中的子类可以访问该变量
38、在Java事件处理模型中，当按下鼠标按钮时，处理（）事件。（选择一项）
A、mouseReleased
B、mouseExited
C、mousePressed
D、mouseDown
39、 String s1=new String(“Hello”); String s2=new String(“there”); String s3=new String("0"); 上面是JAVA程序的一些声明，以下选项中能够通过编译的是（）。（选择一项）
A、a) s3=s1+s2
B、b) s3=s1&s2
C、c) s3=s1||s2
D、d) s3=s1&&s2
40、在Java中，调用Math.random() 方法可能返回的结果是（）。（选择一项）
A、132.34
B、0.342
C、29.34E10
D、1.0009
41、 在Java语言中，Panel默认的布局管理器是（）。（选择一项）
A、BorderLayout
B、FlowLayout
C、GridLayout
D、GridBagLayout
42、public class MyClass1 {
public static void main(String argv[]){ }
______class MyInner{} } 在以上Java代码的横线上，可放置（）修饰符。（选择两项）
A、public
B、private
C、implements
D、friend
43、在java中，下列赋值语句正确的是（）。（选择二项）
A、char c='a';
B、char c="a";
C、char c=97;
D、char c=new Character('a');
44、与传统的过程编程不同，面向对象方法的主要思想是（）。（选择两项）
A、真实反映用户的实际需求
B、将现实世界的一切抽象为实体或对象
C、将现实世界细分为一个过程化实现
D、将软件组织成为对象的集合，将数据结构和行为结合在一起
45、在Java中，根据你的理解，下列方法（）可能是类Orange的构造方法。(选择3项)
A、Orange（）{…}
B、Orange（…）｛…｝
C、Public void Orange(){…}
D、Public Orange(){…}
E、Public Orange Constuctor(){…}
46、45.在Java中,()借口位于集合框架的顶层. (选择一项)
A、Map
B、Collection
C、Set
D、List
47、给定某java程序片段，如下： int i=1; int j=i++; if((i>++j)&&(i++==j)) i+=j; System.out.println(i); 该程序运行后，i的输出结果为（）。（选择一项）
A、1
B、2
C、3
D、4
48、在Java中，假设我们有一个实现ActionListener接口的类，以下方法中（）能够为一个Button类注册这个类。（选择一项）
A、addListener()
B、addActionListener()
C、addButtonListener()
D、setListener()
49、44.在JAVA中的布局管理器，以下说法中错误的是(). (选择一项)
A、FlowLayout以由上到下的方式从左到右排列组件
B、BorderLayout使用 "东"."西"."南"."北","居中"来指定组件的位置
C、GridLayout可以创建网格布局，网格布局中各组的大小可以任意调整
D、可以通过容器的setLayout方法为容器指定布局管理
50、研究下面的Java代码：
public class testException{
public static void main(String args[]){
int n[]={0,1,2,3,4};
int sum=0;
try {
for(int i=1;i<6;i++)
sum=sum+n[i];
System.out.println("sum="+sum);
} catch(ArrayIndexOutOfBoundsExpception e) {
System.out.println("数组越界");
} finally{
System.out.println("程序结束");
}
}
} 输出结果将是（）。（选择一项）
A、10 数组越界 程序结束
B、10 程序结束
C、数组越界 程序结束
D、程序结束
1、在java中如果声明一个类为final，表示什么意思？
答：final是最终的意思，final可用于定义变量、方法和类但含义不同，声明为final的类不能被继承。
2、父类的构造方法是否可以被子类覆盖（重写）？
答：父类的构造方法不可以被子类覆盖，因为父类和子类的类名是不可能一样的。
3、请讲述String 和StringBuffer的区别。
答：String 类所定义的对象是用于存放“长度固定”的字符串。
StringBuffer类所定义的对象是用于存放“长度可变动”的字符串。
4、如果有两个类A、B（注意不是接口），你想同时使用这两个类的功能，那么你会如何编写这个C类呢？
答：因为类A、B不是接口，所以是不可以直接继承的，但可以将A、B类定义成父子类，那么C类就能实现A、B类的功能了。假如A为B的父类，B为C的父类，此时C就能实现A、B的功能。
5、结合Java视频Lesson5（多线程），分析sleep()和wait()方法的区别。
答： Sleeping睡眠的意思 : sleep() 方法用来暂时中止执行的线程。在睡眠后，线程将进入就绪状态。
waiting等待的意思: 如果调用了 wait() 方法，线程将处于等待状态。用于在两个或多个线程并发运行时。
6、谈谈你对抽象类和接口的理解。
答：定义抽象类的目的是提供可由其子类共享的一般形式、子类可以根据自身需要扩展抽象类、抽象类不能实例化、抽象方法没有函数体、抽象方法必须在子类中给出具体实现。他使用extends来继承。
接口：一个接口允许一个类从几个接口继承而来，Java 程序一次只能继承一个类但可以实现几个接口，接口不能有任何具体的方法，接口也可用来定义可由类使用的一组常量。其实现方式是interface来实现。