Java面试题集

Java面试题集 | 楼主 | 2016-12-02 00:02:36 共有3个回复
  1. 1Java SSH面试题集
  2. 2IBM、SUN等公司的Java面试题集
  3. 3IBM、SUN等公司的Java面试题集

摘要:视图不进行任何业务逻辑处理,控制器调用相应的视图来显示处理的结果,为每一个请求产生一个实例因此没有线程安全问题,不依赖于容器允许脱离容器单独测试,测试的一个主要问题是方法暴露了这使得测试要依赖于容器。以下是小编整理的3篇最新Java面试题集范文,欢迎参阅!

Java SSH面试题集2016-12-02 00:00:11 | #1楼回目录

Java—SSH(MVC)

1. 谈谈你mvc的理解

MVC是Model—View—Controler的简称。即模型—视图—控制器。MVC是一种设计模式,它强制性的把应用程序的输入、处理和输出分开。

MVC中的模型、视图、控制器它们分别担负着不同的任务。

视图: 视图是用户看到并与之交互的界面。视图向用户显示相关的数据,并接受用户的输入。视图不进行任何业务逻辑处理。

模型: 模型表示业务数据和业务处理。相当于JavaBean。一个模型能为多个视图提供数据。这提高了应用程序的重用性

控制器: 当用户单击Web页面中的提交按钮时,控制器接受请求并调用相应的模型去处理请求。 然后根据处理的结果调用相应的视图来显示处理的结果。

MVC的处理过程:首先控制器接受用户的请求,调用相应的模型来进行业务处理,并返回数据给控制器。控制器调用相应的视图来显示处理的结果。并通过视图呈现给用户。

Struts

1. struts1.2和struts2.0的区别?如何控制两种框架中的单例模式?

struts1.2和struts2.0的对比

a、Action类:

struts1.2要求Action类继承一个基类。struts2.0 Action要求继承ActionSupport基类

b、线程模式

struts1.2 Action是单例模式的并且必须是线程安全的,因为仅有一个Action的实例来处理所有的请求。

单例策略限制了Struts1.2 Action能做的事情,并且开发时特别小心。Action资源必须是线程安全的或同步的。

struts2.0 Action为每一个请求产生一个实例,因此没有线程安全问题。

c、Servlet依赖

struts1.2 Action依赖于Servlet API,因为当一个Action被调用时HttpServletRequest和HttpServletResponse被传递给execut方法。

struts2.0 Action不依赖于容器,允许Action脱离容器单独测试。如果需要,Struts2 Action仍然可以访问初始的Request和Response。

但是,其他的元素减少或者消除了直接访问HttpServletRequest和HttpServletResponse的必要性。 d、可测性

测试struts1.2 Action的一个主要问题是execute方法暴露了Servlet API(这使得测试要依赖于容器)。一个第三方扩展:struts TestCase

提供了一套struts1.2的模拟对象来进行测试。

Struts2.0 Action可以通过初始化、设置属性、调用方法来测试,“依赖注入”也使得测试更容易。

2. 项目中为什么使用SSH

1. 使用Struts是因为struts是基于MVC模式的,很好的将应用程序进行了分层,使开发者更关注于业务逻辑的实现;第二,struts有着丰富的taglib,如能灵活运用,则能大大提高开发效率。

2. 使用Hibernate:因为hibernate为Java应用提供了一个易用的、高效率的对象关系映射框架。hibernate是个轻量级的持久性框架,功能丰富。

3. 使用Spring:因为spring基于IoC(Inversion of Control,反向控制)和AOP构架多层j2ee系统的框架,但它不强迫你必须在每一层中必须使用Spring,因为它模块化的很好,允许你根据自己的需要选择使用它的某一个模块;

采用IoC使得可以很容易的实现bean的装配,提供了简洁的AOP并据此实现事务管理(Transcation

Managment),等等

3. struts与spring是如何继承的

不懂题目之意:是否是说的struts的action都继承自org.apache.struts.action.Action

而Spring中的继承就不清楚了。

4. struts如何实现国际化

以下以两国语言(中文,英文)为例:

1. 在工程中加入Struts支持

2. 编辑ApplicationResource.properties文件,在其中加入要使用国际化的信息, 例如: lable.welcome.china=Welcome!!!

3. 创建英文资源文件ApplicationResource_en.properites

4. 创建临时中文资源文件ApplicationResource_temp.properites 例如:lable.welcom.china=中国欢迎您!

5. 对临时中文资源文件进行编码转换。可以使用myeclipse的插件,也可以在dos下执行:

native2ascii -encoding gb2312 ApplicationResource_temp.properties ApplicationResource_zh_CN.properties

6. 在jsp中加入struts的bean标记库

显示信息:

可以在struts-config.xml文件中定义多个资源包,而每个资源包可使用key属性指定包的名称。

5. struts2.0的常用标签

1. 往action里传值:

2. 显示标签 property 用于输出指定值:

3. 用于从页面往action中(user)的对象内传值:

4. 判断用于在页面中判断指定数据 ….….

5. 迭代用于将List、Map、ArrayList等集合进行循环遍历

6. URL地址标签,用于生成一个URL地址,可以通过URL标签指定的子元素向URL地址发送请求参数

7. 超链接 一般和标签一起使用,用于带多个参数。

“>超链接

8. set标签,用于将某个值放入指定的范围内。例如application,session等。

6. struts中怎么配置form-bean、action、tiles

此处配置的是struts1.2的

form-bean配置:(在配置文件struts-config.xml中):

name: 指定form的名字; type指定form的类型:包名+类名;

action配置:(在配置文件struts-config.xml中)

attribute=""

input=""

name=""

parameter=""

scope="request"

type=""

>

path:请求Action的名字; attribute:form的名字,与form-bean中的name对应; input:输入页的路径;

name:如果配置了attribute,name不起作用,与attribute一样; parameter:使用分发Action时,指定调用分发Action中的方法名;

scope:Action的范围; type:Action的类型:包名+类名;

tites配置:

1. 新建一个 tiles-defs.xml文件,并在其中做如下配置:

2. 在web.xml和struts-config.xml和web.xml中做相应配置:

在struts-config.xml中配置如下:

************

************

在web.xml中配置如下:

************

definitions-config/WEB-INF/tiles-defs.xml

*************

3. 调用Tiles组件

Tiles组件是通过Struts Action来调用的,在struts-config.xml中做如下action配置:

*************

path="/member"

parameter="member-definition"

type="org.apache.struts.actions.ForwardAction"/>

**************

7. logic标签有哪几个?

此标签库可以分为三种类型:条件、循环、转发/重定向。

1. 条件类型 (没标注的都比较简单)

logic:empty, logic:notEmpty;

logic:equal, logic:notEqual, logic:lessThan, logic:greaterThan,logic:lessEqual, logic:greaterEqual; logic:present, logic:notPresent;

