面试问题总结

1，软件开发周期

市场调研--需求分析(<<需求分析说明书>>)--项目立项--项目系统分析--(<<总体设计说明书>>)(<<详细设计说明书>>)--代码编写(<<开发日志>>)--测试--(<<测试用例说明书>>)--系统的部署和实施(<<系统实施手册>>)--交付用户(<<用户使用手册>>)

2.什么是javaEE

 JavaEE是sun公司提出的多层，分布式，基于组件的企业级应用模型，在这个应用系统中，可按照功能划分为不同的组件，这些组件又可以在不同的计算机上，并且处于相应的层次中。

3.冒泡排序

public class Test {

public static void main(String[] args) {

int[] num={20,3,5,8,1,15,12};

for(int m=0;m<num.length;m++){

for(int i=0;i<num.length-1;i++){

int temp;

if(num[i]>num[i+1]){

temp=num[i];

num[i]=num[i+1];

num[i+1]=temp;

}

}

}

for(int n=0;n<num.length;n++){

System.out.println(num[n]);

}

}

}

4.java程序的执行流程

java源文件--javac编译--.class类文件--java调用--类加载器,将class文件加载到jvm上--字节码验证器，验证class文件的编码格式是否和OS的编码格式一样--验证通过，再在jvm上执行

5.java的垃圾回收

垃圾回收的基本原理：对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的",哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。程序员可以手动执行System.gc(),通知

GC运行，但是Java语言规范并不保证GC一定会执行。

6.struts的工作流程

A:用户提交请求

B:根据扩展名.do，定位到ActionServlet,由ActionServlet加载struts_config.xml。struts-config.xml接收用户请求，进行action的匹配；

C:struts-config.xml根据action的配置信息，判断是否有表单Bean的配置。如果存在表单Bean信息，马上进行表单Bean的实例化，进行请求参数的自动封装，返回封装好的bean,并且在指定的作用域中存在

D:struts-config.xml再根据action的信息，进行action的调用。加载，实例化action，执行excute处理方法，调用模型层的处理，获得处理结果，返回转发信息

F:struts-config.xml根据action返回的转发别名，进行转发页面的调用，实现结果的显示。

7.struts1和struts2的区别

(1)action的区别

共性：都是实现控制层的对象

区别：

A：创建方式不同

struts1的action必须继承自struts的API.

struts2的action可以继承自ActionSupport，更可以是任意的POJO对象。

B：参数捕获方式不同

struts1的action通过明确的表单bean或者request对象捕获参数。

struts2的action可以利用自己的属性，也可以利用BEAN，也可以利用request获得参数。

C：web对象的捕获方式不同

struts1的action，request等对象直接在方法参数中实现了传递，可以在action的具体方法中直接使用。

struts2的action，由于是一个POJO对象，多以没有集成任何的web对象，必须先手动捕获才能使用。

D：中文乱码的处理方式不同

struts1的action直接利用过滤器可以实现乱码的处理。

struts2的action，需要根据请求提交方法和页面编码，具有不同的处理方式。

E：配置不同

F：实现业务处理的方法结构不同

struts1的action以ActionForward的方式进行转发。

struts2的action是以String的方式进行转发。

G：测试方式不同

struts1的action必须部署到web服务器上才能测试。

struts2的action由于就是一个POJO对象，可以不用部署，直接在测试类上测试。

H：线程安全性不同

struts1的action，默认以单态模式实现，所以只有一个action实例发生工作。所以是线程不安全的。所以需要避免使用成员变量。

struts2的action,默认是每个用户请求都创建不同的实例。所以是线程安全的。所以在spring中配置action时，需要指定scope为prototype。

(2)struts1和struts2的区别

共性：都是apache的mvc框架

区别：

A：工作机制不同

struts1是完全建立在传统struts的工作思想上实现的。

struts2是以webwork的工作机制为核心。

B：加载方式不同

struts1是以SERVLET的方式实现加载。

struts2是以过滤器的方式进行加载。

C：配置文件不同

1中的配置文件是在WEB-INF目录struts-config.xml。

2中的配置文件在src目录，允许任意名称任意数量。默认文件是struts.xml。

