java知识点总结
hibernate中离线查询去除重复项怎么加条件？？
dc.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
http协议及端口,smtp协议及端口
http：超文本传输协议 端口 80
smtp：简单邮件传输协议端口25
编写程序，完成文件复制功能
Servlet创建过程及生命周期Servlet 在容器中运行时，其实例的创建及销毁等是由容器进行控制。
Servlet 的创建有两种方法。
客户端请求对应的Servlet 时，创建 Servlet 实例;大部分Servlet 都是这种 Servlet 。
通过在web.xml 中设置load-on-startup来创建servlet实例，这种实例在Web 应用启动时，立即创建Servlet 实例
Servlet 的运行都遵循如下生命周期：
创建 Servlet 实例。
Web 容器调用 Servlet 的 init() 方法，对Servlet 进行初始化。
Servlet 初始化后，将一直存在于容器中，用于响应客户端请求。根据客户端的请求方式通过Servlet中service()方法去相应的doXXX()方法；
Web 容器销毁Servlet 时，调用 Servlet 的 destroy() 方法，通常在关闭Web容器之时销毁Servlet。
用sql语句分页：
Mysql数据库：
SELECT TOP 页大小 * FROM table1WHERE 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,rownumas 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;
list.map.set的存储特点?
List 以特定次序来持有元素,可有重复元素.
Set 无法拥有重复元素,内部排序.
Map 保存key-value值,value可多值
final,finally,finaliz的区别
final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声 明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改 被声明为final的方法也同样只能使用，不能重载。
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
finalize—方法名。Java 技术允许使用finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖；finalize() 方法以整理系统资源或者执行其他清理工作 finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。
arraylist和vector的区别?
1).同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程不安全的，不是同步的
2).数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半
说出ArrayList,Vector,LinkedList的存储性能和特性？
ArrayList 采用的是数组形式来保存对象的，这种方式将对象放在连续的位置中，所以最大的缺点就是插入删除时非常麻烦 LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引但是缺点就是查找非常麻烦 要丛第一个索引开始
ArrayList和Vector都是用数组方式存储数据,此数组元素数要大于实际的存储空间以便进行元素增加和插入操作,他们都允许直接用序号索引元素,但是插入数据元素涉及到元素移动等内存操作,所以索引数据快而插入数据慢.
Vector使用了sychronized方法(线程安全),所以在性能上比ArrayList要差些.
LinkedList使用双向链表方式存储数据,按序号索引数据需要前向或后向遍历数据，所以索引数据慢,是插入数据时只需要记录前后项即可,所以插入的速度快.
HASHMAP,HASHTABLE区别
1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；
2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。
3.在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。
.描述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。
String和stringbuffer进行字符串连接时的区别？
String对项内容是不可改变的，StringBuffer是可以改变的，且高效；
什么叫项目？
用有限的资源、有限的时间为特定客户完成特定目标的一次性工作
.J2EE J是什么意思？ 2是什么意思 EE是什么意思？ Struts的拦截器你是怎么做的，是独立开发的，能够独立开发的到。然后问有哪几种拦截？
Java 2 Platform，Enterprise Edition
继承AbstractInterceptor类，覆盖intercept()方法
有struts自己的拦截器 如timer ,i18n,scop,servletconfig,token
还有自定义拦截器
简单介绍下java？Spring的AOP，IOC的讲述 对struts2的了解，1，2的比较 xml的了解 J2ee的webserviced的协议？
Spring AOP:代理机制 Spring提供的自动代理机制
Spring的IoC来实组件之间的依赖关系注入,使控制层与业务实现分离，即客户通过
调用业务委托接口来调用具体的业务组件的实例，避免控制层与业务层的藕合带来的维护
或升级困难。由Spring为DAO生成代理对象来为DAO添加事务服务，由IoC容器DAO的代理实例注入到业务组件中,业务组件通过DAO的委托接口调用DAO对象，使得上层组件不直接依赖于DAO的实现类，使得持久层更换或修改不影响上层组件。
Collections,collection的区别
Collection是个java.util下的接口，它是各种集合结构的父接口。Collections是个java.util下的普通类，它包含有各种有关集合操作的静态方法。Collections是针对集合类的一个帮助类，它提供一系列的静态方法实现对各种集合的搜索，排序，线程安全化等操作
如何释放过度使用的undo表空间
1. 启动SQLPLUS，并用sys登陆到数据库。 2. 查找数据库的UNDO表空间名3. 确认UNDO表空间；SQL> select name from v$tablespace; 4. 检查数据库UNDO表空间占用空间情况以及数据文件存放位置； 5. 查看回滚段的使用情况，哪个用户正在使用回滚段的资源，如果有用户最好更换时间 6. 检查UNDO Segment状态
数据库里面游标，索引是怎么用的？ 在oracle数据库中，用get 和load方法这2个方法来查没有的数据那么分别会反馈什么样的结果？
declare cur cursor keyset for
get返回null,load classnotfoundException
.在Oracle中数据库中的一个表中，这个表没有主键id也没有特定标示来查数据，怎么查？
rowid
简述private、proteced、public、internal修饰符的访问权限
同一个类 同一个包 不同包的子类 不同包非子类
private *
default * *
protected * * *
public * * * *
概述反射和序列化
Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。本文借由实例，大面积示范Reflection APIs。
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流
ORACLE中not和and和or优先级由高到低？
not and or
java 是如何进行异常处理的
Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理
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
dao 是什么及作用
dao 是数据访问对象 DAO负责管理与数据源的连接来获取和储存其中的数据
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$‘
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
简述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：保证了读取过程中不会读取到非法数据。
写一段把本地文件formfile拷贝到本地文件tofile的程序
public class ChangeJtdToJava {
public static voidmain(String[] args) {
Filedir = new File(“f:/jtd”);
//得到d:/jtd 下的所有文件对象
File[]files = dir.listFiles();
for(File file : files) {
StringfileName = file.getName(); // 得到文件名
intindex = fileName.indexOf(“.”);// .的索引位置
StringfileName2 = fileName.substring(0, index); // 不带后缀名的文件名
StringhouZui = fileName.substrinxg(index);
if(houZui.equals(“.jtd”)) {
//“f:/java/” + fileName2 + “.java”
//要移到的地方
file.renameTo(newFile(“f:/java/” + fileName2 + “.java”));
}
}
}
}
写出删除表中重复记录的语句oracle
delete from people
where peopleId in (select peopleId frompeople group by peopleId having count(peopleId) > 1) and rowid not in(select min(rowid) from people group by
java 类实现序列化的方法（二种）？如在collection框架中，要实现什么样的接口
java.io.Serializable接口
Collection框架中实现比较要实现Comparable 接口和 Comparator 接口
Struts2实现拦截器的原理？
实现原理：Struts2拦截器是在访问某个Action或Action的某个方法、字段之前或之后实施拦截，并且Struts2拦截器是可插拔的，拦截器是ＡＯＰ的一种实现。当请求struts2的action时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表，最后一个一个地调用列表中的拦截器。
sleep()和wait()区别
sleep() 方法：线程主动放弃CPU，使得线程在指定的时间内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后重新测试，直到条件满足为止。
wait( ) ：与notify()配套使用，wait()使得线程进入阻塞状态，它有两种形式，一种允许指定以毫秒为单位的一段时间作为参数，另一种没有参数，当指定时间参数时对应的notify() 被调用或者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用
Servlet的生命周期分为3个阶段:? 和CGI的区别？
Servlet的生命周期主要由3个过程组成。
(1)init()方法：服务器初始化servlet。
(2)service()方法：初始化完毕，servlet对象调用该方法响应客户的请求。
(3)destroy()方法：调用该方法消灭servlet对象。
其中，init()方法只在servlet第一次被请求加载的时候被调用一次，当有客户再请求servlet服务时，web服务器将启动一个新的线程，在该线程中，调用service方法响应客户的请求。
与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
forward与redirect 的区别?有哪些方式实现
<jsp:forward>重定向后url地址栏地址不变还是原来的地址；而response.sendRedirect()重定向后url地址栏地址显示的请求后的新地址。
<jsp:forward>重定向的时候可以保存回话信息，因此可以使用request来进行参数传递，在新页面可以使用request.getAttribute()来得到参数。而response.sendRedirect()不支持此通过request进行参数传递。它唯一的传值方式为response.sendRedirect(“example.jsp?aa=123″)，在新的页面通过request.getParameter(“aa”)来得到参数值
多线程、同步实现方法？
1）实现线程有两种方法：继承Thread类或者实现Runnable接口
2）实现同步也有两种,一种是用同步方法,一种是用同步块.. 同步方法就是在方法返回类型后面加上synchronized, 比如:
public void synchronized add(){…}
同步块就是直接写:synchronized(这里写需要同步的对象){…}
集合类有哪些？有哪些方法？
集合类 ArrayList LinkedListHashSet HashMap
方法：add(),remove(),put(),addAll(),removeAll()
java中实现多态的机制是什么
重写，重载
方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被”屏蔽”了。
果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
静态的多态和动态的多态的区别
静态的多态: 即为重载 ；方法名相同，参数个数或类型不相同。(overloading)
动态的多态: 即为重写；子类覆盖父类的方法，将子类的实例传与父类的引用调用的是子类的方法 实现接口的实例传与接口的引用调用的实现类的方法。
作用域Public,private,protected.以及不写时的区别
public整个java程序中都可以访问
protected在其他包中不可以访问
friendly只有当前包或当前内可以访问，其他都不行
private只有当前内可以访问
不写的话默认是protected
extends和implement的不同
extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了 比如 class A extends B implements C,D,E
join与left join的区别：
inner join(等值连接) 只返回两个表中联结字段相等的行
left join(左联接) 返回包括左表中的所有记录和右表中联结字段相等的记录
right join(右联接) 返回包括右表中的所有记录和左表中联结字段相等的记录
DAO设计模式与DELEGATE模式
DAO(Data Access Object)模式实际上是两个模式的组合，即Data Accessor 模式和 Active Domain Object 模式，其中 Data Accessor 模式实现了数据访问和业务逻辑的分离，而Active DomainObject 模式实现了业务数据的对象化封装，一般我们将这两个模式组合使用。
DAO 模式通过对底层数据的封装，为业务层提供一个面向对象的接口，使得业务逻辑开发员可以面向业务中的实体进行编码。通过引入DAO模式，业务逻辑更加清晰，且富于形象性和描述性，这将为日后的维护带来极大的便利。试想，在业务曾通过Customer.getName方法获得客户姓名，相对于直接通过SQL语句访问数据库表并从ResultSet中获得某个字符型字段而言，哪种方式更加易于业务逻辑的形象化和简洁化？
Business Delegate起到客户端业务抽象化的作用。它抽象化，进而隐藏业务服务的实现。使用BusinessDelegate，可以降低表示层客户端和系统的业务服务之间的耦合程度。根据实现策略不同，Business Delegate可以在业务服务API的实现中，保护客户端不受可能的变动性影响。这样，在业务服务API或其底层实现变化时，可以潜在地减少必须修改表示层客户端代码的次数。
适配器模式与桥梁模式的区别
适配器模式把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。又称为转换器模式、变压器模式、包装模式（把已有的一些类包装起来，使之能有满足需要的接口）。适配器模式的用意是将接口不同而功能相同或者相近的两个接口加以转换，包括适配器角色补充一些源角色没有但目标接口需要的方法。就像生活中电器插头是三相的，而电源插座是两相的，这时需要一个三相变两相的转换器来满足。
比如，在Java I/O库中使用了适配器模式，象FileInputStream是一个适配器类，其继承了InputStrem类型，同时持有一个对FileDiscriptor的引用。这是将一个FileDiscriptor对象适配成InputStrem类型的对象形式的适配器模式。StringReader是一个适配器类，其继承了Reader类型，持有一个对String对象的引用。它将String的接口适配成Reader类型的接口。等等。
桥梁模式的用意是要把实现和它的接口分开，以便它们可以独立地变化。桥梁模式并不是用来把一个已有的对象接到不相匹配的接口上的。当一个客户端只知道一个特定的接口，但是又必须与具有不同接口的类打交道时，就应该使用桥梁模式。
比如，JDBC驱动器就是一个桥梁模式的应用，使用驱动程序的应用系统就是抽象化角色，而驱动器本身扮演实现化角色。应用系统和JDBC驱动器是相对独立的。应用系统动态地选择一个合适的驱动器，然后通过驱动器向数据库引擎发出指令就可以访问数据库中的数据。
工厂模式
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
开发中都用到了那些设计模式?用在什么场合?
每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。
(1) MVC模式,在J2EE项目开发中主要用在表示层框架中，很好解决视图和流程控制。在项目中采用的Struts、WebWork等框架。
(2) DAO模式,在项目开发中主要用在数据层，封装数据的访问操作，为业务层提供数据服务。
(3) IoC模式,在项目开发中业务层有大量对象，他们之间存在依赖关系，可以使用IoC模式减少他们之间的代码耦合，提高系统的可扩展性。实际项目中使用的Spring框架来实现业务组件的装配。
(4) Observer模式，在Servlet的监听器中应用到了观察者模式。
(5) singleton单例模式和Factory工厂模式结合使用在项目中无需使用者了解过多的细节就可获取有关的对象实例。比如Hibernate项目中通过SessionFactory来获取Session。
(6) bridge模式，在项目中使用JDBC驱动访问数据库。
Hibernate中离线查询与在线查询的区别
Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样， Criteria 是在线的，所以它是由 Hibernate Session 进行创建的；而 DetachedCriteria 是离线的，创建时无需 Session，DetachedCriteria 提供了 2 个静态方法 forClass(Class)或forEntityName(Name) 进行DetachedCriteria 实例的创建。
C#数据类型有哪些？
int 整型double 双精度型string 字符串型 char 字符型 bool 布尔型
抽象类能否被实例化 ？抽象类的作用是什么？
抽象类一般不能被实例化；
抽象类通常不是由程序员定义的，而是由项目经理或模块设计人 设计抽象类的原因通常是为了规范方法名 抽象类必须要继承，不然没法用，作为模块设计者，可以把让底层程序员直接用得方法直接调用，而一些需要让程序员覆盖后自己做得方法则定义称抽象方法
ASP.NET页面传递值的方式有哪些
1 通过URL链接地址传递 2 通过post方式。 3 通过session 4通过Application
5 通过Server.Transfersend.aspx:
如何定义一个MDI(.NET技术)
定义MDI父窗口应该是设置窗体的MdiParent属性= true
WCF是什么？
Windows Communication Foundation
(WCF) 是由微软发展的一组数据通信的应用程序开发接口，它是.NET框架的一部分，由 .NET Framework 3.0 开始引入，与 Windows PresentationFoundation 及 WindowsWorkflow Foundation 并行为新一代 Windows 操作系统以及 WinFX 的三个重大应用程序开发类库
常用的包，类，接口，各举5个。
类StringInteger Long File Date
包java.lang.*;java.io.*;java.util.*;java.swt.*;java.math.*;
接口: Comparable,Connection,Map,List,Runable,
网上购物系统的类图，用例图。
用例图：
类图:
给你一个整数类型的数组，按从小到大的顺序进行排列！
public static void fun(int [] a,int c){
for(inti=0;i<a.length-1;i++){
for(intj=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]+” “);
}
}
查询出M 页的N行数据(分页的实现，求第M也的记录数)
Select top N from table where id not in(select top (M-1)*N id from table )
Linkedlist arraylist内部是如何实现的（更深入的问了LinkedList与ArrayList的区别）
ArrayList的内部实现是基于内部数组Object[]，所以从概念上讲，它更像数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更像一个链表结构，所以，它们在性能上有很大的差别。
在ArrayList的前面或中间插入数据时，必须将其后的所有数据相应的后移，这样必然要花费较多时间，所以，当你的操作是在一列数据的后面添加数据而不是在前面或中间，并且需要随机地访问其中的元素时，使用ArrayList会提供比较好的性能；
而访问链表中的某个元素时，就必须从链表的一端开始沿着连接方向一个一个元素地去查找，直到找到所需的元素为止，所以，当你的操作是在一列数据的前面或中间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。
如果在编程中，两种情形交替出现，这时，可以考虑使用List这样的通用接口，而不用关心具体的实现，在具体的情形下，它的性能由具体的实现来保证
new ArrayList(10)含义
在内存中连续分配了用来存在Object对象的数组；
面向对象主要内容? 有什么作用？
就分析设计层面来说，面向对象技术提供了更高级的抽象能力以及更多的方法和工具，如设计模式；就实现维护层面来说，面向对象技术使代码重用更容易，且使代码具有可扩展性，便于软件的维护和升级更新。
如何移动一个数 使62-63=1成立
62-63=1如何移动 2的6次方等于64 2的6次方-63=1 把2移动到6的左下方
递归实现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);
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);
写出删除表中重复记录的语句oracle
delete from people
where peopleId in (select peopleId frompeople group by peopleId having count(peopleId) > 1) and rowid not in(select min(rowid) from people group
用什么方法使服务器关闭之后，session所保存的信息不会丢失？
使用cookie
如果页面没有<html></html>标签，会出现什么错误代码？
没有什么变化
抽象类是否可以没有抽象方法？为什么？
可以 在java中用abstract关键字来修饰一个类时，这个类叫做抽象类。
抽象类中不一定要包含abstract方法，但一个类中包含了abstract方法，则这个类必须声明为abstract类。
servlet中的init方法什么时候被调用？
容器首次创建实例的时候
用4 个0，用你所知道的数学方法计算出24
0的阶乘等于1 即 0！＝１那么４个0就是４了
又4的阶乘为２４ ４！＝２４
linux中进程的查看和调度分别用什么命令？
ps -A 查看 renice top
集合类有哪些？有哪些方法？
集合类 ArrayListLinkedList HashSet HashMap
方法：add(),remove(),put(),addAll(),removeAll()
OSI七层模型tcp四层模型是什么样的
OSI七层参考模型：物理层 、数据链路层 、网络层 、传输层、应用层、会话层、表示层
TCP/IP:第一层网络接口层第二层第二层??网间层第三层??传输层第四层??应用层
JAVA测试模式(ZZ)：
模式（一） Main 模式
模式（二） toString模式
模式（三） Equal 模式
模式（四） InternalTester Class 模式
模式（五） ExternTester Class 模式
一学生表！有班及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 )
jdk的新特性
“JDK1.5″的一个重要主题就是通过新增一些特性来简化开发，这些特性包括泛型，for-each 循环，自动装包/拆包，枚举，可变参数, 静态导入 。使用这些特性有助于我们编写更加清晰，精悍，安全的代码。
j2ee的规范？
SUN公司定义的一个开发分布式企业级应用的规范。它提供了一个多层次的分布式应用模型和一系列开发技术规范。多层次分布式应用模型是指根据功能把应用逻辑分成多个层次，每个层次支持相应的服务器和组件，组件在分布式服务器的组件容器中运行（如Servlet组件在Servlet容器上运行，EJB组件在EJB容器上运行），容器间通过相关的协议进行通讯，实现组件间的相互调用J2EE规范定义了以下四个层次。1.客户端层(ClientTier) 2.Web层 3.业务层(Business Tier) 4.企业信息系统层
ajax的工作原理？
Ajax 基本上就是把 JavaScript 技术和 XMLHttpRequest 对象放在 Web 表单和服务器之间。当用户填写表单时，数据发送给一些 JavaScript 代码而不是 直接发送给服务器。相反，JavaScript 代码捕获表单数据并向服务器发送请求。同时用户屏幕上的表单也不会闪烁、消失或延迟。换句话说，JavaScript 代码在幕后发送请求，用户甚至不知道请求的发出。更好的是，请求是异步发送的，就是说 JavaScript 代码（和用户）不用等待服务器的响应。因此用户可以继续输入数据、滚动屏幕和使用应用程序。
然后，服务器将数据返回JavaScript 代码（仍然在 Web 表单中），后者决定如何处理这些数据。它可以迅速更新表单数据，让人感觉应用程序是立即完成的，表单没有提交或刷新而用户得到了新数据。JavaScript 代码甚至可以对收到的数据执行某种计算，再发送另一个请求，完全不需要用户干预！这就是 XMLHttpRequest 的强大之处。它可以根据需要自行与服务器进行交互，用户甚至可以完全不知道幕后发生的一切。结果就是类似于桌面应用程序的动态、快速响应、高交互性的体验，但是背后又拥有互联网的全部强大力量。
.Xml特点？
XML是一种可扩展标记语言 (XML) 是 Web 上的数据通用语言。它使开发人员能够将结构化数据，从许多不同的应用程序传递到桌面，进行本地计算和演示。XML 允许为特定应用程序创建唯一的数据格式。它还是在服务器之间传输结构化数据的理想格式。
XML主要具有以下几个特点：
① 简洁有效
XML是一个精简的SGML，它将SGML的丰富功能与HTML的易用性结合到Web应用种，它保留了SGML的可扩展功能，这使得XML从根本上有区别于HTML。并且XML种还包括可扩展格式语言XSL（ExtensibleStyle Language）和可扩展链接语言XLL（Extensible Linking Language）使得XML的显示和解析更加方便快捷。
② 易学易用
XML对SGML进行了精简，它抛弃了SGML中不常用的部分，方便用户编写Web页面同时也给设计人员实现XML浏览器降低了困难。
③ 开放的国际化标准
XML是W3C正式批准的，它完全可用于Web和工具的开发。XML具有标准的名域说明方法，支持文档对象模型标准、可扩展类型语言标准、可扩展链接语言标准和XML指针语言标准。使用XML可以在不同的计算机系统间交换信息，而且还可以跨越国界和超越不同文化疆界交换信息。
④ 高效可扩充
XML支持复用文档片断，使用者可以发明和使用自己的标签，也可以与他人共享，可延伸性大。在XML中，可定义一组无限量的标准，可以有效地进行XML文件的扩充。
oracle中除了数据库备份，还有什么方法备份？
Oracle数据库有三种标准的备份方法，它们分别是导出/导入(EXP/IMP)、热备份和冷备份。导出备份是一种逻辑备份，冷备份和热备份是物理备份。
j2ee的常用设计模式
Factory（工厂模式）,Builder（建造模式）Factory Method（工厂方法模式），Prototype（原始模型模式），Singleton（单例模式），Facade（门面模式），Adapter（适配器模式），Bridge（桥梁模式）
由aaa字符串得到1000个a写个程序
StringBuilder sBuilder = newStringBuilder();
for(int i=0;i<333;i++){
sBuilder.Append(“aaa”);
}
sBuilder.Append(“aaa”.subString(0,1));
servlet与cgi的区别
CGI应用开发比较困难，因为它要求程序员有处理参数传递的知识，这不是一种通用的技能。CGI不可移植，为某一特定平台编写的CGI应用只能运行于这一环境中。每一个CGI应用存在于一个由客户端请求激活的进程中，并且在请求被服务后被卸载。这种模式将引起很高的内存、CPU开销，而且在同一进程中不能服务多个客户。
Servlet提供了Java应用程序的所有优势——可移植、稳健、易开发。使用Servlet Tag技术，Servlet能够生成嵌于静态HTML页面中的动态内容
Servlet对CGI的最主要优势在于一个Servlet被客户端发送的第一个请求激活，然后它将继续运行于后台，等待以后的请求。每个请求将生成一个新的线程，而不是一个完整的进程。多个客户能够在同一个进程中同时得到服务。一般来说，Servlet进程只是在Web Server卸载时被卸载
SOCKET中有几中连接方式，区别？
Sockets有两种主要的操作方式:面向连接的和无连接的。无连接的操作使用数据报协议，无连接的操作是快速的和高效的,但是数据安全性不佳. 面向连接的操作使用TCP协议.面向连接的操作比无连接的操作效率更低,但是数据的安全性更高
Socket如何获取本地ip地址？
public InetAddress getLocalAddress()
truncate与delete的区别？（deletefrom 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, 高水线(highwatermark)保持原位置不动
显然drop语句将表所占用的空间全部释放
truncate 语句缺省情况下见空间释放到 minextents个extent,除非使用reuse storage;truncate会将高水线复位(回到最开始).
4.速度,一般来说:drop> truncate > delete
5.安全性:小心使用drop和truncate,尤其没有备份的时候.否则哭都来不及
使用上,想删除部分数据行用delete,注意带上where子句. 回滚段要足够大.
想删除表,当然用drop
想保留表而将所有数据删除. 如果和事务无关,用truncate即可. 如果和事务有关,或者想触发trigger,还是用delete.
xml有哪些解析技术，及区别？
有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
文件和目录(i/o)操作，怎么列出某目录下所有文件？某目录下所有子目录，怎么判断文件或目录是否存在？如何读写文件？
列出某目录下所有文件：调用listFile()，然后判断每个File对象是否是文件可以调用 isFile（），判断是否是文件夹可以调用isDirectory（），判断文件或目录是否存在：调用exists() 方法，读写文件使用FileReader和FileWriter两个类即可
怎么用java反射得到一个类的私有方法？
package test;
public
class TestClass {
privateString 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(); } |
写一个单例模式？描述工厂模式和单例优缺点 举例在什么情况下用
| class Single{} public private SingleFactory(){}; private public if(single==null){ single=new Single(); } return } } |
简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。通过它，外界可以从直接创建具体产品对象的尴尬局面中摆脱出来。
外界与具体类隔离开来，偶合性低。
明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
缺点：工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则 虽然简单工厂模式能够适应一定的变化，但是它所能解决的问题是远远有限的。它所能创建的类只能是事先教考虑到的，如果需要添加新的类，则就需要改变工厂类了。（这个问题在工厂方法模式将得到很好的解决）
应用情景 工厂类负责创建的对象比较少客户只知道传入了工厂类的参数，对于始何创建对象（逻辑）不关心
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) 装载器: 装载器为系统装载器，它从用户指定的网络上的特定目录装载小应用程序代码。
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文件。
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 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上
Error和 exception的区别与联系
error 表示恢复不是不可能,但很困难的情况下的一种严重问题。比如说内存溢,网络故障等。不可能指望程序能处理的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，就不会发生的情况。程序可以捕获到这些异常，并进行处理。
在编写页面的会用到哪些技术？
美化页面需要用到CSS、页面交互使用JavaScript、动态页面需要用到JSP、XML等动态网页技术。
手写个程序在本页面中心弹出一个窗体，里面有学生的成绩，可以修改学生的成绩，并且可以关闭窗口，把每个要用的jsp页面显示出来。（用JavaScript）
到显示页面的ShowStudentServlet
| public 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}“ <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>
|
请求修改的UpdateStudentServlet
| public 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 } } |
可以修改成绩的页面:updateStu.jsp
| <base href=“<%=basePath%>“ <form action=“UpdateScoreServlet” method=“post”> <table> <tr> <th>编号</th> <td><input type=“text” name=“sid” value=“${st.sid }“ </tr> <tr> <th>姓名</th> <td><input type=“text” name=“name” value=“${st.name }“ </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>
|
负责修改成绩的UpdateScoreServlet
| public 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>”); } } |
用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;
}
查一下每门课程都大于80的学生姓名
学生表student 分数表grade
select s.name from student s where s.id notin(select g.studentid from grade g where g.marks<=80)
或者
select s.name from student s where notexists(select 1 from grade g where g.studentid=s.id and g.marks<=80)
LIUNIX如何查看CPU,IP,内存？
cat /proc/cpuinfo 查看CPU
cat /proc/meminfo 查看内存
/sbin/ifcong 查看 IP的
j2EE系统访问速度慢.从哪些方面可以优化
J2EE性能的优化包括很多方面的，要达到一个性能优良的系统，除了关注代码之外，还应该根据系统实际的运行情况，从服务器软硬件环境、集群技术、系统构架设计、系统部署环境、数据结构、算法设计等方面综合考虑
J2EE访问速度慢，怎么样优化
1 使用缓冲标记对于代码逻辑复杂的页面，利用缓冲标记提高性能的效果比较明显；反之，效果可能略逊一筹。
2 始终通过会话Bean访问实体Bean一些时候，使用实体Bean会导致程序性能不佳。如果实体Bean的惟一用途就是提取和更新数据，改成在会话Bean之内利用JDBC访问数据库可以得到更好的性能
3 选择合适的引用机制
4 在部署描述器中设置只读属性实体Bean的部署描述器允许把所有get方法设置成”只读”。当某个事务单元的工作只包含执行读取操作的方法时，设置只读属性有利于提高性能，因为容器不必再执行存储操作
5 缓冲对EJB Home的访问
haShtable的原理
原理:通过节点的关键码确定节点的存储位置,即给定节点的关键码k,通过一定的函数关系H(散列函数),得到函数值H(k),将此值解释为该节点的存储地址
struts中的prepare怎么用？
prepare是在validate拦截器之前执行
<s:checkboxlist list=”users” listKey=”id” listValue=”name” name=”userid”></s:checkboxlist>
在使用struts2checkboxlist,select绑定list时，有时候会出现 以下异常
The requested list key ‘users’ could not be resolved as a collection/array/map/enumeration/iteratortype. Example: people or people.{name} – [unknown location]这样的错误。是因为list的值为空
解决办法是把初始化list的工作放到prepare拦截器中
public class RoleAction extendsActionSupport implements Preparable{
@Override
public void prepare() throws Exception {
//初始化list
} }
C#题目conetextmenu控件如何使用.. listview
ContextMenu 组件提供与选定对象相关的常用命令的菜单。可以通过向 MenuItems 集合中添加 MenuItem 对象来向快捷菜单中添加项。可以从快捷菜单中永久地移除项；但是在运行时隐藏或禁用项可能更为妥当。ListView的ContextMenu属性设置为ContextMenu对象
写一条SQL语句，查询姓张学生中平均成绩大于75的学生信息
select * from student where name in (selectname from student
where name like ‘张%’ group by name having avg(score) > 75)
从以下方面比较strut1和strut2:线程模式、依赖、可测性、表达式语言、捕获输入、绑钉值到页面、类型转换
线程模式: Struts1Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
• Struts2Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）
Servlet 依赖:
• Struts1Action 依赖于Servlet API,因为当一个Action被调用时HttpServletRequest 和 HttpServletResponse 被传递给execute方法。
• Struts 2Action不依赖于容器，允许Action脱离容器单独被测试。如果需要，Struts2 Action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问HttpServetRequest和HttpServletResponse的必要性。
可测性:
• 测试Struts1 Action的一个主要问题是execute方法暴露了servlet API（这使得测试要依赖于容器）。一个第三方扩展－－Struts TestCase－－提供了一套Struts1的模拟对象（来进行测试）。
• Struts 2Action可以通过初始化、设置属性、调用方法来测试，”依赖注入”支持也使测试更容易。
捕获输入:
• 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 GraphNotation Language” (OGNL).
绑定值到页面（view）:
• Struts 1使用标准JSP机制把对象绑定到页面中来访问。
• Struts 2 使用 “ValueStack”技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。ValueStack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。
类型转换：
• Struts 1ActionForm 属性通常都是String类型。Struts1使用Commons-Beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。
• Struts2 使用OGNL进行类型转换。提供基本和常用对象的转换器。
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将结果展现给用户。
Spring工作原理
内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射,反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xmlSpring的配置文件来动态的创建对象，和调用对象里的方法的 还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象 进行监督和控制（也就是在调用这类对象的具体方法的前后去调用你指定的模块）从而达到对一个模块扩充的功能。这些都是通过配置类达到的
Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明管理的（Spring根据这些配置 内部通过反射去动态的组装对象）要记住：Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能
Hibernate 的初始化.
读取Hibernate 的配置信息-〉创建Session Factory
1)创建Configeration类的实例。
它的构造方法：将配置信息(Hibernateconfig.xml)读入到内存。
一个Configeration实例代表Hibernate 所有Java类到Sql数据库映射的集合。
2)创建SessionFactory实例
把Configeration对象中的所有配置信息拷贝到SessionFactory的缓存中。
SessionFactory的实例代表一个数据库存储员源，创建后不再与Configeration 对象关联。
缓存(cache):指Java对象的属性(通常是一些集合类型的属性－－占用内存空间。
在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 完成备份后启动数据库用冷备份进行恢复时，只需要将所有文件恢复到原有位置，就可以启动数据库了
关闭数据库SQL>shutdown 5 备份文件到备份的目录 6 然后启动数据库 ＃sqlplus “/as sysdba”SQL>startup 冷备份完毕！！
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自动销毁。客户端第一次请求时，容器会建立相应的会话，直到会话超时，会话随即销毁。
手写个单例模式？每个公司基本都考
public class danli {
private staticdanli dl;
privatedanli(){
System.out.println(“单例模式”);
}
publicstatic danli getconnection()
{
if(dl==null)
{
dl=newdanli();
}
returndl;
}
}
解释一下mvc以及熟悉的mvc框架
答:m代表模型层，v 代表视图层，c代表控制层，也就是把一个整体分割成不同的模块，各负责自己的功能，分工明确，提高代码的重用性和方便维护。
在jsp设计模式二中，jsp用来做视图层，servlet是控制器，dao则处理相关业务成为模型层。
在struts2.0,其中m是action,c是拦截器，v是jsp.
解释一下IOC,以及spring的举例
IOC称为控制反转，也叫依赖注入，ioc是Spring的核心组件，它通过配置文件，将需要创建的对象以池的方式管理，将实例注入到需要的对象中区，是对象依赖于注入而不依赖于实现，解决了各个组件的耦合度，使得项目在后期的维护和扩展上非常方便。如在ssh框架整合中，我们将datasource对象注入给sessionFactory，再将sessionFactory注入给dao组件，再将dao组件注入给struts的Action组件，在将action对象注入给struts的拦截器。
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;
浏览器页面与T0MCat的交互过程？
当一个JSP页面第一次被访问的时候，JSP引擎将执行以下步骤：
（1）将JSP页面翻译成一个Servlet，这个Servlet是一个java文件，同时也是一个完整的java程序
（2）JSP引擎调用java编译器对这个Servlet进行编译，得到可执行文件class
（3）JSP引擎调用java虚拟机来解释执行class文件，生成向客户端发送的应答，然后发送给客户端
以上三个步骤仅仅在JSP页面第一次被访问时才会执行，以后的访问速度会因为class文件已经生成而大大提高。当JSP引擎街道一个客户端的访问请求时，首先判断请求的JSP页面是否比对应的Servlet新，如果新，对应的JSP需要重新编译。
用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();
}
用一个方法查出宜个数值类型数组的最大值，用递归方式实现
方法1
public class Test1 {
public static inta(int[] i,int j){
if(i.length-1>j){
if(i[j]>i[j+1]){
i[j+1]=i[j];
}
returna(i,j+1);
}else{
returni[i.length-1];
}
}
}
方法2 — 非递归
public static int test(int []num) { intx=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, intindex,int max){
intlen = a.length;
if(len==1){
returna[len-1];
}
if(index==0){
max= a[index];
}
if(index==len){
returnmax;
}
if(max<a[index]){
max= a[index];
}
index++;
returngetMax(a,index,max);
}
// 测试
int max = getMax(newint[]{2,5,18,3,38,10,2},0,0);
System.out.println(max);
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主要用于控制逻辑。
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 自己指定的任何资格。
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只能采取这样笼统而又松散的线程规范。
写一个单例Signleton代码
public
class Singleton {
privateSingleton(){};
private
static Singleton singleton;
@SuppressWarnings(“unused”)
private
static Singleton getSingleton(){
if(singleton==null){
singleton=newSingleton();
}
return
singleton;
}
}
Mvc各部分用什么实现？
视图层用jsp，javascript
作用–显示数据，接受用户输入数据
控制层用servlet
作用–接收视图层数据，传输 给业务逻辑层（即模型层）
模型层用普通javaBean
作用–业务类的实现，如：数据库操作
ejb是基于哪些技术实现的，和javabean的区别？
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现EJB是一个关于用JAVA语言开发的可部署的服务器端组件的组件体系结构。它是一个技术协议，能使组件运行于任何应用服务器,专门用来解决商务问题JAVABEANS是JAVA类，是由属性、事件和方法组成的JAVA组件，它们可以用来组成JAVA应用程序
适配器模式解释：
把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端
进程和线程的区别：
线程是一种操作系统对象，代表着一个进程中要被执行的代码的路径。每一个WIN32应用程序至少有一个线程–通常称为住线程或默认线程–但应用程序可以自由地创建其他线程来执行其他任务！
进程是程序的一次动态执行过程，它对应了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到消亡的过程线程是比进程更小的执行单位。一个进程在其执行过程能够中，可以产生 多个线程，形成多条执行线索。每条线索，即每个线程也有它自身的产生、存在和消亡过程，也是一个动态的概念
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;（可以正确编译）
写一个程序,把一个文件的数组按对角线做对称变换,并输出!
一个正方形里面全数字,写一个程序,成对角线转变! 我做的这个是3行3列的对角互换，也许转换规则不一样
public class testMain {
public static voidmain(String[] args) {
inta[][]=new int[3][3];
intc=1;
//初始化数据
for(inti=0;i<3;i++){
for(intj=0;j<3;j++){
a[i][j]=c++;
}
}
System.out.println(“转换之前：”);
for(inti=0;i<3;i++){
for(intj=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(intj=0;j<3;j++){
if((i+1<3&&j+1<3)&&i==j&&i!=0&&i!=3-i){
inttemp=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(inti=0;i<3;i++){
for(intj=0;j<3;j++){
System.out
print(“a["+i+"]["+j+"]=”+a[i][j]+” “);
}
System.out.println(“\n”);
}
}
}
再SSH框架中，用流程表示处理过程。从Request, Response
人民币小写转成大写，写个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;
}
}
针对一个分期付款，总期为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());
}
}
用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);
}
}
}
SSH的优点和缺点
优点： ssh把数据库，实体，配置都整合，封装
层次的结构（偏于mvc模式）
而且框架的融合，代码的耦合都很不错
对于编程的持续化，扩展化，维护化都很棒 ，SSH已经把底层实现封装好了，开发人员可以更专注于业务处理，
缺点： 出现错误容易搞的复杂
如果某个框架不是很熟悉的话（特别是spring）那就很麻烦
运行速度比较慢
用JDBC来实现访问数据库记录可以采用下面的几个步骤：
1、通过驱动器管理器获取连接接口。
2、获得Statement或它的子类。
3、限制Statement中的参数。
4、执行Statement。
5、查看返回的行数是否超出范围。
6、关闭Statement。
7、处理其它的Statement
8、关闭连接接
overload和override的区别
override是方法重载，用在同一个类中，是几个方法的名字相同，返回值相同，但是参数列表不同，举例来说就像构造函数，可以后多个构造函数，并且每个的参数列表都不同，这样可以用多种方式构造对象。
overload是方法覆盖，用在父子类中，是方法名字相同，参数列表也相同，声明形式都相同，但是子类方法的权限不允许小于父类，不允许抛出比父类更多的异常
最常见的runtimeexception运行时异常？
数字转换异常，类异常ClassCastExceptionNumberFormatException ArrayIndexOutOfBoundsException:数组越界 ClassCastException:类型转换错误
ArithmeticException：算术错误，典型的就是0作为除数的时候。IllegalArgumentException：非法参数 IndexOutOfBoundsExceptionNullPointerException
SystemException ArrayStoreException
描述工厂模式和单例优缺点 举例在什么情况下用。
单例 保证一个类只有单一的实例，也就是说你无法通过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接口实例
}
}
创建一个序列号,从1000开始,每次增加1,最大到999999
create sequence newstudnoincrement by 1
start with 10001 maxvalue 99999
设计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(); } } } }
十六进制的216转换十进制是多少：
216是16进制，转10进制:
＝2*16^2+1*16^1+6*16^0
=512+16+6
=536
Java中的XML解析方式： dom和jdom解析
Java中处理XML文档的标准API有两种，即XML的简单API（SAX，Simple APIfor 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 操作符而不故弄玄虚使用复杂的工厂化模式，使对象操作即便对于初学用户也很方便。
UML几种图及用途？
单一的图形不可能包含系统所学的所有信息，更不可能描述系统的整体结构，所以系统通常是从多个不同的方面来描述的，分别对应UML的几种视图：
用例视图–从使用者角度描述系统功能
逻辑视图—描述系统内部如何实现
组件视图—描述系统有哪些组件/模块构成
并发视图—描述系统内部的通信与并发问题
配置视图—描述系统软硬件的配置与位置关系
用例图—描述系统的参与者与用例之间的关系
类图—描述系统中的概念及它们之间的关系
对象图—描述系统中实例及它们之间关系
状态图—描述系统中对象所具备的状态，及触发状态改变的事件
时序图—描述对象之间发送消息的时间顺序
协作图—描述对象之间协作关系
活动图—描述执行过程中涉及的活动及状态变化
组件图—描述系统组件之间的关系
配置图—描述系统的硬件及软件的物理结构
列举你接触过的框架，说明特点和原理
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中受益。
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 组件很好的耦合。
你对面向对象思想的理解？
面向对象(ObjectOriented,OO)是当前计算机界关心的重点，它是90年代软件开发方法的主流。面向对象的概念和应用已超越了程序设计和软件开发，扩展到很宽的范围。如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。
面向对象的特征
(1)对象唯一性。
每个对象都有自身唯一的标识，通过这种标识，可找到相应的对象。在对象的整个生命期中，它的标识都不改变，不同的对象不能有相同的标识。
(2)分类性。
分类性是指将具有一致的数据结构(属性)和行为(操作)的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。
(3)继承性。
继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。
继承性是面向对象程序设计语言不同于其它语言的最重要的特点，是其他语言所没有的。
在类层次中，子类只继承一个父类的数据结构和方法，则称为单重继承。
在类层次中，子类继承了多个父类的数据结构和方法，则称为多重继承。
在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重性。
采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。
(4)多态性(多形性)
多态性使指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。
多态性允许每个对象以适合自身的方式去响应共同的消息。
多态性增强了软件的灵活性和重用性。
数组和链表的理解，及优缺点？
链表是一种常见的数据组织形式，它采用动态分配内存的形式实现。需要时可以用new分配内存空间，不需要时用delete将已分配的空间释放，不会造成内存空间的浪费。
A 从逻辑结构来看
A-1. 数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。
A-2. 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）
B 从内存存储来看
B-1. (静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小
B-2. 链表从堆中分配空间, 自由度大但是申请管理比较麻烦.
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
数组中的数据在内存中的按顺序存储的，而链表是随机存储的！
要访问数组中的元素可以按下标索引来访问，速度比较快，如果对他进行插入操作的话，就得移动很多元素，所以对数组进行插入操作效率很低！
由于连表是随机存储的，链表在插入，删除操作上有很高的效率（相对数组），如果要访问链表中的某个元素的话，那就得从链表的头逐个遍历，直到找到所需要的元素为止，所以链表的随机访问的效率就比数组要低
数组在内存中开辟连续的一块区域，如果一个数据要两个内存单元，一组5个数据10个单元就够了，无需标记其地址，因为数组定义时候标顶了第一个原许的地址，其他四个都知道了。
链表可可以是连续的，也可以是不连续的，但一般都是不连续的，尽管在内存中是连续的，我们也不把他当作是连续的，而是把他当作是不连续的，因为如果把他当作是连续的，不如当作是数组了，在某些情况下。一链5个数据，如果每个数据本身用2个内存单元，那么10个单元是不够的，因为每个数据都要表示出下个数据在哪里，所以一个数据本身用2个单元，再用1个单元表示此链下一个数据在什么地址。
写几个java.lang.Object类中的方法名称
equals(); toString(); getClass();hashCode(); clone() finalize() notify() wait() notify()
js中加VAR与不加VAR的区别？
在全局作用域中可以不使用var声明变量，但在声明局部变量时，一定要使用var语句.
加了var:在局部函数中加了var说明是局部变量,只对该函数起作用.
不加var:在局部函数中不加的话,说明是给这个全局变量重新赋值.其结果为重新赋值后的.
Struts 1的Action类与Struts 2的Action类区别？
Struts 1要求Action类要扩展自一个抽象基类。Struts1的一个共有的问题是面向抽象类编程而不是面向接口编程。
Struts 2的Action类实现了一个Action接口，连同其他接口一起实现可选择和自定义的服务。
Struts 1 Action类是单例类，因只有一个示例控制所有的请求。
Struts 2 Action对象每一个请求都实例化对象，所以没有程安全的问题。
jsp有哪些的动作？分别有什么作用？
答： jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。
用oracle写向mine表中差入miname字段？
ALTER TABLE MINE ADD MINNAME VARCHAR2(10);
oracle有哪几个对象？
Oracle数据库对象有表、索引、视图、同义词、序列、存储过程、触发器、PL/SQL块等
在oracle中，有4个大对象（lobs）类型可用
分别是blob,clob,bfile,nclob。
定义两个变量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[]){
newtestMain().test(10,13);
}
}
题目：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.01Transitional//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><ahref=””> xiaoxin</a> </td>
</tr>
</table>
</td>
</tr>
</table>
</body>
</html>
办公自动化系统用到的技术，分哪些层，有哪些包
使用技术:DWR +Struts + Hibernate + Spring+Ajax+JavaScript
系统架构分为: View层、WEB层、Serivce层、DAO层、持久层(po层)
解释下mvc，客户端的请求被发送到哪?
.jsp是v层(视图层view) Servlet是c层(控制层,Control)Bean Bin都是M层(后台类,Model)
m层(模型层)
使用了哪些数据库事务?
BeginTransaction、Commit 和 Rollback
.
对数据库的访问是怎么实现的
将对持久层数据库的基本添加，修改，查找等操作提取到BaseDAO中,采用JavaBean对数据进行封装，以便对持久层的数据能够很好的处理，实现BaseDAO设计对数据库访问的便捷。业务组件通过DAO 的委托接口调用DAO对象，使得上层组件不 直接依赖于DAO的实现类.
回答步骤：
1.回答什么是抽象类、什么是接口。
2.回答抽象类和接口各自特点的区别。
3.回答他在应用场合的区别.
答：
含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
<<回答了什么是抽象类、什么是接口>>
下面比较一下两者的语法区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为publicabstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
<<对比了抽象类和接口各自特点>>
下面接着再说说两者在应用上的区别：
接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约，对架构组件进行解藕命名其组件实现依赖于抽象而不依赖于实现。而抽象类在代码也可以在架构设计上实现方面发挥作用，可以实现代码的重用。如果对一个组件接口的实现可以通过抽象类实现方法体，再通过子类进行派生，选择重写实现，这也是一种适配器模式的应用。
<<架构上的作用>>
数据库优化的方案
建立主键，为数据库创建索引，建立存储过程，触发器，可提高查询速度。
冒泡
public static void Bubble(int a[]){
for(inti=0;i<a.length-1;i++){
for(intj=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];
}
}
}
}
常用的设计模式有哪些？并写出一段程序代码
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;
}
}
数据库有哪几种结构？
从数据管理的角度看，数据库通常采用三级模式结构，这是数据库管理系统的内部结构；从数据库最终用户的角度看，数据库的结构可分为集中式结构、分布式结构、客户/服务器结构、并型结构，这是数据库的外部的体系
css是什么？ABSTRACT是什么意思？（层叠样式表，抽象）
Css:（层叠样式表，抽象）
abstract 修饰符可以用于类、方法、属性、事件和索引指示器（indexer），表示其为抽象成员，abstract 不可以和 static 、virtual 一起使用 声明为 abstract 成员可以不包括实现代码，但只要类中还有未实现的抽象成员（即抽象类），那么它的对象就不能被实例化，通常用于强制继承类必须实现某一成员
你对Oracle有哪些了解？ （大型数据库，安全性高，稳定性高，功能强大，效率低，价格贵，操作麻烦）
你大学所学习的哪些课程？（会哪些JAVA技术？学过 C语言，c++,c#,java）
BBS论坛运用了那些技术，如果你单独开发需要多久，你能够独立完成整个代码的编写吗？（jsp技术，ajax技术，通信技术，）
你对博客网有什么认识（典型的网络新事物，指网上写作的一种特定形式和格式。由按时间倒序排列的文档组成的栏目，两侧通常还可以有补充材料，频繁更新，一般大量使用链接）
测试覆盖最强的是__d______,最弱的是____c___
A.条件覆盖 B.条件及判定覆盖 C.语句覆盖 D.条件组合覆盖
DFD是面向__c____分析方法的描述工具（DFD数据流程图）
A.数据结构 B.数据流 C.对象 D.构件
从终端用户的角度来看,事务是一个__B_____
A.对象 B.原子 C.操作 D.子程序
构造器是否可以被重写？ 不能
char是否可以装一个汉字？可以
public class Test {
public static voidadd(Integer i){
intval=i.intValue();
val+=3;
i=newInteger(val);
}
public static voidmain(String[] args) {
Integeri=new Integer(0);
add(i);
System.out.println(i.intValue());
}
}
打印的结果是0
outmermory是个什么问题？你是怎么解决的？
内存溢出 解决方法：手动设置Heap size修改TOMCAT_HOME/bin/catalina.bat
在”echo “Using CATALINA_BASE: $CATALINA_BASE””上面加入以下行：
JAVA_OPTS=”-server-Xms800m -Xmx800m -XX:MaxNewSize=256m”
&和&&的区别
&,按位与,是位运算符
&&,与，是逻辑运算符
数组有没有length()这个方法，String有没有length()这个方
数组没有length()方法，但有length属性
String有length()方法。
String s=new String(“xyz”)创建了几个对象
2个string对象,一个是=null的s，一个是=”xyz”的string
谈谈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的特点，做了相应的变化与扩展
域名格式要求
英文26个字母和10个阿拉伯数字以及横杠”－”可以用作域名。字母的大小写没有区别；每个层次最长不能超过26个字母；首字或结尾字不能是”.”和”-”；域名不能包括有空格；中文暂时不能用作域名。
AjAX有什么好处？
用于需要查询数据库才能做的页面校验,再比如实时刷新,再比如良好的用户界面以及快速的响应等等 无刷新、减少网络流量
Webservice 有什么好处?
跨平台的可互操作性 跨防火墙的通信 应用程序集成 软件和数据重用
JAVA 的缓冲机制？ BufferdStream
如何在javascript中实现继续？首先js是单线程的，现在基本除了XHR的callback可以另开一个线程以外，还无法实现多线程，其次timeout是在本次js代码运行完开始计时timeout的，所以在一个耗时的函数之外timeout或者interval一个函数运行本身就是荒谬的，ie下面alert，js函数执行也会阻塞interval执行
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的效率会快点（因为他从缓存中查询）
连接池的原理
j2ee 服务器启动时会建立一定数量的池连接，并一直维持不少于此数量的池连接。当客户端程序需要连接时，吃驱动程序会返回一个未使用的池连接并将其标记为忙。如果当前没有空闲连接，池驱动就建立一定新的 连接
用javascript编写脚本小程序，实现点击全选（）
functionselectAll(){
varitem = 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}”>
<inputtype=button value=”全选” onclick=”selectAll()”>
说一下垃圾回收的原理，可以直接从内存中回收吗?
垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象和进行清楚回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收
java的异常有哪几种，有什么区别。
第一种方式：直接在函数头中throwsSomeException，函数体中不需要try/catch
第二种方式：使用try/catch，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常
第三种方法：使用try/catch/finally，在catch中进行一定的处理之后（如果有必要的话）抛出某种异常
通过部署描述文件（web.xml）可以配置哪些功能？
监听器。。过滤器。。也可以用来验证XML文件的正确性
说一下mvc原理，（关于mvc）
1、模型（Model）
模型是应用程序的主体部分。模型表示业务数据，或者业务逻辑.
2、视图（View）
视图是应用程序中用户界面相关的部分，是用户看到并与之交互的界面。
3、控制器（controller)
控制器工作就是根据用户的输入，控制用户界面数据显示和更新model对象状态。
MVC 式的出现不仅实现了功能模块和显示模块的分离，同时它还提高了应用系统的可维护性、可扩展性、可移植性和组件的可复用性
servlet 在MVC中充当的角色: 中心控制器
什么是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最大的优点就是可以在任何地方进行操作而不用安装任何专门的软件。只要有一台能上网的电脑就能使用，客户端零维护。系统的扩展非常容易，只要能上网，再由系统管理员分配一个用户名和密码，就可以使用了。甚至可以在线申请，通过公司内部的安全认证（如ＣＡ证书）后，不需要人的参与，系统可以自动分配给用户一个账号进入系统。
页面中使用javascript的利与弊？（益端：能减少一些简单的逻辑业务，提高页面的效率，弊端：对于有些不能识别Javascript的浏览器存在一定的安全隐患）
在Liniux/Uinix下创建一个角色帐号，自己拥有一切权限，系统用户拥有访问权限，其他用户没有任何权限.
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 voidmain(String[] args) {
try{
Stringdriver = “oracle.jdbc.driver.OracleDriver”;
Stringurl=”jdbc:oracle:thin:@localhost:1521:yf”;
Stringusername = “scott”;
Stringpassword = “tiger”;
DriverManager.registerDriver(new oracle.jdbc.OracleDriver());
Connectioncon = DriverManager.getConnection(url, username, password);
PreparedStatementstm = con.prepareStatement(“select sysdate from dual”);
ResultSetrs =stm.executeQuery();
while(rs.next()){
System.out.print(rs.getString(1));
}
}catch(Exceptione){
e.printStackTrace();
}
}
}
数据库索引的优点和缺点
一、为什么要创建索引呢（优点）？
这是因为，创建索引可以大大提高系统的性能。
第一， 通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二， 可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
第三， 可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四， 在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五， 通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。
二、建立方向索引的不利因素（缺点）但是，为表中的每一个列都增加索引，是非常不明智的缺点：
1 创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
2 索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
3 当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。
struts2.0中几种常用的标签
<s:if test=””></s:if> <s:formaction=””></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>
介绍下spring
Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯.Spring的架构基础是基于使用JavaBean属性的Inversion of Control容器是一个解决了许多在J2EE开发中常见的问题的强大框架，还提供了可以和总体的IoC容器集成的强大而灵活的MVCweb框.
介绍下ajax
AJAX全称为”Asynchronous JavaScript and XML”（异步JavaScript和XML），是指一种创建交互式网页应用的网页开发技术
介绍下hibernate
Hibernate是连接 Java 应用程序和关系数据库的中间件。它对 JDBC API 进行了封装，负责Java对象的持久化。在分层的软件架构中它位于持久化层，封装了所有数据访问细节，使业务罗基层可以专注于实现业务逻辑
servlet和jsp页面过滤器Filter的作用及配置
过滤器可附加到一个或多个servlet或JSP页面上，并且可以检查进入这些资源的请求信息过滤器要好处。1它以一种模块化的或可重用的方式封装公共的行为 2 利用它能够将高级访问决策与表现代码相分离
学JAVA的都看了什么书？
基础很差的人我建议用那本JavaSE6.0编程指南 《最新Java2 核心技术 卷1、卷2》了，不要怕代码难懂，这个一定要克服，当然某些代码(比如经常提及的画小球、你又不是搞图象的:))就可以跳过去。这当中可以穿插阅读《Java实效编程百例》，最后建议大家阅读《Java编程思想》 thinking in JAVA第三版中文版 Core Java（java核心技术）
函数和过程的区别？
过程和函数区别如下：
1、标识符不同:函数的标识符为FUNCTION，过程为：PROCEDURE。
2、话法不同：函数中一般不用变量形参，用函数名直接返回函数值；而过程如有返回值，则必须用变量形参返回。
3、函数在定义时一定要进行函数的类型说明，过程则不进行过程的类型说明。
4、调用方式不同:函数的调用出现在表达式中，过程调用，由独立的过程调用语句来完成。
5、过程一般会被设计成求若干个运算结果，完成一系列的数据处理，或与计算无关的各种
操作；而函数往往只为了求得一个函数值。
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的方法.
将字符串str（例：”abcrepefd”）中的”rep”部分替换成”with”字符串(不能用jdk自带的replace方法)
答案如下:
public void replace(String str,String rep,String with){
try{
int i =str.indexOf(rep);
Strings1 = str.substring(0, i);
Strings2 = str.substring(i, rep.length()+i);
Strings3 = str.substring(rep.length()+i, str.length());
s2= with;
Stringmes = s1+s2+s3;
System.out.println(“替换前：”+str);
System.out.println(“替换后：”+mes);
}catch(Exceptione){
System.out.println(“字符串”+str+”中不含有”+rep+”字符串！”);
}
}
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);
}
}}
1到11相加是奇数还是偶数?
偶数
一个圆上有6个点，可以连多少条直线？
15条线段
Stack堆栈，实现进栈，出栈
package t1;
public class mystack {
private Object[]data;
private int top=-1;
private int size;
public mystack()
{
data=newObject[5];
size=5;
}
public mystack(intsize)
{
data=newObject[size];
this.size=size;
}
public voidpush(Object obj)
{
if(this.isfull())
{
return;
}
top++;
data[top]=obj;
}
public Object pop(){
if(this.isempty())
{
returnnull;
}
Objectobj=data[top];
top–;
returnobj ;
}
public booleanisfull()
{
if(top==data.length)
{
returntrue;
}
else
{
returnfalse;
}
}
public booleanisempty()
{
if(top==-1)
{
returntrue;
}
else
{
returnfalse;
}
}
}
每周的工作效率要提高24％，每周工作6天，那么每天工作效率要提高多少？（6％，4%,24%）
答：24%
.前一天是星期一，又是第二个工作日，那么今天是星期几？
答：星期三
Hibernate 中的HQL和 criteria的区别？
答：
1.QBC(Query by Criteria)查询对查询条件进行了面向对象封装，符合编程人员的思维方式;
2．HQL(Hibernate Query Language)查询提供了更加丰富的和灵活的查询特性，在涵盖Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更加面向对象的封装;
Web service 是什么？它是采用什么通信机制，它的通信协议是什么？
答： Webservice是跨平台，跨语言的远程调用技术;
它的通信机制实质就是xml数据交换;
它采用了soap协议（简单对象协议）进行通信
Struts 是怎么实现MVC的？
Struts提供MVC三层模式:
MVC就是 model view controller.
1、view视图层一般运用jsp或者html进行实现，展现给用户看；
2、controller控制层struts有个文件叫struts-config.xml，该文件里面定义个处理后的跳转页面；
3、model模型层理解不深，可能是逻辑模型
j a v a 对象初始化顺序
1.类的初始化（initialization class & interface）
2.对象的创建（creation of new class instances）
顺序：应为类的加载肯定是第一步的，所以类的初始化在前。大体的初始化顺序是：
类初始化 -> 子类构造函数 -> 父类构造函数 -> 实例化成员变量 -> 继续执行子类构造函数的语句
一个字符串中可能存在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();
}
写一个方法，传入一个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); //整数大小自己比较吧
}
．类的工厂模式怎么实现？
首先确定这些类的父类或共同的接口，担任抽象产品的角色，比如
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);
}
}
Web容器里面的对象存活周期？
Web容器里面的对象的存活周期由JVM控制。某个对象有容器负责实例化或应用负责实例化，如果某个对象得不到任何引用，
则由JVM的垃圾收集器负责销毁。
struts2中action的对象的生命周期？
用spring来控制action的生命周期Struts2支持通过拦截器堆栈（Interceptor Stacks）为每一个Action创建不同的生命周期。堆栈能够根据需要和不同的Action一起使用。
annotation的使用方法和用途主要分为几类？
答 1、内建Annotation——Java5.0版在java语法中经常用到的内建Annotation：
2、开发者自定义Annotation：由开发者自定义Annotation类型；
3、使用第三方开发的Annotation类型
说说你对IOC的理解
答：1.控制反转（Inversion of Control，英文缩写为IoC）是一种设计模式；
2.控制反转还有一个名字叫做依赖注入（DependencyInjection）。简称DI；
应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。
从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容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）
如何理解struts,jsf,struts2的工作原理
答：1.JSF和STRUTS工作原理大致相同,有一个中心控制器即一个servlet,
2.JSF:用一个JAVABENA里的属性绑定页面表单值,而struts用ActionFrom对应表单值;
3.JSF在一个JAVABEAN里处理从页面送来的个值,而struts则是把actionFrom的值送给对象的ACTION来处理,两者都是MVC模式的.
整合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的控制之下。无疑，这是最灵活的一种整合方式。
springframework与struts的不同之处
答：1. SpringFramework是一个采用了反转控制（InversionofControl,Ioc）策略的基于J2EE 的轻量级应用框架。核心是IoC容器，对于其它应用，如数据库访问，日志等，SpringFramework多使用现有的、成熟的框架。它采用了模块化的方式，各模块可以共同使用，也可以单独使用其中的一个模块。
struts2利用成熟的struts1和webwork整合使之操作更加方便;
spring使用了哪些设计模式，这样用有什么好处？
Dao模式通过实现DAO,我们达到了解耦合的目的,使的程序更加的健壮,但复杂性增加了；
spring对多种ORM 框架提供了很好的支持，结合事务管理描述spring中使用Hibernate的方法。
答：spring中采用aop模式注入hibernate的sessionfactory和事务管理,在dao中调用.Spring集成hibernate有两种方式,一是dao层只与hibernate有关, 不使用任何spring 的api, 然后把dao注入到ioc容器.二是使用spring的hibernateDaoSupport.事务管理也可以只使用hibernate的事务管理.
struts中action是全局的还是局部的，为什么？
是全局
Hibernate有哪几种查询数据的方法？
答:hibernate在查询方式上有三种方式:HQL SQL QBC
http和ftp的默许使用端口是什么？
答：http：80 ftp：21
Ping命令的作用？
答：Ping命令的主要作用是通过发送数据包并接收应答信息来检测两台计算机之间的网络是否连通。当网络出现故障的时候，可以用这个命令来预测故障和确定故障地点
构造器的名能不能和类的名字相同？
答：可以！并且一定要相同
在一个主方法类可不可以调用一个非静态的方法？
答：可以
一个类中可不可以有2个公共的方法？
答：可以
Internet的最顶级的商业域名叫什么？
答： .com
GC是什么，为什么要使用它？
垃圾回收 (garbagecollection, GC) 一个跟踪过程，它传递性地跟踪指向当前使用的对象的所有指针，以便找到可以引用的所有对象，然后重新使用在此跟踪过程中未找到的任何堆内存。公共语言运行库垃圾回收器还压缩使用中的内存，以缩小堆所需要的工作空间因为你没有足够多内存,并且,你挺懒,不去自己清理内存,所以就有了 GC
编程题:有一个数据文件:123 34 17 651234 345….这些数据都是随机产生的,编写程序读出该文件.并将其以从大到小的顺序输出到另一个文件中.
public void readtext(){
File file = newFile(“D:\test.txt”);
List list= newArrayList();
try {
BufferedReaderbr=new BufferedReader(new FileReader(file));
Stringdata = “”;
Stringline = null;
while( (line = br.readLine()) != null) {
data= data.concat(line);
}
StringTokenizerstoken = new StringTokenizer(data, ”“);
while(stoken.hasMoreTokens()) {
inti = Integer.parseInt(stoken.nextToken());
list.add(i);
}
} catch(Exceptionex) {}
String[] str = newString[list.size()];
for(inti=0;i<list.size();i++){
str[i]=list.get(i);
}
Object iTemp= null;
for(inti=1;i<list.size();i++) {
for(intj=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(inti=0;i<str.length;i++){
result+=str[i]+” “;
}
//将result写入另外一个文件即可。
}
从一到十九共十九个数,打印出利用这十九个整数任意多个相加等于20所以可能性,每个数字在同一个算式中只出现一次.
public void test(){
Integer[] a = newInteger[19];
for(inti=1;i<20;i++){
a[i-1]=i;
}
for(int i=0;i<18;i++){
for(intj=18-i;j<18;j++)
if(a[i]+a[j]==20)
System.out.println(a[i]+”+”+a[i+1]+”=”+20);
}
}
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文件执行时发生的错误和异常
写几个线程安全类，不安全的，支持排序的类名？
线程安全类：Vector 、Hashtable、
不安全的类：ArrayList、HashMap、Linkedlist
支持排序的类：TreeSet
JDK也提供一个对集合类进行线程安全处理的类Collections类，可以对一些非结程安全的类进行同步处理。
将ISO8859-1字符串转成GB2312编码，语句为？
String s=new String(text.getBytes(“iso8859-1″),”gb2312″).
说出你用过的J2EE标准的WEB框架和他们之间的比较？
答：用过的J2EE标准主要有：JSP&Servlet、JDBC、JNDI、JavaMail、JTA、XML、RMI、WebServices等。这些标准主要提供了对于WEB框架的全方位的支持与整合，通过Web容器来管理这些中间件，使得Web框架开发实现者，只需注重应用系统的实现，而不必关注与业务不相关的逻辑，大大降低了开发成本和开发周期。同时这些中间年良好的扩展性、平台不相关性，也使得这个标准成为大多数Web框架所采用。
类库有哪些？
Xerces ，JDOM dom4j XOM jConfig XStream
<jsp:include>与<%@include>的区别
动态INCLUDE用jsp:include动作实现 它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。
静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面，不能实现参数共享。
怎么样手动启动Oracle数据库？
答：第一步：启动Oracle在OS下的监听程序。第二步：启用OS下的实例服务。第三步打开数据库。
WEB SERVICE 的理解
Web Service主要是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。 Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以WebService可以在任何支持这些标准的环境（Windows,Linux）中使用。注：SOAP协议（SimpleObject Access Protocal,简单对象访问协议）,它是一个用于分散和分布式环境下网络信息交换的基于XML的通讯协议。在此协议下，软件组件或应用程序能够通过标准的HTTP协议进行通讯。它的设计目标就是简单性和扩展性，这有助于大量异构程序和平台之间的互操作性，从而使存在的应用程序能够被广泛的用户访问。
写一个递归编程
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));
}
AWT和Swing的区别？
一般swing组件是从awt组件扩展的,swing是轻量组件 而awt是重量组件， AWT是比较依赖操作系统组件，功能少，Swing不依赖，组件多，功能多 窗口风格更多样化 Swing是由纯JAVA CODE所写的，解决了JAVA因窗口类而无法跨平台的问题，使窗口功能也具有跨平台与延展性的特性，而且SWING不需占有太多系统资源，并且一些组件也采用一些更开放式的开发方式，支持更多的扩展。
哪几个方法可以实现一个线程？
一种是声明 Thread 的子类,重载 Thread 类的方法 run。 另一种途径是声明一个类，该类实现 Runnable 接口。然后再实现方法 run。
STOP()和SUSPEND()不推荐使用的原因？
因为stop本质上就是不安全的。停止线程会导致解锁它已锁定的所有监视程序。suspend从本质上就是易于死锁的一种操作。
JAVA事件有哪些模式？
事件直接驱动模式。它的第一个要求就是性能的要求，需要直接而且快，是必须经常使用的，主要适合于迅速处理前台的命令，往往是系统架构的重要部分，也是流程控制的主要模式。2.监控式事件模式是借助第三者来监控和触发事件，特点是： 有一个观察者置身事外在定期独立运行着。
用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>
<%
uml三要素.
事物、关系、图
EJB规范规定的EJB禁止的操作有哪些？
1.不能操作线程和线程API(线程API指非线程对象的方法如notify,wait等)，
2.不能操作awt，
3.不能实现服务器功能，
4.不能对静态属生存取，
5.不能使用IO操作直接存取文件系统，
6.不能加载本地库.，
7.不能将this作为变量和返回，
8.不能循环调用。
TRUNCATE和DELETE有以下几点区别？
1、TRUNCATE在各种表上无论是大的还是小的都非常快。如果有ROLLBACK命令DELETE将被撤销，而TRUNCATE则不会被撤销。
2、TRUNCATE是一个DDL语言，向其他所有的DDL语言一样，他将被隐式提交，不能对TRUNCATE使用ROLLBACK命令。
3、TRUNCATE将重新设置高水平
http协议，tcpip协议解释
答：HTTP：超文本传输协议（Hypertext Transfer Protocol）
TCP/IP（Transmission Control Protocol/Internet Protocol)的简写，中文译名为传输控制协
//编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。
//但是要保证汉字不被截半个，如”我ABC”4，应该截为”我AB”，输入”我ABC汉DEF”，6应该输出为”我ABC”而不是”我ABC+汉的半个”。
public static void main(String[] args)throws Exception{
Stringstr = “我a爱中华abc def’;
Stringstr = “我ABC汉”;
intnum = trimGBK(str.getBytes(“GBK”),5);
System.out.println(str.substring(0,num));
}
public static inttrimGBK(byte[] buf,int n){
intnum = 0;
booleanbChineseFirstHalf = false;
for(inti=0;i<n;i++)
{
if(buf[i]<0&& !bChineseFirstHalf){
bChineseFirstHalf= true;
}else{
num++;
bChineseFirstHalf=false;
}
}
returnnum;
}
java程序每天12点打印”hello”
public static void main(String[] args) {
Date date = newDate();
System.out.println(date.getHours());
while (true) {
while(date.getHours() == 12) {
if(date.getMinutes() == 0) {
if(date.getSeconds() == 0) {
System.out.println(“hello world!”);
}
}
}
}
}
编程题：读取一个文件在控制台打印出来
File file = new File(“E:\\课件\\二期课件\\Java\\T09src\\JRadioButtonDemo.java”);
long
file_length= file.length();
try{
//输入流
FileInputStreaminput = new FileInputStream(file);
byteb_data [] = new
byte[(int)file_length];
input.read(b_data);
System.out.println(newString(b_data));
input.close();
}catch (FileNotFoundException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}catch (IOException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
解析XML的方法及对它的了解？
答：:有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
你所熟悉的开源组件和框架，简单介绍下
答：FileUpload、 POI、WebWork、Struts1/2、hibernate、spring、Ajax、Ibatis
要求WEB2。0是什么东西？
Web1.0 的主要特点在于用户通过浏览器获取信息。Web2.0 则更注重用户的交互作用，用户既是网站内容的浏览者，也是网站内容的制造者。所谓网站内容的制造者是说互联网上的每一个用户不再仅仅是互联网的读者，同时也成为互联网的作者；不再仅仅是在互联网上冲浪，同时也成为波浪制造者;在模式上由单纯的”读”向”写”以及”共同建设”发展；由被动地接收互联网信息向主动创造互联网信息发展，从而更加人性化
webservice和soap的区别？
Web ServiceWeb Service是基于网络的、分布式的模块化组件，它执行特定的任务，遵守具体的技术规范，这些规范使得Web Service能与其他兼容的组件进行互操作。
SOAP即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。 它是Webservice所采用的主要协议之一
。
介绍几种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规范且比绝大多数商业应用软件服务器要好。
ThreadLocal在项目中的实际意义？
ThreadLocal和其它同步机制相比从另一个角度来解决多线程的并发访问，它为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。还提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal
ThreadLocal可以大量减少参数的传递，可以使代码简洁，但一个线程会绑定多个自己定义的局部对象，ThreadLocal是抽象在线程上的对象创建工厂，目前的Tomcat5使用了线程池，一个线程处理一个request，这样ThreadLocal对象可以抽象的绑定在request生命周期，不会存在线程危机，而且线程池也平衡了这些ThreadLo
不同的数据库里面有相同的表实现同步更新（从多方面考虑）
–用触发器可以实现两个数据表之间的数据同步更新
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 。
ejb是基于哪些技术实现的，和javabean的区别？
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现 EJB是一个关于用JAVA语言开发的可部署的服务器端组件的组件体系结构。它是一个技术协议，能使组件运行于任何应用服务器,专门用来解决商务问题JAVABEANS是JAVA类，是由属性、事件和方法组成的JAVA组件，它们可以用来组成JAVA应用程序
适配器模式解释：
把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端
Gc是什么，为什么要有GC
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。
switch可以作用于byte吗？可以作用于long，可以作用于string 吗？
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。
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(newTest().test());;
}
static int test()
{
int
x = 1;
try
{
return
x;
}
finally
{
++x;
}
}
}
———执行结果 ———
1
运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。
两个对象值相同(x.equals(y)== true)，但却可有不同的hashcode，这句话对不对?
对。
如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。
如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，我们没有理由不实现，通常都会去实现的。
当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?
引用传递。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。
在Oracle中数据库中的一个表中，这个表没有主键id也没有特定标示来查数据，怎么查？
[题意不明：考虑从面试者的角度能是考伪列和rownum的内容]
考虑使用Oracle的伪列rowid来查询
概述反射和序列化
反射Reflection 是Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查;能直接操作程序的内部属性和方法。
简单来说序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化，我们可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。而把Java对象转换为字节序列的过程称为对象的序列化。
简述WebService和Remoting的特点和运用场景
Web Service主要是为了使原来各孤立的站点之间的信息能够相互通信、共享而提出的一种接口。 Web Service所使用的是Internet上统一、开放的标准，如HTTP、XML、SOAP（简单对象访问协议）、WSDL等，所以Web Service可以在任何支持这些标准的环境（Windows,Linux）中使用。Remoting 依赖于特定语言的远程调用机制，比如Java的RMI/IIOP它的设计目标就是简单性和扩展性，这有助于大量异构程序和平台之间的互操作性，从而使存在的应用程序能够被广泛的用户访问。
dao 是什么及作用
DAO组件主要提供数据库访问操作，主要是对各自数据表的CRUD方法，在一般设计过程中为了考虑松耦合的问题，业务逻辑层中不应当牵涉到任何持久层实际操作，所以可以将各数据源表的操作特性封装到DAO组件中去，这样增强了系统的可读性、可维护性。
Inserted和deleted的含义？
SQLServer的DML触发器中两个临时表
inserted表反映插入或更新操作时插入的记录
deleted表反映删除或更新操作时删除的记录
3个框架在项目在项目当中的用，basedao是用来做什么的。
DAO组件主要提供数据库访问操作，针对不同数据源表进行了封装，这样可以提供其它层的访问接口，使得组件之间解耦，而BaseDAO是这些所有不同DAO的公共特性的封装，针对一些可以进一步进行细化的DAO组行的进一步抽象，使组件的移值性更为灵活。
Orace中除了数据库[XX]备份，还有什么方法备份？
1.导出／导入（EXP/IMP）。
2.热备份。 热备份是在数据库运行的情况下，采用archivelog mode方式备份数据库的方法。所以，如果你有昨天夜里的一个冷备份而且又有今天的热备份文件，在发生问题时，就可以利用这些资料恢复更多的信息。热备份要求数据库在Archivelog方式下操作，并需要大量的档案空间。一旦数据库运行在archivelog状态下，就可以做备份了。
3.冷备份。冷备份发生在数据库已经正常关闭的情况下，当正常关闭时会提供给我们一个完整的数据库。冷备份时将关键性文件拷贝到另外的位置的一种说法。
jsp与servlet中请求转发的区别
forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址，但此转发是连续的转发，在转发过程中请求参数也连续转发到目标地址中。
redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求。前者对请求是连续的，后者是重新发送一个新的请求，所以只能重新发送新的请求参数，原有的请求参数将不再连续到目标页面。
分页的优化需考虑哪些
sql语句的优化：ID排除法、三层嵌套等
表的优化：适当使用索引
web运用程序的稳定、安全需要考虑哪些
Web服务器的性能考虑主要有：并发用户数、事务安全、负载均衡、时段流量、网络带宽
安全性：
关键数据的保护，例如用户数据等
功能服务的正常提供。
网站的防攻击能力
对异常灾害的恢复能力
程序性能：
响应请求并运行得出结果的平均时间
错误的检测和拦截
扩展性
问spring的AOP，mvc到底是怎么优化程序的结构？
SpringAOP主要提供了Pointcut、Aspects等以及它们如何被织入应用程序、代理的方式等等进行优化的控制。而Spring MVC里面前端控制器叫做DispatcherServlet。里面充当Action的组件叫做Controller，返回的视图层对象叫做ModelAndView，提交和返回都可能要经过过滤。从而提高程序可读性和稳定性。
笔试：1.LinkedList和ArrayList内部是如何实现的？new ArrayList（10）意思
ArrayList的内部实现是基于内部数组Object[]，所以从概念上讲，它更像数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更像一个链表结构，所以，它们在性能上有很大的差别。
new ArrayList（10）构造一个初始容量为 10 的空列表
定义一个变量，Var v=new Object (),用js编写的简便写法是什么？
var v = {};
网上购物系统的类图，用例图。
主要的类有：商品分类 商品 订单 订单项 商品评论
主要用例有：查看商品详情 发表评论 登录 注册 购物车管理 订单生成 查询订单等
给你一个整数类型的数组，按从小到大的顺序进行排列！
Array.sort(inta[]);//默认为升序排列
查询出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
把二叉树从小到大遍历出来怎么实现？
public
class Node {
public
int value;
public Node left;
public Noderight;
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;
returnright.find(value);
}else
{
if(left== null) return
false;
returnleft.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(inti=0;i<data.length;i++)
{
data[i]= (int)(Math.random()*100) + 1;
System.out.print(data[i]+ “,”);
}
System.out.println();
Noderoot = new Node();
root.value= data[0];
for(inti=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();
}
}
mysql分页怎么实现，oracle分页怎么实现，他们之间的区别？
Ajax是一个RIA应用技术，解决富Web客户端问题，提高用户体验的
jms是Java的消息服务系统，解决Java分布式应用消息异步通信
mysql中的limit关键字查询出指定区间的记录进行分页。
oracle中通过rownum来记录结果集记录编号实现分页
描述struts体系结构？对应各个部分的开发工作主要包含哪些？
按MVC设计的Web架构，
其中Model为ActionForm组件的设计
View为Struts标签的使用
Controller为Action组件的设计和ActionServlet的配置
组合优于继承。你是否同意这句话，并说明
继承和组合都可以实现代码的重用（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>
如何运行本地的EXE文件？
双击运行,或者在DOS窗口中通过命令运行
struts中的prepare怎么用？
首先Action组件实现Preparable接口的prepare()方法，在配置 Action组件时应用PrepareInterceptor拦截器。
Hrbernate的二级缓存讲述。
hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的时候，一级缓存就失效了。
二级缓存是SessionFactory级别的全局缓存，它底下可以使用不同的缓存类库，比如ehcache、oscache等。hibernate在执行任何一次查询的之后，都会把得到的结果集放到缓存中，缓存结构可以看作是一个hash table，key是数据库记录的id，value是id对应的pojo对象。当用户根据id查询对象的时候（load、iterator方法），会首先在缓存中查找，如果没有找到再发起数据库查询。
如果做个招聘网站性别只招男的，年龄20-30，如果不匹配就不能让他投简历，怎么实现？ 填身份证时如何让该人信息全部显示出来？
使用JavaScript做客户端检验，填身份证时使用Ajax获取人员信息；
软件的开发过程、以及角色？
软件立项 à 需求分析 à 概要设计 à 详细设计 à 编码测试 à 验收运行
| | | |
|————分析员 ———|————–程序员—————|————测试员——-|
Io流 InputStream与Reader的区别 ,怎样将字符流转换成字节流
InputStream 字节输入流、Reader字符输入流
OutputStreamWriter 是字符流通向字节流的桥梁
InputStreamReader 是字节流通向字符流的桥梁
启动线程调用那个方法 ？为什么要调用start（）方法？若调用run（）方法会出现什么情况？
面试题上有
Struts2.0 若在一个方法中返回的是null，表明什么?struts.xml还需要配置吗？为什么？struts有那些标签？struts.xml中有那些标签？
方法返回null，表示没有视图结果回应，当然自己通过流直接输出响应结果，则struts.xml只需对Action进行映射配置，而无须进行结果配置。
Hibernate 运行的流程？优缺点？为什么insert比select快？可以批量insert一些数据吗？
Hibernate应该是建立在JDBC基础上的一个开源的ORM映射框架，很好的封装了实体映射实现，提供友好的实体操作接口，以及基于HQL的查询接口，在开发中可以减少编写SQL相关代码，提高效率和减少出错。
以面向对象的方式操作数据库，进行增删改很方便，但执行复杂的查询时则很费事麻烦。
select查询可能需要执行多条SQL语句，牵涉到加载策略所以执行需要消耗很多时间，相比insert操作要慢些。
hibernate可批量insert一些数据，配置文件中设置hibernate.jdbc.batch_size参数，来指定每次提交SQL的数量。
sqlserver查询怎样取得JAVA虚拟机默认的编码方式？
可通过Charset.defaultCharset()来获取
智力题：
1、有一辆火车以15公里/小时从洛杉矶开往纽约，一辆火车以20公里/小时从纽约开往洛杉矶，一只鸽子以30公里/小时从洛杉矶开往纽约，鸽子和两辆火车同时出发，鸽子遇到火车转头，向另一辆火车飞，直到两辆火车相遇，问鸽子飞了多少公里？
假设洛杉矶到纽约的距离为s
那小鸟飞行的距离就是(s/(15+20))*30。
2、有两根不匀称的香，烧完1小时，问如何知道1 5分钟
把香称重，取出总重量的1/4
3一群人在一黑屋子，有黑白2种帽子，每人可以看其他人的帽子，至少1顶黑帽子。如果知道自己是黑帽子，打自己一巴掌。第一次开灯，无人，关灯。第二开灯，无人，关灯。第3次，听到劈劈啪啪的声音。问有几顶黑帽子。
什么是 联通图的生成树？
什么是哈夫曼树？什么是平衡二叉树？写一个深度优先排序，写一个广度优先排序？写出 C语言对链表HEAD的排序？
连通图的生成树——是连通图的一个极小连通子图，它含有图中全部顶点，但只有足以构成一棵树的n-1条边。
哈夫曼树又称最优树（二叉树），是一类带权路径最短的树。构造这种树的算法最早是由哈夫曼(Huffman)1952年提出，这种树在信息检索中很有用。
如果任意节点的左右子树的深度相差不超过1，那这棵树就是平衡二叉树。
哪些不是JAVA关键字：TRUE sizeof native是关键字
sizeof不是大写的TRUE不是
怎样知道给出的两条线段是否相交，用伪码实现。
假设线段AB,A(X1,Y1),B(X2,Y2);线段CD,C(X3,Y3),D(X4,Y4);
1。判断两斜率相等则不相交
2。若斜率不等
ORACLE数据库用到了哪些方面，怎样优化数据库。SQL语句过长时，怎样优化？
(1) 使用分区这种手段。所谓分区就是动态地将表中的记录分离到若干不同的表空间上，使数据在物理上被分割开来，便于维护、备份、恢复、事务及查询性能。
(2) 重建索引，及时回收那些未使用空间，提高空间利用率。
(3) 调整SGA参数
sql语句长：用存储过程！
JAVASCRIPT的一些常用东西：如提示框如何实现的：MVC
使用jQuery等第三方的插件Dialog即可，无需重复造轮子。
两个SQL语句 一个ArrayList里面存了一些Student对象，Student对象有Name和Age两人属性，此类里面有set和get方法，要求以Age来降序排序。
要求Student实现Comparable接口的compareTo()方法来按照age判断对象的大小，并且大于时返回-1，小于时返回1，相等则返回0。
有一些奇数和偶数，无序的，要求写一个方法，实现将所有的奇数放在全部的偶数前面
主要代码如下：主要采用快速排序的算法。
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]+ ” “);
}
你对工作流和表单的理解
一个工作流包括一组活动及它们的相互顺序关系，还包括过程及活动的启动和终止条件，以及对每个活动的描述。一个完整的工作流管理系统通常由工作流引擎、可视工作流设计、流程操作、工作流客户端程序、流程监控、表单设计工具、与表单的集成以及与应用程序的集成八个部分组成。工作流引擎作为工作流管理系统的核心部分，主要提供了对于工作流定义的解析以及流程流转的支持。
表单用来显示查询或输入的业务数据。
Classpath怎么设置和它的意义是什么？
比如，setCLASSPATH=C:\Java\jdk1.6.0_10\lib\dt.jar;.
设置class文件的搜索路径
用java写一个读取盘符的名字
new File(“”).getAbsolutePath().substring(0, 1);
Deprecated API 是什么意思？
deprecated是指已经过时，但是为了向前兼容起见仍然保留的方法，这些方法可能会在以后取消支持。你应当改用较新的方法。一般在API里面会说明你应当用什么方法来代替之。
如何去掉JAVA的 内存机制？
是不是垃圾回收机制，使用System.gc()强制回收。
缺少IDE如何编译JAVA代码？
使用JDK的javac.exe 直接手工编译
或使用Apache的ANT脚本构建
THHP与HTTPS有什么区别？
HTTP为普通WEB协议、HTTPS为加密WEB协议。默认http为tcp80端口。https为tcp443端口
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.一般能用#的就别用$.
请裂举session、cookie、viewstated的应用范围
Session 服务器端维护，某个用户活动时间 + 延迟时间（默认20分钟），
Cookie 客户端维护，程序可指定生命周期，
ViewState 小量数据，一个web页面的生命期
用什么方法使服务器关闭之后，session所保存的信息不会丢失？
将session信息保存到数据库中或文件中
B2C和C2C你们是怎么区别的？
Business（企业）、Customer（消费者）
B2C的B是Business企业，2则是to的谐音，C是Customer消费者，所以B2C是企业对消费者的电子商务模式。这种形式的电子商务一般以网络零售业为主，主要借助于Internet开展在线销售活动。B2C简而言之是就是商家与顾客之间的商务活动，也就是通常所说的”网上购物网站”，企业、商家可充分利用电子商城提供的网络基础设施、支付平台、安全平台、管理平台等共享资源有效地、低成本地开展自己的商业活动。
C2C就是消费者（consumer）与消费者（consumer）之间的电子商务。打个比方，比如一个消费者的有一台旧电脑，通过网上拍卖，把它卖给另外一个消费者，这种交易类型就称为c2c电子商务。主要是指网上拍卖。c2c模式的特点就是大众化交易，因为是个人与个人之间的交易！
用最好效率写一个2*17等于多少？
（2<<4）+ 2
用4 个0，用你所知道的数学方法计算出24
0的阶乘等于1 即 0！＝１那么４个0就是４了
又4的阶乘为２４ ４！＝２４
10怎样计算等于24？ (10×10-4)÷4=24
有一个长方形蛋糕,切掉长方形一块,怎样一刀切下去成大小相等两块
将完整的蛋糕的中心与被切掉的那块蛋糕的中心连成一条线。这个方法也适用于立方体
九个球不知道哪个轻重，让你称？
4个和4个称，若相等则剩下一个是比较重要(2)若不相等，则往那边不相等的那4个球中取两个分为一组，则左2个，右2个，则有左边或右边右一个是比较重的，从任意一边取一个投入另一方，并记住这个球，从其它4个取两个放入另外一边，并记住这两个球，若从一边取走的放到另一边后，那边重，则这球比较重要，若从一边取走的放到另一边后，那边轻，则为另外一边所剩的一个球发