logic:match, logic:notMatch; 比较两字符串是否相等,可以比较字符串的开始的、结尾的或其中的某个部分。location属性:指定从某个位置开始进行比较。

2. 循环类型

logic:iterate

3. 转发/重定向类型

logic:forward和logic:redirect

logic:forward标签和jsp:forward标签相似,但它可以使用global forward中的一个ActionForward 例如:

——————————————————————————

与上面相关的global forward中的代码:

logic:redirect标签和上面的标签类似,但它默认调用的方法是response.sendRedirect(),

取代了上面的requestDispatcher.forward()。最大的不同是它支持所有html:link标签的属性,所以你能够指定request参数:

在MVC框架下,不推荐使用这两个标签,你应该是从controller中选择下一个view,而不是从view中选择.在Jsp页面中不要过多的使用logic标签。

8. action是单实例还是多实例,为什么?

action是单实例的。当多个用户访问一个请求的时候,服务器内存中只有一个与之对应的action类对象。

因为当服务器第一次加载struts的配置文件的时候,创建了一个Action后,每发送一个请求,服务器都会先去检索相应的范围内(request,session)是否存在

这样一个action实例,如果存在,则使用这个实例,如果不存在,则创建一个action实例。

9. dispatchAction是用什么技术实现的?

DispatchAction 是Aciton的一个子类,主要解决了一个请求处理多个功能的问题

普通的Action你只能写execute方法来处理业务,而想用这一个Action处理多个任务,你必须要请求参数进行解析,用if语句块来处理

举一个小例子:

有如下一个url: http://localhost:8080/myApp/addUserAction.do

如果你处理这个url的是一个普通的Action,那么就只能在execute里面执行插入的相关操作,如果换成一下url:

http://localhost:8080/myApp/UserAction.do?method=add

你就应该根据method对象的值来执行相应的操作,如再有一个路径http://localhost:8080/myApp/UserAction.do?method=delete

这个还可以使用那个Action来处理的,只是多判断一下而已.

如果你用DispatchAction,就简单多了,所以dispatchAction还是用的Action的这么一个技术。

10. struts2.0的mvc模式?与struts1.0的区别?

struts2的mvc模式:当用户在页面提交用户请求时,该请求需要提交给struts2的控制器处理。struts2的控制器根据处理结果,

决定将哪个页面呈现给客户端。

与struts1最大的不同是:struts2的控制器。struts2的控制器不再像struts1的控制器,需要继承一个Action父类,甚至可以无需实现

任何接口,struts2的Action就是一个普通的POJO。实际上,Struts2 的Action就是一个包含execute方法的普通Java类

该类里包含的多个属性用于封装用户的请求参数。

11. STRUTS的配置文件是什么?

struts-config.xml

12. 请写出Struts的工作原理。

13. struts的处理流程。

一、ActionServlet的初始化

ActionServlet作为Struts组件的前端控制器,由于web.xml的相应配置:

在应用一加载时即会被实例化并调用其init方法,init方法所做的主要工作有二:

1. 加载struts配置文件,并创建用于封装配置信息的ModuleConfig对象

2. 加载资源文件,并创建用于封装资源文件的MessageResources对象

需要注意两点:如果web.xml有多模块配置,将创建多个ModuleConfig对象和MessageResources对象分别

用于封装各个模块的struts配置文件和资源文件。

针对各个模块所创建的ModuleConfig对象和MessageResources对象将存储在ServletContext中,对应的属

性名中有该模块名称的相应标识。

另外,如果有相应配置的话,init方法还将初始化数据源和PlugIn

二、ActionServlet的process

所有形如*.do的请求(根据web.xml中的相关配置)将提交给ActionServlet,最终将调用其process方法

。process方法的主要工作有三:

1. 根据请求信息获知所请求的模块名称,从ServletContext中获得与请求模块对应的的ModuleConfig对

象,并存储到request中。

2. 根据模块信息获得相应的RequestProcessor对象,一个模块对应一个RequestProcessor对象, RequestProcessor对象将关联与所属模块对应的ModuleConfig对象。

3. 调用RequestProcessor对象的process方法,将request和response作为参数传递给它。

三、RequestProcessor的process

RequestProcessor对象的process方法的主要工作有五步:

1. 调用自己的 processPreprocess(request, response)方法,该方法不进行任何操作,用于子类重写 扩展其功能。

2. 获得与请求地址所匹配的ActionMapping对象,AcionMapping对象用于封装一个特定acion的配置信息

。3. 根据ActionMapping中的配置信息获得ActionForm对象(该对象将缓存到request或session中),并

将表单数据填充到ActionForm中,然后根据ActionMapping的配置决定是否验证ActionForm,如果验证,

将调用ActionForm的 validate方法,若其返回的ActionErros对象中包含ActionMessage对象则表示验证

失败,将转向action配置信息 input属性所指示的地址。

4. 如果ActionForm无需验证或验证通过将创建并缓存与请求地址匹配的Action对象,将ActionMapping

对象、ActionForm对象、request和response作为参数调用其execute方法。

5. 根据Action对象的execute方法返回的ActionForward对象,将请求转发或重定向到该ActionForward

所封装的地址。

14. 用struts +hibernate做一个增删查改(机试)

15. Struts2.0与Struts1.x有何区别。

特征

Struts的一

Struts的2

行动班

Struts的一要求采取行动班,以延长一个抽象的基类。 一个共同的问题在Struts的一,是编程抽象类而不是接口。 1 2 Struts的行动, 可能实施一项行动的界面,随着其他接口,使可选和定制服务。 Struts的2提供了相应的actionsupport一流的执行常用的接口。 虽然,这项行动的界面是不是必需的 。 任何波霍对象与执行的签名可以被用来作为一个Struts的二行动的对象。

线程模型

Struts的一行动是单身,必须线程安全的,因为将只有一个实例一类来处理所有的请求采取行动。 单身人士策略地方的限制,可以做些什么与Struts的一行动,并要求加倍小心发展。 行动的资源,必须线程安全的或同步。 2 Struts的行动对象是实例对于每个请求,因此没有线程安全问题。 (在实践中, Servlet的容器,产生许多扔离家出走的对象,每次请求,并多一个对象不施加表现罚款,或影响垃圾收集) 。

Servlet的依赖 Struts的一行动,依赖于该Servlet的空气污染指数以来, httpservletrequest和httpservletresponse传递给Execute方法,当一个行动是引用。 Struts的行动,二是不耦合的一个货柜。 最经常的Servlet的背景是派代表作为简单的地图,让行动,以测试陷入孤立的境地。 2 Struts的行动仍然可以使用原来的请求和响应,如果需要。 不过,其他建筑元素,减少或消除需要访问httpservetrequest或httpservletresponse直接。

测试

