java工程师面试题大全100%公司笔试题你都能碰到几个

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数据库：

SELECT TOP 页大小 * FROM table1 WHERE id NOT IN (

SELECT TOP 页大小*(页数-1) id FROM table1 ORDER BY id

) ORDER BY id

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. struts2的实现原理

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_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常。 PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。 Spring 的隔离级别

1、Serializable：最严格的级别，事务串行执行，资源消耗最大； 2、REPEATABLE READ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。 3、READ COMMITTED:大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。 4、Read Uncommitted：保证了读取过程中不会读取到非法数据。

30. 写一段把本地文件formfile拷贝到本地文件tofile的程序 public class ChangeJtdToJava {

public static void main(String[] args) { File dir = new File(\

// 得到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(\

// \ // 要移到的地方

file.renameTo(new File(\ } } } }

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() 被调用

35. Servlet的生命周期分为3个阶段:? 和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）. 重定向后url地址栏地址不变还是原来的地址；而response.sendRedirect()重定向后

url地址栏地址显示的请求后的新地址。

2）. 重定向的时候可以保存回话信息，因此可以使用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模式

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

for(int j=i;j

} }

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(\

String url=\ Connection con = DriverManager.getConnection(url,\StateManager sm =con.createStateMent();

String sql = \; 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 group

64. 用什么方法使服务器关闭之后，session所保存的信息不会丢失？ 使用cookie

65. 如果页面没有标签，会出现什么错误代码？

没有什么变化

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（单例模式），Facade（门面模式），Adapter（适配器模式），Bridge（桥梁模式）

80. 由aaa字符串得到1000个a写个程序

StringBuilder sBuilder = new StringBuilder(); for(int i=0;i<333;i++){ sBuilder.Append(\}

sBuilder.Append(\

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 \+value; } }

try { //得到test.TestClass类 Class c=Class.forName(\); //得到testMethod的方法 Method m=c.getDeclaredMethod(\, new Class[]{String.class}); //打印完整的方法表示字符串 System.out.println(m.toGenericString()); //调用这个方法 Object obj=m.invoke(c.newInstance(), new Object[]{\}); //打印返回结果 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 中它以\表示。除根装载器以外的类装载器有且仅有一个父装载器。在创建一个装载器时, 如果没有显式地给出父装载器, 那么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(\); response.setCharacterEncoding(\); response.setContentType(\); StudentDao dao=new StudentDao(); List sts=dao.stlist(); request.setAttribute(\, sts); request.getRequestDispatcher(\).forward(request, response); } 学生成绩的显示页面：showStu.jsp 学号 姓名 成绩 修改 ${st.sid} ${st.name} ${st.score} alert('修改成功');window.close();\); } }

95. 用main涵数输出一到一百的和。 #include int main() {

printf(\ 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拦截器之前执行

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，但是也支持一个更强大和灵活的表达式语言－－\Graph Notation Language\(OGNL).

绑定值到页面（view）:

? Struts 1使用标准JSP机制把对象绑定到页面中来访问。

? Struts 2 使用 \技术，使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=\

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

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 \

sysdba\冷备份完毕！！

109. servlet 创建过程以及ruquest，response，session的生命周期？ Servlet的创建过程： 第一步

public class AAA extends HttpServlet{ 实现对应的doxxx方法 } 第二步:

在web.xml中配置

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 main() {

int i,j;

for(i=2;i<100;i++) {

for(j=2;j

if(i%j==0) break; }

if(i==j) {

printf(\ } } }

/* 分解质因数*/ main() {

int n,i;

printf( \

scanf( \ printf( \ for(i=2;i <=n;i++) while(n!=i) {

if(n%i==0) {

printf( \ n=n/i;

} else{ break; } }

printf( \ 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;tx){ 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

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：用\方式发送数据,可以大到4MB 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(\

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(\ }

System.out.println(\ }

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(\ }

System.out.println(\ } } }

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 + \

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(\第\期还款日期: \ 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++) {

System.out.println(++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(\ } 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 = \通过字符串寻找实现接口的类,字符串可从文件中读取获得,从而实现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()+\} //???currentThread()有什么作用呢是什么方法 //???getname呢 private synchronized void dec(){ j--;

System.out.println(Thread.currentThread().getName()+\}

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文档中的任何一部分数据。

? 基于树的处理的优点和缺点

? 优点

? 树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改 ? 可以在任何时候在树中上下导航，而不是像 SAX 那样是一次性的处理 ? DOM API是读写的，而不象SAX那样是只读的。

? 缺点

? 在内存中构建一个DOM树开销比较大 ? 创建一棵 DOM 树可能是一个缓慢的过程

? DOM不象SAX那样可以提供很多XML文档中的信息。比如非分析实体、标记、属性类型和

DTD中的声明。

SAX是一个基于事件的 API。解析器向一个事件处理程序发送事件，比如元素开始和元素结束，而事件处理器则处理该信息。应用程序本身就能够处理该数据。原始的文档仍然保留完好无损 ? 优点：

? 可以解析任意大小的文件； ? 适合创建自己的数据结构； ? 适合小信息子集； ? 简单； ? 快速

? 缺点：

? 不能对文档做随机存取； ? 难以实现复杂的查询；

? 不能使用文档类型定义（DTD）； ? 不可获取词法信息； ? SAX是只读的；

? 当前的浏览器不支持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的几种视图： ? 用例视图--从使用者角度描述系统功能 ? 逻辑视图—描述系统内部如何实现

? 组件视图—描述系统有哪些组件/模块构成 ? 并发视图—描述系统内部的通信与并发问题 配置视图—描述系统软硬件的配置与位置关系

? 用例图—描述系统的参与者与用例之间的关系 ? 类图—描述系统中的概念及它们之间的关系 ? 对象图—描述系统中实例及它们之间关系

? 状态图—描述系统中对象所具备的状态，及触发状态改变的事件 ? 时序图—描述对象之间发送消息的时间顺序 ? 协作图—描述对象之间协作关系

? 活动图—描述执行过程中涉及的活动及状态变化 ? 组件图—描述系统组件之间的关系 配置图—描述系统的硬件及软件的物理结构

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 = \ System.out.println(\交换前b = \

a=a+b; b=a-b; a=a-b;

System.out.println(\交换后a = \ System.out.print(\交换后b = \ }

public static void main(String args[]){

本文来源：https://www.bwwdw.com/article/t1bg.html