D：表单bean不同

1中，必须明确的借助表单bean实现参数封装。

2中，没有了表单bean的概念，直接在action上捕获参数。

E：action不同

F：转发实现方式不同

1中以明确的ActionForward实现转发。

2中以String的方式实现转发。

G：乱码解决方式不同

H：web内置对象的捕获方式不同

I：与spring的整合方式不同

J：标签库不同

1中有多个标签库存在

2中只有1个。

K：注解支持不同

1中不使用注解

2中可以直接使用注解完成配置。

7.常见的运行时异常

 IndexOutOfBoundsException，SystemException，ClassCastException，NullPointerException，

8.抽象类和接口的区别

含有abstract修饰符的class即为抽象类，abstract类不能创建实例对象。含有abstract方法的类必须定义为abstract class,abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体的子类中实现，所以，不能有抽象构造方法或抽象金泰方法。如果子类没有实现抽象父类中的所有抽象方法，name子类也必须定义为abstract类型。

接口(interface)可以说成是抽象类的一种特列，接口中的所有方法都必须是抽象的。接口中定义默认为public abstract类型，接口中的成员变量类型默认为public static final.

两者的语法区别：

a:抽象类中可以有抽象方法，接口中不能有构造方法；

b:抽象类中可以有普通成员变量，接口中没有普通成员变量

c:抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的蹼泳方法；

d:抽象类中的抽象方法的访问类型可以使public,protected，但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型；

e：抽象类中可以包含静态方法，接口中不能包含静态方法；

f：抽象类和接口都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final 类型，并且默认即为public static final类型；

9.list set map是否都是继承自collection接口？有哪些本质区别？

(1)HashMap和Hashtable的区别。

  都属于Map接口的类，实现了将惟一键映射到特定的值上。 HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。

  Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

(2)List，Set是，Map不是

(3)就ArrayList与Vector主要从二方面来说.

一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的

二.数据增长:当需要增长时,Vector默认增长为原来一培，而ArrayList却是原来的一半

就HashMap与HashTable主要从三方面来说。

一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现

二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的

三.值：只有HashMap可以让你将空值作为一个表的条目的key或value

10.servlet的生命周期

(a).定位：用户根据地址请求指定的servlet,web.xml,根据用户输入的地址，定位到具体的servlet

(b).加载：将找到的servlet类加载到web容器中(servlet容器)

(c).实例化：调用默认无参构造函数，实现servlet的实例化

(d).初始化：用Init方法，实现成员变量的初始化

(e).服务处理：servlet的service方法接收用户请求，根据当前用户请求的方式是get还是post,service自动将用户请求传递到doGet和doPost方法中进行处理，处理完成后，产生响应结果

(f).调用destory方法，实现servlet的释放工作。

11.jsp的生命周期

(a):根据用户请求的jsp地址，在指定的路径调用jsp文件，加载到web容器中

(b):如果jsp文件是第一次被调用，进行编译阶段，生成servlet

(c):调用生成的servlet类文件，加载到servlet容器中

(d):调用默认无参构造函数，进行实例化

(e):调用_jspInit进行初始化

(f):调用_jspService实现服务处理

(g):调用_jspDestory方法，实现jsp资源释放

12.数据库的分页

oracle:

  sql=select * from (select j.*,rownum rn from 方案名.表名 j where rownum<=(当前页-1)*pageSize) where rn<=(当前页-1)*每页显示记录数

sqlserver:

  sql=select top pagesize * from 表名 where id>(select max(id) from (select top (当前页-1)*pagesize) id from 表名 order by id) as j)

13.删除重复值

oracle:

    delete 表名 where rowid not (select min(rowid) from 表名 group by 重复的字段)

sqlserver:

   delete 表名 where id not in(select min(id) from 表名 group by 重复的字段)

14.web开发中的ssh框架组合，说明各部分设计思想及其在框架组合中的作用？