一个主要障碍,以测试Struts的一行动是Execute方法暴露了Servlet的空气污染指数。 第三党的扩展, Struts的testcase ,提供了一套模拟对象的Struts 1 。 2 Struts的行动可以测试实例化的行动,设置属性,引用的方法。 依赖注入的支持也使测试更简单。

收获的投入 Struts的一使用actionform对象捕获输入。 一样的行动,所有actionforms必须扩大基地,一流的。 由于其他的JavaBeans不能被用来作为actionforms ,开发商常常造成多余的班,以捕捉的投入。 dynabeans可以用来作为一种替代创造常规actionform班,但这里太,发展商可能会redescribing现有的JavaBeans 。

Struts的2使用性能的行动作为输入属性,不再需要第二个输入对象。 输入属性可能是丰富的对象类型可能有自己的属性。 行动性质可以从网页上通过taglibs 。 Struts的2还支持actionform模式,以及波霍形式,对象和波霍行动。 丰富的对象类型,其中包括商业利益或域对象,可以被用来作为输入/输出对象。 该modeldriven功能简化taglb的提述,波霍投入对象。

语言表达

Struts的一整合与jstl ,所以它使用jstl下午。 的El已基本对象图遍历,但相对薄弱的收集和索引财产的支持。 Struts的二可以使用jstl ,但框架也支持一个更强大和灵活的语言表达所谓的“对象图形符号语言” ( ognl ) 。

有约束力的价值观纳入意见 Struts的一使用标准的JSP机制,有约束力的物体进入该网页的背景下访问。 Struts的2使用“ valuestack ”技术,使该taglibs可以访问的价值观没有耦合您的看法,以对象类型,这是渲染。 该valuestack策略允许重用的意见覆盖的类型可能有相同的属性名称,但不同的属性类型。

类型转换

Struts的一actionform属性通常是所有字符串。 Struts的一用途的商品- beanutils为类型转换。 转换器每级的,而不是配置的每个实例。 Struts的2使用ognl为类型转换。 该框架包括转换为基本和共同的对象类型和原始。

验证

Struts的一支持手册审定通过验证方法对actionform ,或通过一个扩展到商品校验。 班级可以有不同的验证背景为同一阶层,但不能链,以验证就分对象。 Struts的2支持手册审定通过验证的方法和xwork的验证框架。 该xwork的验证框架支持链接验证分为分性能的使用验证的定义为性能一流的类型和验证。

控制行动的执行 Struts的一支持独立的请求处理器(生命周期)为每个单元,但所有的行动,在该模块必须共用相同的生命周期。 2 Struts的支持,创造不同的生命周期对每行动的基础上通过拦截堆叠。 自定义栈,才能创造和使用不同的行动,视需要。

16. Struts/webwork 的工作机制,它有哪些标签

Struts 2框架的大致处理流程如下:

浏览器发送请求,例如请求/mypage.action、/reports/myreport.pdf等。

核心控制器FilterDispatcher根据请求决定调用合适的Action。

WebWork的拦截器链自动对请求应用通用功能,例如workflow、validation或文件上传等功能。 回调Action的execute方法,该execute方法先获取用户请求参数,然后执行某种数据库操作,既可以是将数据保存到数据库,也可以从数据库中检索信息。实际上,因为Action只是一个控制器,它会调用业务逻辑组件来处理用户的请求。

Action的execute方法处理结果信息将被输出到浏览器中,可以是HTML页面、图像,也可以是PDF文档或者其他文档。此时支持的视图技术非常多,既支持JSP,也支持Velocity、FreeMarker等模板技术。

Hibernate

1. 什么是Hibernate的并发机制?怎么去处理并发问题?

Hibernate并发机制:

a、Hibernate的Session对象是非线程安全的,对于单个请求,单个会话,单个的工作单元(即单个事务,单个线程),它通常只使用一次,

然后就丢弃。

如果一个Session 实例允许共享的话,那些支持并发运行的,例如Http request,session beans将会导致出现资源争用。

如果在Http Session中有hibernate的Session的话,就可能会出现同步访问Http Session。只要用户足够快的点击浏览器的“刷新”,

就会导致两个并发运行的线程使用同一个Session。

b、多个事务并发访问同一块资源,可能会引发第一类丢失更新,脏读,幻读,不可重复读,第二类丢失更新一系列的问题。

解决方案:设置事务隔离级别。

Serializable:串行化。隔离级别最高

Repeatable Read:可重复读

Read Committed:已提交数据读

Read Uncommitted:未提交数据读。隔离级别最差

设置锁:乐观锁和悲观锁。

乐观锁:使用版本号或时间戳来检测更新丢失,在的映射中设置 optimistic-lock=”all”可以在没有版本或者时间戳属性映射的情况下实现 版本检查,此时Hibernate将比较一行记录的每个字段的状态 行级悲观锁:Hibernate总是使用数据库的锁定机制,从不在内存中锁定对象!只要为JDBC连接指定一下隔 离级别,然后让数据库去搞定一切就够了。类LockMode 定义了Hibernate所需的不同的锁定级别:LockMode.UPGRADE,LockMode.UPGRADE_NOWAIT,LockMode.READ;

2. Hibernate和spring中常出现的几个异常

org.springframework.beans.factory.BeanCreationException:

Error creating bean with name sessionFactory defined in ServletContext resource

[/WEB-INF/applicationContext.xml]:

Initialization of bean failed; nested exception is org.hibernate.MappingException: Repeated column in mapping for entity: com.xindeco.myregister.pojo.MyRegisterInfo column:

password (should be mapped with insert=”false” update=”false”)

出错原因:password 和repassword同时对应数据库表中的password一列,同时update和insert都设为true。xml文件如下:

type="java.lang.String"

update="true"

insert="true"

access="property"

column="password"

length = "32"

/>

type="java.lang.String"

update="false"

insert="false"

access="property"

column="password"

length = "32"

/>

解决方法:将repassword的insert和update设为false。

org.springframework.beans.factory.BeanCreationException:

Error creating bean with name sessionFactory defined in ServletContext resource

[/WEB-INF/applicationContext.xml]:

Initialization of bean failed;nested exception is org.hibernate.PropertyNotFoundException: Could not find a getter for ID in class

错误原因:hibernate的映射文件中ID是大写的,而pojo的类中id是小写的

解决方法:要么将pojo类中的id改称大写,要么把hibernate的映射文件中的ID改称小写。

3. Hibernate与jdbc的联系

hibernate是jdbc的轻量级封装,包括jdbc的与数据库的连接(用hibernate.property的配置文件实现当然本质是封装了jdbc的forname),

和查询,删除等代码,都用面向对象的思想用代码联系起来,hibernate通过hbm 配置文件把po类的字段和数据库的字段关联起来比如数据库的id,

在po类中就是pravite Long id; public Long getId() ;public setId(Long id);

然后hql语句也是面向对象的,它的查询语句不是查询数据库而是查询类的,这些实现的魔法就是xml文件,其实hibernate=封装的jdbc+xml文件

4. Hibernate与spring的联系

hibernate中的一些对象可以给Spring来管理,让Spring容器来创建hibernate中一些对象实例化。例如:SessionFactory,HibernateTemplate等。

Hibernate本来是对数据库的一些操作,放在DAO层,而Spring给业务层的方法定义了事务,业务层调用DAO层的方法,很好的将Hibernate的操作也加入到事务中来了。

5. Hibernate自带的分页机制是什么?如果不使用Hibernate自带的分页,则采用什么方式分页?

1、hibernate自带的分页机制:获得Session对象后,从Session中获得Query对象。用Query.setFirstResult():设置要显示的第一行数据,

Query.setMaxResults():设置要显示的最后一行数据。

2、不使用hibernate自带的分页,可采用sql语句分页,

如:5:为每页显示的记录,2为当前页: select * top 5 from table where tabId not in (select tabId top (2-1)*5 from table);

6. hibernate的对象的三种持久化状态,并给出解释?

不清楚hibernate的对象的三种持久化状态,只知道hibernate对象的三种状态,下面有介绍。

7. hibernate中一对多配置文件返回的是什么?

hibernate中一对多配置文件会相应的映射为两张表,并且它们之间的关系是一对多的。

例如:一个student和classes表的关系 。一个学生只能是一个班的,一个班可以有多个学生。

8. update()和saveOrUpdate()的区别?

update()和saveOrUpdate()是用来对跨Session的PO进行状态管理的。

update()方法操作的对象必须是持久化了的对象。也就是说,如果此对象在数据库中不存在的话,就不能使用update()方法。

saveOrUpdate()方法操作的对象既可以使持久化了的,也可以使没有持久化的对象。如果是持久化了的对象调用saveOrUpdate()则会

更新数据库中的对象;如果是未持久化的对象使用此方法,则save到数据库中。

9. hibernate的三种状态之间如何转换

当对象由瞬时状态(Transient)一save()时,就变成了持久化状态。

当我们在Session里存储对象的时候,实际是在Session的Map里存了一份,

也就是它的缓存里放了一份,然后,又到数据库里存了一份,在缓存里这一份叫持久对象(Persistent)。 Session 一 Close()了,它的缓存也都关闭了,整个Session也就失效了,

这个时候,这个对象变成了游离状态(Detached),但数据库中还是存在的。

当游离状态(Detached)update()时,又变为了持久状态(Persistent)。

当持久状态(Persistent)delete()时,又变为了瞬时状态(Transient),

此时,数据库中没有与之对应的记录。

10. hibernate拒绝连接、服务器崩溃的原因?最少写5个

1. db没有打开

2. 网络连接可能出了问题

3. 连接配置错了

4. 驱动的driver,url是否都写对了

5. LIB下加入相应驱动,数据连接代码是否有误

6. 数据库配置可能有问题

7. 当前联接太多了,服务器都有访问人数限制的

8. 服务器的相应端口没有开,即它不提供相应的服务

9 hibernate有哪些缓存,分别怎么使用?

10 你对hibernate的了解到了一个什么样的程度?

11 写出一个sql语句体现hibernate中一对多的关系

11. Hibernate介绍

Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合,既可以在Java的客户端程序使用,也可以在Servlet/JSP的Web应用中使用,最具革命意义的是,Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据持久化的重任。

Hibernate的核心接口一共有5个,分别为:Session、SessionFactory、Transaction、Query和Configuration。这5个核心接口在任何开发中都会用到。通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。下面对这五个核心接口分别加以介绍。

Session接口:Session接口负责执行被持久化对象的CRUD操作(CRUD的任务是完成与数据库的交流,包含了很多常见的SQL语句。)。但需要注意的是Session对象是非线程安全的。同时,Hibernate的session不同于JSP应用中的HttpSession。这里当使用session这个术语时,其实指的是Hibernate中的session,而以后会将HttpSesion对象称为用户session。

SessionFactory接口:SessionFactroy接口负责初始化Hibernate。它充当数据存储源的代理,并负责创建Session对象。这里用到了工厂模式。需要注意的是SessionFactory并不是轻量级的,因为一般情况下,一个项目通常只需要一个SessionFactory就够,当需要操作多个数据库时,可以为每个数据库指定一个SessionFactory。

Configuration接口:Configuration接口负责配置并启动Hibernate,创建SessionFactory对象。在Hibernate的启动的过程中,Configuration类的实例首先定位映射文档位置、读取配置,然后创建SessionFactory对象。

Transaction接口:Transaction接口负责事务相关的操作。它是可选的,开发人员也可以设计编写自己的底层事务处理代码。

Query和Criteria接口:Query和Criteria接口负责执行各种数据库查询。它可以使用HQL语言或SQL语句两种表达方式。

12. Hibernate主键介绍

Assigned

Assigned方式由程序生成主键值,并且要在save()之前指定否则会抛出异常

特点:主键的生成值完全由用户决定,与底层数据库无关。用户需要维护主键值,在调用session.save()之前要指定主键值。

Hilo

Hilo使用高低位算法生成主键,高低位算法使用一个高位值和一个低位值,然后把算法得到的两个值拼接起来作为数据库中的唯一主键。Hilo方式需要额外的数据库表和字段提供高位值来源。默认请况下使用的表是

hibernate_unique_key,默认字段叫作next_hi。next_hi必须有一条记录否则会出现错误。 特点:需要额外的数据库表的支持,能保证同一个数据库中主键的唯一性,但不能保证多个数据库之间主键的唯一性。Hilo主键生成方式由Hibernate 维护,所以Hilo方式与底层数据库无关,但

不应该手动修改hi/lo算法使用的表的值,否则会引起主键重复的异常。

Increment

Increment方式对主键值采取自动增长的方式生成新的主键值,但要求底层数据库的支持Sequence。如Oracle,DB2等。需要在映射文件xxx.hbm.xml中加入Increment标志符的设置。 特点:由Hibernate本身维护,适用于所有的数据库,不适合多进程并发更新数据库,适合单一进程访问数据库。不能用于群集环境。

Identity

Identity当时根据底层数据库,来支持自动增长,不同的数据库用不同的主键增长方式。

特点:与底层数据库有关,要求数据库支持Identity,如MySQl中是auto_increment, SQL Server 中是Identity,支持的数据库有MySql、SQL Server、DB2、Sybase和HypersonicSQL。 Identity无需Hibernate和用户的干涉,使用较为方便,但不便于在不同的数据库之间移植程序。

Sequence

Sequence需要底层数据库支持Sequence方式,例如Oracle数据库等

特点:需要底层数据库的支持序列,支持序列的数据库有DB2、PostgreSql、Qracle、SAPDb等在不同数据库之间移植程序,特别从支持序列的数据库移植到不支持序列的数据库需要修改配置文件

Native