Struts：

           优点:首先他是开源的,使开发者可以更深了解他的原理和内部实现机制,   可扩展性

                  采用MVC模式分离业务逻辑层 显示层 模型层 低耦合,结构清晰，使开发者专注于业务逻辑

                  还有丰富的标签库供使用

                  支持国际化

                  还有很高的重用性

           缺点:  Struts将MVC中的控制层 一分为三 在获得结构更加清晰的同时，也增加了系统的复杂度

                    ActionForms使用不便、无法进行单元测试

                   对servlet依赖性过强，struts在处理action时 必须要依赖 httprequest和 HttpResponse 对象

Hibernate 

          优点: 他是数据库连接的中间件，而且对程序的依赖性很小  透明性  使用了java的反射机制

                轻量级  他对jdbc进行了轻量级的封装  而且可以在程序中取代EJB的cmp，完成持久化

                 性能很好，而且还是轻量级 很灵活

               他支持多种数据库 的 1对多的复杂关系

                   可以完全使用面向对象的思想去编程

                  使用了JTA  JDBC 和  JNDI技术

         缺点：一个持久化类不能映射多个表

           相对内存消耗JDBC是最省内存的，hibernate次之  ejb Bean 最差

Spring

         优点：spring  是基于ioc（控制反转）和aop（面向切面编程） 的框架

                 而且封装了所有的事务，不需要程序员自己去提交事务，一切都由web容器去控制，省去了很多代码

                 spring采用了单态和工厂模式       采用mvc模式下的java程序 尽管已经把层与层之间的关系耦合度降低，但还是有联系，        这时候使用spring 把所有bean都交由web容器去控制 创建和销毁，这样才真正的降低了耦合度， 而且bean的创建的生命周期都在web容器里控制，而且他从工厂里实例的bean都是单态的，当然可以加一个属性让他不是单态

                 面向接口编程，只需要知道要实现的接口就可以，不需要知道他的具体实现

                 使用spring框架有利于单元测试

15.hibernate的工作机制

(a). 通过Configuration().configure();读取并解析hibernate.cfg.xml配置文件。

(b). 由hibernate.cfg.xml中的读取解析映射信息。

(c). 通过config.buildSessionFactory();//得到sessionFactory。

(d). sessionFactory.openSession();//得到session。

(e). session.beginTransaction();//开启事务。

(f). persistent operate;

(g). session.getTransaction().commit();//提交事务

(h). 关闭session;

(i). 关闭sessionFactory;

16.为什么要用hibernate?

(a). 封装了jdbc,简化了很多重复性代码。

(b). 简化了DAO层编码工作,使开发更对象化了。

(c). 移植性好,支持各种数据库,如果换个数据库只要在配置文件中变换配置就可以了,不用改变hibernate代码。

(d). 支持透明持久化,因为hibernate操作的是纯粹的(pojo)java类,没有实现任何接口,没有侵入性。所以说它是一个轻量级框架。

17、 Hibernate对象的三种状态

永久态，瞬时态，游离态

18、 hibernate的核心类是什么,它们的相互关系是什么?重要的方法是什么?

Configuration 接口:配置Hibernate,根据其启动hibernate,创建SessionFactory 对象;

SessionFactory 接口:初始化Hibernate,充当数据存储源的代理,创建session 对象,sessionFactory 是线程安全的,意味着它的同一个实例可以被应用的多个线程共享,是重量级、二级缓存;

Session 接口:负责保存、更新、删除、加载和查询对象,是线程不安全的,避免多个线程共享同一个session,是轻量级、一级缓存;

Session如下方法: save,load,update,delete,

Query q=CreateQuery(“from Customer where customerName=:customerName”)

beginTransaction, close, transaction, commit

Transaction 接口:管理事务;

Query 和Criteria 接口:执行数据库的查询。

19. j2ee 常用的设计模式？说明工厂模式。 

 答： Java 中的 23 种设计模式： 

Factory （工厂模式），       Builder （建造模式），        Factory Method （工厂方法模式）， 

Prototype （原始模型模式）， Singleton （单例模式），     Facade （门面模式）， 

Adapter （适配器模式），     Bridge （桥梁模式），         Composite （合成模式）， 

Decorator （装饰模式），     Flyweight （享元模式），      Proxy （代理模式）， 

Command （命令模式），       Interpreter （解释器模式），  Visitor （访问者模式）， 