Native主键生成方式会根据不同的底层数据库自动选择Identity、Sequence、Hilo主键生成方式 特点:根据不同的底层数据库采用不同的主键生成方式。由于Hibernate会根据底层数据库采用不同的映射方式,因此便于程序移植,项目中如果用到多个数据库时,可以使用这种方式。 UUID

UUID使用128位UUID算法生成主键,能够保证网络环境下的主键唯一性,也就能够保证在不同数据库及不同服务器下主键的唯一性。

特点;能够保证数据库中的主键唯一性,生成的主键占用比较多的存贮空间

Foreign GUID

Foreign用于一对一关系中。GUID主键生成方式使用了一种特殊算法,保证生成主键的唯一性,支持SQL Server和MySQL

13. Hibernate源码中几个包的作用简要介绍

net.sf.hibernate.*该包的类基本上都是接口类和异常类

net.sf.hibernate.cache.*JCS的实现类

net.sf.hibernate.cfg.*配置文件读取类

#url#llection.*Hibernate集合接口实现类,例如List,Set,Bag等等,Hibernate之所以要自行编写集合接口实现类是为了支持lazy loading

#url#nnection.*几个数据库连接池的Provider

net.sf.hibernate.dialect.*支持多种数据库特性,每个Dialect实现类代表一种数据库,描述了该数据库支持的数据类型和其它特点,例如是否有AutoIncrement,是否有Sequence,是否有分页sql等等

net.sf.hibernate.eg.*Hibernate文档中用到的例子

net.sf.hibernate.engine.*这个包的类作用比较散

net.sf.hibernate.expression.*HQL支持的表达式

net.sf.hibernate.hq.*HQL实现

net.sf.hibernate.id.*ID生成器

net.sf.hibernate.impl.*最核心的包,一些重要接口的实现类,如果Session,SessionFactory,Query等

net.sf.hibernate.jca.*JCA支持,把Session包装为支持JCA的接口实现类

net.sf.hibernate.jmx.*我不懂JMX,只知道JMX是用来编写App Server的管理程序的,大概是JMX部分接口的实现,使得App Server可以通过JMX接口管理Hibernate

net.sf.hibernate.loader.*也是很核心的包,主要是生成sql语句的

net.sf.hibernate.lob.*Blob和Clob支持

net.sf.hibernate.mapping.*hbm文件的属性实现

net.sf.hibernate.metadata.*PO的Meta实现

net.sf.hibernate.odmg.*ODMG是一个ORM标准,这个包是ODMG标准的实现类 net.sf.hibernate.persister.*核心包,实现持久对象和表之间的映射

net.sf.hibernate.proxy.*Proxy和Lazy Loading支持

net.sf.hibernate.ps.*该包是PreparedStatment Cache

net.sf.hibernate.sql.*生成JDBC sql语句的包

net.sf.hibernate.test.*测试类,你可以用junit来测试Hibernate

net.sf.hibernate.tool.hbm2ddl.*用hbm配置文件生成DDL

net.sf.hibernate.transaction.*Hibernate Transaction实现类

net.sf.hibernate.type.*Hibernate中定义的持久对象的属性的数据类型

net.sf.hibernate.util.*一些工具类,作用比较散

net.sf.hibernate.xml.*XML数据绑定

14. 缓存管理

Hibernate 中提供了两级Cache,第一级别的缓存是Session级别的缓存,它是属于事务范围的缓存。这一级别的缓存由hibernate管理的,一般情况下无需进行干预;第二级别的缓存是SessionFactory级别的缓存,它是属于进程范围或群集范围的缓存。这一级别的缓存可以进行配置和更改,并且可以动态加载和卸载。 Hibernate还为查询结果提供了一个查询缓存,它依赖于第二级缓存。

1. 一级缓存和二级缓存的比较:第一级缓存 第二级缓存 存放数据的形式 相互关联的持久化对象 对象的散装数据 缓存的范围 事务范围,每个事务都有单独的第一级缓存进程范围或集群范围,缓存被同一个进程或集群范围内的所有事务共享 并发访问策略由于每个事务都拥有单独的第一级缓存,不会出现并发问题,无需提供并发访问策略由于多个事务会同时访问第二级缓存中相同数据,因此必须提供适当的并发访问策略,来保证特定的事务隔离级别 数据过期策略没有提供数据过期策略。处于一级缓存中的对象永远不会过期,除非应用程序显式清空缓存或者清除特定的对象必须提供数据过期策略,如基于内存的缓存中的对象的最大数目,允许对象处于缓存中的最长时间,以及允许对象处于缓存中的最长空闲时间 物理存储介质内存内存和硬盘。对象的散装数据首先存放在基于内在的缓存中,当内存中对象的数目达到数据过期策略中指定上限时,就会把其余的对象写入基于硬盘的缓存中。缓存的软件实现 在Hibernate的Session的实现中包含了缓存的实现由第三方提供,Hibernate仅提供了缓存适配器(CacheProvider)。用于把特定的缓存插件集成到Hibernate中。启用缓存的方式只要应用程序通过Session接口来执行保存、更新、删除、加载和查询数据库数据的操作,Hibernate就会启用第一级缓存,把数据库中的数据以对象的形式拷贝到缓存中,对于批量更新和批量删除操作,如果不希望启用第一级缓存,可以绕过Hibernate API,直接通过JDBC API来执行指操作。用户可以在单个类或类的单个集合的粒度上配置第二级缓存。如果类的实例被经常读但很少被修改,就可以考虑使用第二级缓存。只有为某个类或集合配置了第二级缓存,Hibernate在运行时才会把它的实例加入到第二级缓存中。 用户管理缓存的方式第一级缓存的物理介质为内存,由于内存容量有限,必须通过恰当的检索策略和检索方式来限制加载对象的数目。Session的evit()方法可以显式清空缓存中特定对象,但这种方法不值得推荐。 第二级缓存的物理介质可以是内存和硬盘,因此第二级缓存可以存放大量的数据,数据过期策略的maxElementsInMemory属性值可以控制内存中的对象数目。

管理第二级缓存主要包括两个方面:选择需要使用第二级缓存的持久类,设置合适的并发访问策略:选择缓存适配器,设置合适的数据过期策略。

2. 一级缓存的管理: 当应用程序调用Session的save()、update()、savaeOrUpdate()、get()或load(),以及调用查询接口的 list()、iterate()或filter()方法时,如果在Session缓存中还不存在相应的对象,Hibernate就会把该对象加入到第一级缓存中。当清理缓存时,Hibernate会根据缓存中对象的状态变化来同步更新数据库。 Session为应用程序提供了两个管理缓存的方法: evict(Object obj):从缓存中清除参数指定的持久化对象。 clear():清空缓存中所有持久化对象。

3. 二级缓存的管理:

3.1. Hibernate的二级缓存策略的一般过程如下:

1) 条件查询的时候,总是发出一条select * from table_name where …. (选择所有字段)这样的SQL语句查询数据库,一次获得所有的数据对象。

2) 把获得的所有数据对象根据ID放入到第二级缓存中。

3) 当Hibernate根据ID访问数据对象的时候,首先从Session一级缓存中查;查不到,如果配置了二级缓存,那么从二级缓存中查;查不到,再查询数据库,把结果按照ID放入到缓存。

4) 删除、更新、增加数据的时候,同时更新缓存。

Hibernate的二级缓存策略,是针对于ID查询的缓存策略,对于条件查询则毫无作用。为此,Hibernate提供了针对条件查询的Query Cache。

3.2. 什么样的数据适合存放到第二级缓存中? 1 很少被修改的数据 2 不是很重要的数据,允许出现偶尔并发的数据 3 不会被并发访问的数据 4 参考数据,指的是供应用参考的常量数据,它的实例数目有限,它的实例会被许多其他类的实例引用,实例极少或者从来不会被修改。

3.3. 不适合存放到第二级缓存的数据? 1 经常被修改的数据 2 财务数据,绝对不允许出现并发 3 与其他应用共享的数据。

3.4. 常用的缓存插件 Hibernater 的二级缓存是一个插件,下面是几种常用的缓存插件:

EhCache:可作为进程范围的缓存,存放数据的物理介质可以是内存或硬盘,对Hibernate的查询缓存提供了支持。

OSCache:可作为进程范围的缓存,存放数据的物理介质可以是内存或硬盘,提供了丰富的缓存数据过期策略,对Hibernate的查询缓存提供了支持。

SwarmCache:可作为群集范围内的缓存,但不支持Hibernate的查询缓存。

JBossCache:可作为群集范围内的缓存,支持事务型并发访问策略,对Hibernate的查询缓存提供了支持。

3.5. 配置二级缓存的主要步骤:

1) 选择需要使用二级缓存的持久化类,设置它的命名缓存的并发访问策略。这是最值得认真考虑的步骤。

2) 选择合适的缓存插件,然后编辑该插件的配置文件。

Spring

1. 你一般用spring做什么?

控制反转IOC AOP

2. spring中的哪个类的哪个方法可用于获取bean

3. spring是什么?根据你的理解详细谈谈你的见解。

◆目的:解决企业应用开发的复杂性

◆功能:使用基本的JavaBean代替EJB,并提供了更多的企业应用功能

◆范围:任何Java应用

简单来说,Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只

有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外,Spring是非侵入式的:典型地,Spring应用中的对象不依赖于Spring的特定类。

◆控制反转——Spring通过一种称作控制反转(IoC)的技术促进了松耦合。当应用了IoC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖,而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

◆面向切面——Spring提供了面向切面编程的丰富支持,允许通过分离应用的业务逻辑与系统级服务(例如审计(auditing)和事务()管理)进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责(甚至是意识)其它的系统级关注点,例如日志或事务支持。

◆容器——Spring包含并管理应用对象的配置和生命周期,在这个意义上它是一种容器,你可以配置你的每个bean如何被创建——基于一个可配置原型(prototype),你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而,Spring不应该被混同于传统的重量级的EJB容器,它们经常是庞大与笨重的,难以使用。

◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中,应用对象被声明式地组合,典型地是在一个XML文件里。Spring也提供了很多基础功能(事务管理、持久化框架集成等等),将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

4. 项目中如何体现Spring中的切面编程,距离说明。

面向切面编程:主要是横切一个关注点,将一个关注点模块化成一个切面。在切面上声明一个通知(Advice)和切入点(Pointcut); 通知: 是指在切面的某个特定的连接点(代表一个方法的执行。通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知(Advice)的主体部分获得连接点信息。)上执行的动作。通知中定义了要插入的方法。切入点:切入点的内容是一个表达式,以描述需要在哪些对象的哪些方法上插入通知中定义的方法。

项目中用到的Spring中的切面编程最多的地方:声明式事务管理。

a、定义一个事务管理器

b、配置事务特性(相当于声明通知。一般在业务层的类的一些方法上定义事务)

c、配置哪些类的哪些方法需要配置事务(相当于切入点。一般是业务类的方法上)

5. spring中可以用注入获得属性值,还有其他的方式吗?

读取配置文件

6. spring在项目中如何充当粘合剂

1、在项目中利用spring的IOC(控制反转或依赖注入),明确地定义组件接口(如UserDAO),开发者可以独立开发各个组件, 然后根据组件间的依赖关系组装(UserAction依赖于UserBiz,UserBiz依赖于UserDAO)运行,很好的把Struts(Action)和hibernate(DAO的实现)结合起来了。

2、spring的事务管理把hibernate对数据库的操作进行了事务配置。

7. spring的事务如何配置

spring的声明式事务配置:

1.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

/WEB-INF/classes/hibernate.cfg.xml

2. 配置事务管理器

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

3. 配置事务特性

4. 配置哪些类的哪些方法配置事务

isolation设定事务的隔离级别,事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据。

定义的5个不同的事务隔离级别:

DEFAULT:默认的隔离级别,使用数据库默认的事务隔离级别

READ_COMMITTED:保证一个事务修改的数据提交后才能被另外一个事务读龋另外一个事务不能读取该事务未提交的数据。这种事务隔离级别可以避免脏读出现,但是可能会出现不可重复读和幻像读。

READ_UNCOMMITTED:这是事务最低的隔离级别,它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读,不可重复读和幻像读。

REPEATABLE_READ:这种事务隔离级别可以防止脏读,不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外,还保证了避免不可重复读。

SERIALIZABLE:这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读,不可重复读外,还避免了幻像读。

propagation定义了7个事务传播行为

REQUIRED: 如果存在一个事务,则支持当前事务。如果没有事务则开启一个新的事务。

SUPPORTS: 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行。但是对于事务同步的事务管理器,SUPPORTS与不使用事务有少许不同。

REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在,则将这个存在的事务挂起。 NOT_SUPPORTED 总是非事务地执行,并挂起任何存在的事务。

NEVER 总是非事务地执行,如果存在一个活动事务,则抛出异常

NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。

嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时,会回滚内层事务所做的动作。而内层事务操作失败并不会引起外层事务的回滚。

REQUIRED应该是我们首先的事务传播行为。它能够满足我们大多数的事务需求。

8. transaction有那几种实现(事务处理)(Spring)

在Spring中,事务处理主要有两种方式

(1) 代码控制事务

在程序中引入新的模版类,这个类封装了事务管理的功能

(2) 参数配置控制事务,在Application-Context.xml增加一个事务代理(UserDAOProxy)配置

2. IBATIS中的事物属性怎么配置

SQL MAP XML配置文件中的transactionManager

IBM、SUN等公司的Java面试题集2016-12-01 23:59:52 | #2楼回目录