Iterator （迭代子模式），    Mediator （调停者模式），     Memento （备忘录模式）， 

Observer （观察者模式），    State （状态模式），          Strategy （策略模式）， 

Template Method （模板方法模式），  Chain Of Responsibleity （责任链模式） 

工 厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且 实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个 工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

20.struts2的工作流程

struts2并不是一个陌生的web框架，它是以Webwork的设计思想为核心，吸收struts1的优点，可以说

struts2是struts1和Webwork结合的产物。 

一个请求在Struts2框架中的处理分为以下几个步骤：

a.客户端发出一个指向servlet容器的请求(tomcat)；

b.这个请求会经过图中的几个过滤器，最后会到达FilterDispatcher过滤器。

c.过滤器FilterDispatcher是struts2框架的心脏，在处理用户请求时，它和请求一起相互配合访问struts2

  的底层框架结构。在web容器启动时，struts2框架会自动加载配置文件里相关参数，并转换成相应的类。

  如：ConfigurationManager、ActionMapper和ObjectFactory。ConfigurationManager 存有配置文件的一

  些基本信息，ActionMapper存有action的配置信息。在请求过程中所有的对象（Action，Results，

  Interceptors，等）都是通过ObjectFactory来创建的。过滤器会通过询问ActionMapper类来查找请求中

  需要用到的Action。

d.如果找到需要调用的Action，过滤器会把请求的处理交给ActionProxy。ActionProxy为Action的代理对象

  。ActionProxy通过ConfigurationManager询问框架的配置文件，找到需要调用的Action类。

e.ActionProxy创建一个ActionInvocation的实例。ActionInvocation在ActionProxy层之下，它表示了

  Action的执行状态,或者说它控制的Action的执行步骤。它持有Action实例和所有的Interceptor。 

f.ActionInvocation实例使用命名模式来调用，1. ActionInvocation初始化时，根据配置，加载Action相

  关的所有Interceptor。2. 通过ActionInvocation.invoke方法调用Action实现时，执行Interceptor。在

  调用Action的过程前后，涉及到相关拦截器(intercepetor)的调用。

g. 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果

  通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版

21.set集合如何去除重复？

22.数据库优化的规则？

(1)硬件充足，软件版本匹配，网络运行优良

(2)安装oracle的机器虚拟内存应该是物理内存的2-8倍；

(3)安装oracle的物理磁盘和安装系统文件的磁盘进行分离;

(4)自己的数据存储在自己的文件中，不建议使用数据库默认提供的数据文件;

(5)使用oracle数据库，建议建立自己的表空间，建立自己的用户，分配自己的权限，创建自己的数据库对象，管理自己的数据;

(6)根据实际需要，设计结构良好的表结构;

(7)表中数据，如果频繁被检索，一定合理的设计和应用索引;

(8)创建索引后，应用索引的规则(sql语句进行优化的简单准则)

(a)建立只应用于查询，反复被调用的复杂的select语句，需要借助视图实现重用；

(b)索引字段只有在where条件中出现时，索引才起作用;

(c)where条件中的索引字段，如果进行数学运算，进行函数运算，此时索引不起作用;

(d)在查询语句中，尽量少用in(not in),exit(not exit),like 关键字，此时索引也不起作用;

(e)多表查询时，首选连接查询，集合查询，子查询;

(f)多表查询时，驱动表应当放在最后。驱动表：数据最小的表;

(g):where 条件中，数据过滤功能最强的条件，放到最后。where的执行从右向左；

(I)复合索引，只对主索引字段有效

(9)核心的业务处理，建议使用过程

22.创建索引的语句？

oracle:create index 方案名.索引名 on 方案名.表名(字段列表) tablespace 表空间名

23.创建过程的语句

(1)基本语法

  create or replace procedure 方案名.过程名(参数列表)

  as(is)

  声明部分

  begin

    执行部分

  exception

    异常处理部分

  end 过程名;

(2)调用

A：execute 方案名.过程名(参数值)

适用于单命令行语句

B：pl/sql的调用方式

begin

方案名.过程名(参数值)

end;

C：前提

如果过程有输出参数，必须先声明一个与输出参数同种类型的变量进行接收。