IBM、SUN等公司的Java面试题集

找工作要面试,有面试就有对付面试的办法。以下一些题目来自我和我朋友痛苦的面试经历,提这些问题的公司包括IBM, E*Trade, Siebel, Motorola, SUN, 以及其它大小公司。

IBM、SUN等公司的Java面试题集上 2:IBM、SUN等公司的Java面试题集下

面试是没什么道理可讲的,它的题目有的不合情理、脱离实际。有在纸上写的,有当面考你的,也有在电话里问的,给你IDE的估计很少(否则你赶快去买彩票, 说不定中)。所以如果你看完此文后,请不要抱怨说这些问题都能用IDE来解决。你必须在任何情况下准确回答这些问题,在面试中如果出现一两题回答不准确很 有可能你就被拒之门外了。

当然这些都是Java的基本题,那些面试的人大多数不会问你Hibernate有多先进,Eclipse的三个组成部分,或command design pattern,他们都是老一辈了,最喜欢问的就是基础知识。别小看了这些基础,我朋友水平一流,结果就栽在一到基础知识的问题下,和高薪无缘。

第一,谈谈final, finally, finalize的区别。

最常被问到。

第二,Anonymous Inner Cla(匿名内部类) 是否可以extends(继承)其它类,是否可以implements(实现)interface(接口)?

第三,Static Nested Cla和 Inner Class的不同,说得越多越好(面试题有的很笼统)。

第四,&和&&的区别。

这个问得很少。

第五,HashMap和Hashtable的区别。

常问。

第六,Collection 和 Collections的区别。

你千万别说一个是单数一个是复数。

第七,什么时候用assert。

API级的技术人员有可能会问这个。

第八,GC是什么? 为什么要有GC?

基矗

第九,String s = new String(xyz);创建了几个String Object?

第十,Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

第十一,short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

面试题都是很变态的,要做好受虐的准备。

第十二,sleep() 和 wait() 有什么区别?

搞线程的最爱。

第十三,Java有没有goto?

很十三的问题,如果哪个面试的问到这个问题,我劝你还是别进这家公司。

1、final。它可以用于以下四个地方:

定义变量,包括静态的和非静态的。

定义方法的参数。

定义方法。

定义类。

我们依次来回顾一下每种情况下final的作用。首先来看第一种情况,如果final修饰的是一个基本类型,就表示这个变量被赋予的值是不可变的,即它是个常量;如果final修饰的是一个对象,就表示这个变量被赋予的引用是不可变的,这里需要提醒大家注意的是,不可改变的只是这个变量所保存的引用,并不是这个引用所指向的对象。在第二种情况下,final的含义与第一种情况相同。实际上对于前两种情况,有一种更贴切的表述final的含义的描述,那就是,如果一个变量或方法参数被final修饰,就表示它只能被赋值一次,但是JAVA虚拟机为变量设定的默认值不记作一次赋值。

被final修饰的变量必须被初始化。初始化的方式有以下几种:

在定义的时候初始化。

final变量可以在初始化块中初始化,不可以在静态初始化块中初始化。

静态final变量可以在静态初始化块中初始化,不可以在初始化块中初始化。final变量还可以在类的构造器中初始化,但是静态final变量不可以。

通过下面的代码可以验证以上的观点:

Java代码

public claFinalTest {

// 在定义时初始化

public final int A = 10;

public final int B;

// 在初始化块中初始化

{

B = 20;

}

// 非静态final变量不能在静态初始化块中初始化// public final int C;

// static {

// C = 30;

// }

// 静态常量,在定义时初始化

public static final int STATIC_D = 40;

public static final int STATIC_E;

// 静态常量,在静态初始化块中初始化

static {

STATIC_E = 50;

}

// 静态变量不能在初始化块中初始化

// public static final int STATIC_F;// {

// STATIC_F = 60;

// }

public final int G;

// 静态final变量不可以在构造器中初始化// public static final int STATIC_H;

// 在构造器中初始化

public FinalTest() {

G = 70;

// 静态final变量不可以在构造器中初始化// STATIC_H = 80;

// 给final的变量第二次赋值时,编译会报错

// A = 99;

// STATIC_D = 99;

}

// final变量未被初始化,编译时就会报错

// public final int I;

// 静态final变量未被初始化,编译时就会报错

// public static final int STATIC_J;

}

我们运行上面的代码之后出了可以发现final变量(常量)和静态final变量(静态常量)未被初始化时,编译会报错;另外还可以发现,静态final变量可以在构造器中初始化,却不可以在初始化块中初始化。

用final修饰的变量(常量)比非final的变量(普通变量)拥有更高的效率,因此我们在实际编程中应该尽可能多的用常量来代替普通变量,这也是一个很好的编程习惯。

当final用来定义一个方法时,会有什么效果呢?正如大家所知,它表示这个方法不可以被子类重写,但是它这不影响它被子类继承。我们写段代码来验证一下:Java代码

claParentCla{

public final void TestFinal() {

System.out.println("父类--这是一个final方法");

}

}

public claSubClaextends ParentCla{

/**

* 子类无法重写(override)父类的final方法,否则编译时会报错*/

// public void TestFinal() {

// System.out.println("子类--重写final方法");

// }

public static void main(String[] args) {

SubClasc = new SubClass();

sc.TestFinal();

}

}

这里需要特殊说明的是,具有private访问权限的方法也可以增加final修饰,但是由于子类无法继承private方法,因此也无法重写它。编译器在处理private方法时,是按照final方法来对待的,这样可以提高该方法被调用时的效率。不过子类仍然可以定义同父类中的private方法具有同样结构的方法,但是这并不会产生重写的效果,而且它们之间也不存在必然联系。

最后我们再来回顾一下final用于类的情况。这个大家应该也很熟悉了,因为我们最常用的String类就是final的。由于final类不允许被继承,编译器在处理时把它的所有方法都当作final的,因此final类比普通类拥有更高的效率。final的类的所有方法都不能被重写,但这并不表示final的类的属性(变量)值也是不可改变的,要想做到final类的属性值不可改变,必须给它增加final修饰,请看下面的例子:

Java代码

public final claFinalTest {

int i = 10;

public static void main(String[] args) {

FinalTest ft = new FinalTest();

ft.i = 99;

System.out.println(ft.i);

}

}

运行上面的代码试试看,结果是99,而不是初始化时的10。

接下来我们一起回顾一下finally的用法。这个就比较简单了,它只能用在try/catch语句中,并且附带着一个语句块,表示这段语句最终总是被执行。请看下面的代码:

Java代码

public final claFinallyTest {

public static void main(String[] args) {

try {

throw new NullPointerException();

} catch (NullPointerException e) {

System.out.println("程序抛出了异常");

} finally {

System.out.println("执行了finally语句块");

}

}

}

运行结果说明了finally的作用:

程序抛出了异常

执行了finally语句块

请大家注意,捕获程序抛出的异常之后,既不加处理,也不继续向上抛出异常,并不是良好的编程习惯,它掩盖了程序执行中发生的错误,这里只是方便演示,请不要学习。

那么,有没有一种情况使finally语句块得不到执行呢?大家可能想到了

return、continue、break这三个可以打乱代码顺序执行语句的规律。那我们就来试试看,这三个语句是否能影响finally语句块的执行:

Java代码

public final claFinallyTest {

// 测试return语句

public ReturnClatestReturn() {

try {

return new ReturnClass();

} catch (Exception e) {

e.printStackTrace();

} finally {

System.out.println("执行了finally语句");

}

return null;

}

// 测试continue语句

public void testContinue() {

for (int i = 0; i < 3; i++) {

try {

System.out.println(i);

if (i == 1) {

continue;

}

} catch (Exception e) {

e.printStackTrace();

} finally {

System.out.println("执行了finally语句");}

}

}

// 测试break语句

public void testBreak() {

for (int i = 0; i < 3; i++) {

try {

System.out.println(i);

if (i == 1) {

break;

}

} catch (Exception e) {

e.printStackTrace();

} finally {

System.out.println("执行了finally语句");}

}

}

public static void main(String[] args) {

FinallyTest ft = new FinallyTest();

// 测试return语句

ft.testReturn();

System.out.println();

// 测试continue语句

ft.testContinue();

System.out.println();

// 测试break语句

ft.testBreak();

}

}

claReturnCla{

public ReturnClass() {

System.out.println("执行了return语句");

}

}

上面这段代码的运行结果如下:

执行了return语句

执行了finally语句

执行了finally语句

1

执行了finally语句

2

执行了finally语句

执行了finally语句

1

执行了finally语句

很明显,return、continue和break都没能阻止finally语句块的执行。从输出的结果来看,return语句似乎在finally语句块之前执行了,事实真的如此吗?我们来想想看,return语句的作用是什么呢?是退出当前的方法,并将值或对象返回。如果finally语句块是在return语句之后执行的,那么return语句被执行后就已经退出当前方法了,finally语句块又如何能被执行呢?因此,正确的执行顺序应该是这样的:编译器在编译return new ReturnClass();时,将它分成了两个步骤,new ReturnClass()和return,前一个创建对象的语句是在finally语句块之前被执行的,而后一个return语句是在finally语句块之后执行的,也就是说finally语句块是在程序退出方法之前被执行的。同样,finally语句块是在循环被跳过(continue)和中断(break)之前被执行的。

最后,我们再来看看finalize,它是一个方法,属于java.lang.Object类,它的定义如下:

Java代码

protected void finalize() throws Throwable { }

众所周知,finalize()方法是GC(garbage collector)运行机制的一部分,关于GC的知识我们将在后续的章节中来回顾。

在此我们只说说finalize()方法的作用是什么呢?

finalize()方法是在GC清理它所从属的对象时被调用的,如果执行它的过程中抛出了无法捕获的异常(uncaught exception),GC将终止对改对象的清理,

并且该异常会被忽略;直到下一次GC开始清理这个对象时,它的finalize()会被再次调用。

请看下面的示例:

Java代码

public final claFinallyTest {

// 重写finalize()方法

protected void finalize() throws Throwable {

System.out.println("执行了finalize()方法");

}

public static void main(String[] args) {

FinallyTest ft = new FinallyTest();

ft = null;

System.gc();

}

}

运行结果如下:

执行了finalize()方法

程序调用了java.lang.System类的gc()方法,引起GC的执行,GC在清理ft对象时调用了它的finalize()方法,因此才有了上面的输出结果。调用System.gc()等同于调用下面这行代码:

Java代码

Runtime.getRuntime().gc();

调用它们的作用只是建议垃圾收集器(GC)启动,清理无用的对象释放内存空间,但是GC的启动并不是一定的,这由JAVA虚拟机来决定。直到JAVA虚拟机停止运行,有些对象的finalize()可能都没有被运行过,那么怎样保证所有对象的这个方法在JAVA虚拟机停止运行之前一定被调用呢?答案是我们可以调用System类的另一个方法:

Java代码

public static void runFinalizersOnExit(boolean value) {

//other code

}

给这个方法传入true就可以保证对象的finalize()方法在JAVA虚拟机停止运

行前一定被运行了,不过遗憾的是这个方法是不安全的,它会导致有用的对象finalize()被误调用,因此已经不被赞成使用了。

由于finalize()属于Object类,因此所有类都有这个方法,Object的任意子类都可以重写(override)该方法,在其中释放系统资源或者做其它的清理工作,如关闭输入输出流。

IBM、SUN等公司的Java面试题集2016-12-02 00:01:55 | #3楼回目录

IBM、SUN等公司的Java面试题集

找工作要面试,有面试就有对付面试的办法。以下一些题目来自我和我朋友痛苦的面试经历,提这些问题的公司包括IBM, E*Trade, Siebel, Motorola, SUN, 以及其它大小公司。

IBM、SUN等公司的Java面试题集上 2:IBM、SUN等公司的Java面试题集下

面试是没什么道理可讲的,它的题目有的不合情理、脱离实际。有在纸上写的,有当面考你的,也有在电话里问的,给你IDE的估计很少(否则你赶快去买彩票, 说不定中)。所以如果你看完此文后,请不要抱怨说这些问题都能用IDE来解决。你必须在任何情况下准确回答这些问题,在面试中如果出现一两题回答不准确很 有可能你就被拒之门外了。

当然这些都是Java的基本题,那些面试的人大多数不会问你Hibernate有多先进,Eclipse的三个组成部分,或command design pattern,他们都是老一辈了,最喜欢问的就是基础知识。别小看了这些基础,我朋友水平一流,结果就栽在一到基础知识的问题下,和高薪无缘。

第一,谈谈final, finally, finalize的区别。

最常被问到。

第二,Anonymous Inner Cla(匿名内部类) 是否可以extends(继承)其它类,是否可以implements(实现)interface(接口)?

第三,Static Nested Cla和 Inner Class的不同,说得越多越好(面试题有的很笼统)。

第四,&和&&的区别。

这个问得很少。

第五,HashMap和Hashtable的区别。

常问。

第六,Collection 和 Collections的区别。

你千万别说一个是单数一个是复数。

第七,什么时候用assert。

API级的技术人员有可能会问这个。

第八,GC是什么? 为什么要有GC?

基矗

第九,String s = new String(xyz);创建了几个String Object?

第十,Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

第十一,short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

面试题都是很变态的,要做好受虐的准备。

第十二,sleep() 和 wait() 有什么区别?

搞线程的最爱。

第十三,Java有没有goto?

很十三的问题,如果哪个面试的问到这个问题,我劝你还是别进这家公司。

回复帖子
标题:
内容:
相关话题
相关帖子推荐