IT面试笔试题全集-史上-JAVA篇4-Rain系列

IT面试笔试题全集—史上最全_JAVA篇4_Rain系列

JSF如何进行表格逐理及取值？

—追雨制作

importjavax.faces.model.DataModel;

importjavax.faces.model.ListDataModel;

DataModd:代表一个表格，其可以从客户端传上来。

实例化：

DataModeldm=newListDataModel();

将一个list值放入到DataModel中.

dm.setWrappedData(list)

将客户端当前行取出

(LogsVO)dm.getRowData()

对于多条的查询及增删改在模型中加入了如下属性：

模型的名称是bean,其下的属性是

DataModeldm:代表返有的行数据

VOvo:代表一行数据。

取一行：

vo=(VO)dm.getRowData();

通#{bean.vo.属性名},如果修改对应信息自动修改。

增加一行：

this.vo=newV0();

通#{bean.vo.属性名},显示肯定无值，但客户输入值提交后会将值勤写入

JSF面试题：Jsf中导航的标签是什么?

追雨制作

<navigation-rule>

<from-view-id>/main.jsp

</from-view-id>

<navigation-case>

<from-outcome>success

</from-outcome>

/result.jsp

</to-view-id>

</navigation-case>

</navigation-rule>

JSF面试题：如何管量web层中的Bean,用什么标签。如何通过jsp

页面与Bean绑定在一起进行处理？

—追雨制作

<managed-bean>

<managed-bean-name>checkNumber

</managed-bean-name>

<managed-bean-class>jsfl.CheckNumber

</managed-bean-class>

<managed-bean-scope>session

</managed-bean-scope>

</managed-bean>

JSF面试题：Jsf中的核心类用那些?有什么作用？LiftCycle六大生命

周期是什么？

一追雨制作

JSP的核心类主要有

FacesServlet

LiftCycleFacesContext

LiftCycle的生命周期是：恢复视图，应用请求值，校验，更新模型。调用应用程序-

＞呈现响应

介绍一下ibatis的核心类？

一追雨制作

SqlMapClientBuilder:加载配置文件，返RI一个会话。

SqlMapClient:具体的会话

Listlist=queryForList（

标签名

,object）;

Objectobj=queryForObject（

标签名

,object）;

delete（

标签名

,object）

update（

标签名

,object）

insert（

标签名

,object）

工程的使用：

将ibatisfactory拷贝到工程目录下

将ms的3个包及ibatis的三个包拷贝到/WEB-INF/lib下

修改ibatisfhctory中的abatorConfig.xml文件

进入ibatisfactory目录运行java-jarabator.jarabatorConfig.xmlue

将sql标记、select>update>insert、delete的副本删除

spring

amp;ibatis:

dataSource

sqlMapClient:SqlMapClientFactoryBean

configLocation

classpath:sqlMapClient.xml

/WEB-INF/sqlMapClient.xml

dataSource

ansactionManager:DataSourceTransactionManager

dataSource

customerDaoextendsSqlMapClientDaoSupport

sqlMapClient

buyDao

sqlMapClient

Facade

buyDao

customerDao

absactProxy:TransactionProxyFactoryBean

ansactionManager

ansactionAtibutes

facadeProxy

target:fa?ade

ibatis的核心配置文件都有什么？

_追雨制作

sqlmapclient.xml：数据库连接及相关o/rMapping的映射文件

(hibemate.cfg.xml)

sqlmapBuy.xml:具体的o/rmapping映射(*.hbm.xml)

四大标记：

select

update

delete

insert

procedure

描述Cookie和Session的作用,区别和各自的应用范围,SessionI

作原理。

_追雨制作

Cookie:主要用在保存客户端，其值在客户端与服务端之间传送，不

安全，存储的数据量有限。

Session:保存在服务端，每一个session在服务端有-一个sessionlD作一个标识。存

储的数据量大，安全性高。占用服务端的内存资源。

简单说说tomcat的配置？

一追雨制作

JAVA_HOME=JDK的根目录

CATALINA_HOME=tomcat的根目录

CATALINA-HOME\conf\server.xml:可以配置tomcat的端口，可以配置tomcat中下

连接池。

CATALINA-HOME\common\lib:存放公用的类包

在Myeclipse中如何配置tomcat

在eclipse中，选择windows->preference->MyEclipse->ApplicationServer->Tomcat

选择Tomcat的安装目录，并选择TomCat所需的jdk,选择enable,确定即可。

简述你对Statement,PreparedStatement,CallableStatement的理解

—追雨制作

statement用于执行静态SQL语句并返回它所生成结果的对象，在执

行时确定sqlo

PreparedStatement表示预编译的SQL语句的对象。SQL语句被预编译并且存储在

PreparedStatement对象中。然后可以使用此对象高效地多次执行该语句，可以传参

数，在得到PreparedStatement对象时确定sql.

CallableStatement用于执行SQL存储过程的接口。如果有输出参数要注册说明是输

出参数。

如何用Java判断一个文件或目录是否存在?

—追雨制作

Filef=newFile(

C:\\entityBean

)；

ifi(f.exists())

System.out.println(

exist

)；

else

System.out.println(

notexist

);

如何用Java实现列出某个目录下的所有子目录？

—追雨制作

publicstaticvoidmain(Sing[]args)throwsException

getFile(newFile(

C:\\entityBean

),

publicstaticvoidgetFile(File[Singsem)throwsException

ji

System.out.println(sem+f.getName());

Filefl[]=f.listFiles();

if(fl.length>=l)

for(inti=0;i

<fl.length;i++)

if(fl[i].isDirectory())

getFile(fl[i],sem+

)；

请用Java实现列出某个目录下的所有文件

—追雨制作

Importjava.io.File;

Filef=newFile(

C:\\

)；

File[]fl=f.listFiles();

fbr(inti=0;i

<fl.length;i++)

if(fl[i].isDirectory())

System.out.println(

dirctoryis

+fl[i].getName());

)

else

System.out.println(

fileis

+fl[i].getName());

介绍一下Java的输入输出流

追雨制作

在java使用流的机制进行数据的传送，从文件到内存是输入流，从

内存到文件是输出流，输入流可以通过read读取，输出流以write或print写入，

对于流可以是分为高层流和低层流，低层以一个字节或字符为单位进行处理，高层

流以一批数据为单位进行处理。

FilelnputSeam（System.in）至InputSteamReader至BuffferReader

OutputSteam（System.out）至printSeam

FileReader至BufferedReader

FileWriter至PrintWriter或bufferWriter

分类：

字节（二进制）

FilelnputSeam（低层输入流）

FileOutputSeam（低层输出流）

PrintSeam（高层流）System.out.println（）

字符（一-个char）

FileReader

FileWriter

线程的基本概念、线程的基本状态以及状态之间的关系

一追雨制作

线程是进程内的并发，没有自己内存空间，共享进程的，线程间的

通信成本较低。

Java中的线程有四种状态分别是：运行、就绪、挂起、结束。

java中有几种类型的流？JDK.为每种类型的流提供了一些抽象类以供

继承，请说出他们分别是哪些类？

—追雨制作

字节流，字符流。字节流继承于InputSeamOutputSeam,字符流继

承于ReaderWriter。在java.io包中还有许多其他而流，低层流与调层流，高层流

主要是为了提高性能和使用方便。

Set里的元素是不能重复的，那么用什么方法来区分重复与否呢？是

用==还是equals()?它们有何区别?用contains来区分是否有重复的对象。还是都不

用。

—追雨制作

在比较时先调用hashCode方法，如果不相同，证明不相等。

如果相同，再调用equals方法，如果equals方法相同，证明相等，不相同，证明

不相等。

==:主要用在基本数据类型及引用

Equals:主要是对象或对象引用的比较。

集合中是否包含某一个元素用contains来判断。

请用用java代码写一个堆栈

一追雨制作

publicclassStack{

int[]data;

intmaxSize;

inttop;

publicStack(intmaxSize){

this.maxSize=maxSize;

data=newint[maxSize];

top=-1;

*依次加入数据

*@paramdata要加入的数据

*@retum添加是否成功

*/

publicbooleanpush(intdata){

if(top+l==maxSize){

System.out.println(

栈已满!

）；

returnfalse;

this.data[-H-top]=data;

returnue;

*从栈中取出数据

*@retum取出的数据

*/

publicintpop()throwsException{

if(top==-l){

thrownewException(

栈已空！

)；

)

returnthis.data[top-];

publicstaticvoidmain(Sing[]args)throwsException{

Stackstack=newStack(lOOO);

stack.push(l);

stack.push(2);

stack.push(3);

stack.push(4);

stack.push(5);

while(stack.top>=0)

System.out.println(stack.pop());

java中实现多态的机制是什么？

一追雨制作

静态的多态:方法名相同，参数个数或类型不相同。(overloading)

动态的多态：

子类覆盖父类的方法，将子类的实例传与父类的引用调用的是子类的方法

实现接口的实例传与接口的引用调用的实现类的方法。

编码转换，怎样实现将GB2312编码的字符串转换为ISO-8859-1编

码的字符串。

—追雨制作

Singa=newSing(

中

,getBytes(

gb2312

#8243;),

iso-8859-1

#8243;);

Singa=newSing(

中

.getBytes(

iso-8859-1

#8243;));

Java如何格式化日期？

—追雨制作

Importjava.text.SimpleDateFormat;

SimpleDateFormatsdf=newSimpleDateFormat(

yyyy-MM-ddhh:mm:ss

)；

Datedat=newDate();

〃把日期转化为字符串

Sings=sdf.fdrmat(dat);

System.out.println(s);

〃将字符串转化为日期

Java.util.Dated1=sdf.parse("yyyy-mm-dd");

如何获取某个日期是当月的最后-•天

一追雨制作

当前日期加一天，若当前日期与结果的月份不相同，就是最后一

天。

取下一个月的第一天，下一个月的第一天-1

publicstaticvoidmain(Sing[]args)

Calendarc=Calendar.get!nstance();

c.set(Calendar.YEAR,2004);

c.set(Calendar.MONTH,0);

c.set(Calendar.DAY_OF_MONTH,30);

Calendarcl=(Calendar)c.clone();

System.out.println(c.get(Calcndar.YEAR)+

#8220;+(c.get(Calendar.MONTH)+1)+

#8220;+c.get(Calendar.DAY_OF_MONTH));

c.add(Calendar.DAY_OF_MONTH,1);

if(c.get(Calendar.MONTH)!=cl.get(Calendar.MONTH))

System.out.println(

是最后一天

)；

else

System,out.println(

不是取后一关

)；

如何唤起类中的一个方法

一追雨制作

产生一个Class数组，说明方法的参数

通过Class对象及方法参数得到Method

通过method.invoke（实例渗数值数组）唤醒方法

得到Class的三个过程是什么

一追雨制作

对象.getClass。

类.class或Integer.type(int)Integer.class(java.lang.Integer)

Class.forName();

类的返射机制中的包及核心类

一追雨制作

java.lang.Class

java.lang.rcfrcction.Method

java.lang.rcfrcction.Field

java.lang.rcfrcction.Consuctor

java.lang.rcfrcction.Modifier

java.lang.rcfrcction.Interface

什么是类的返射机制

一追雨制作

通过类（Class对象），可以得出当前类的fields、method、consutor、

interface、superClass、modified等，同是可以通过类实例化一个实例、设置属性、

唤醒方法。Spring中一切都是返射、suts、hibernate都是通过类的返射进行开发

的。

Final类有什么特点

—追雨制作

属性常量

方法不可以overridding

类不可以继承

排序都有哪儿种方法？请列举。用JAVA实现…个快速排序？

—追雨制作

排序的方法有：插入排序（直接插入排序、希尔排序），交换排序

（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配

排序（箱排序、基数排序）

用Java语言实现的各种排序，包括插入排序、冒泡排序、选择排序、Shell排

序、快速排序、归并排序、堆排序、SortUtil等。

插入排序：

packageorg.rut.utiLalgorithm.support;

importorg.rut.util.algorithiTi.SortUtil;

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassInsertSortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.utiLalgorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

inttemp;

fbr(inti=l;i

<data.length;i++){

fbr(intj=i;(j>0)

amp;

amp;(data[j]

<data{j-l])y

){

Sort(Jtil.swap(data,j,j-1);

冒泡排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassBubbleSortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

inttemp;

fbr(inti=0;i

<data.length;i++){

fbr(intj=data.length-1;j>i;j

){

if(data[j]

<data[j-l]){

SortUtil.swap(data,j,j-l);

选择排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassSelectionSortimplementsSortUtil.Sort{

/*

*(non-Javadoc)

*

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

inttemp;

for(inti=0;i

<data.length;i++){

intlowlndex=i;

for(intj=data.length

)(

if(data[j]

<dataflowIndex]){

lowlndex=j;

SortUtil.swap(data,iJowIndex);

}

Shell排序:

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassShellSortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

fbr(inti=data.length/2;i>2;i/=2){

fbr(intj=O;j

<i；j++){

insertSort(data,j,i)；

}

}

insertSort(data,0,l);

*@paramdata

*@paramj

*@parami

*/

privatevoidinsertSort(int[]data,intstart,intinc){

inttemp;

fbr(inti=start+inc;i

<data.length;i+=inc){

fdr(intj=i;(j>=inc)

amp;

amp;(data[j]

<data[j-inc]);j-=inc){

SortUtil.swap(dataj,j-inc);

i

J

}

}

}

快速排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassQuicksortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

quickSort(data,0,data.length-1);

privatevoidquickSort(int[]data,inti,intj){

intpivotIndex=(i+j)/2;

//swap

SortUtil.swap(data,pivotindex,j);

intk=partition(data,i-l,j,data[j]);

SortUtil.swap(data,k,j);

if((k-i)>l)quickSort(data,i,k-1);

if((j-k)>l)quickSort(data,k+1j);

*@paramdata

*@parami

*@paramj

*@retum

*/

privateintpartition(int[]data,int1,intr,intpivot){

do{

while(data[++l]

<pivot);

while((r!=O)

amp;

amp;data[—r]>pivot);

SortUtil.swap(data,l,r);

}

while(l

<r)；

SortUtiLswap(data,l,r);

return1;

)

}

改进后的快速排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassImprovedQuickSortimplementsSortUtil.Sort{

privatestaticintMAX_STACK_SIZE=4096;

privatestaticintTHRESHOLD=10;

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

int[]stack=newint[MAX_STACK_SIZE];

inttop=-1;

intpivot;

intpivotindex,l,r;

stack[+4-top]=0;

stack[++top]=data.length-1;

while(top>0){

intj=stack[top-];

inti=stack[top-];

pivotlndex=(i+j)/2;

pivot=data[pivotlndex];

SortUtil.swap(data,pivotindex,j);

//partition

l=i-l;

r=j；

do{

while(data[-H-l]

<pivot);

while((r!=O)

amp;

amp;(data[—r]>pivot));

SortUtil.swap(data,l,r);

i

while(l

<r)；

SortUtil.swap(data,l,r);

SortUtil.swap(data,l,j);

if((l-i)>THRESHOLD){

stack[++top]=i;

stack[++top]=l-l;

i

J

if((j-I)>THRESHOLD){

stack[++top]=l+l;

stack[++top]=j;

//newInsertSort().sort(data);

insertSort(data);

*@paramdata

*/

privatevoidinsertSort(int[]data){

inttemp;

fbr(inti=l;i

<data.length;i++){

fbr(intj=i;(j>O)

amp;

amp;(data[j]

<data[j-l]);j

){

Sort(Jtil.swap(data,j,j-1);

)

}

归并排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassMergeSortimplementsSortUtil.Sort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

int[]temp=newint[data.length];

mergeSort(data,temp,0,data.length-1);

j

privatevoidmergeSort(int[]data,int[]temp,intl,intr){

intmid=(l+r)/2;

if(l==r)return;

mergeSort(data,temp,1,mid);

mergeSort(data,temp,mid+1,r);

fbr(inti=l;i

<=r;i-H-){

temp[i]=data[i];

)

intil=l;

inti2=mid+l;

fbr(intcur=l;cur

<=r;cur++){

if(il==mid+l)

data[cur]=temp[i2-H-];

elseif(i2>r)

data[cur]=temp[il-H-];

elseif(temp[il]

<temp[i2])

data[cur]=temp[il++];

else

data[cur]=temp[i2++];

f

)

}

改进后的归并排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassImprovedMergeSortimplementsSortUtil.Sort{

privatestaticfinalintTHRESHOLD=10;

/*

*(non-Javadoc)

*

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

int[]temp=newint[data.length];

mergeSort(data,temp,0,data.length-1);

f

privatevoidmergeSort(int[]data,int[]temp,int1,intr){

inti,j,k；

intmid=(1+r)/2;

if(l==r)

return;

if((mid

1)>=THRESHOLD)

mergeSort(data,temp,1,mid);

else

insertSort(data,1,mid

1+1)；

if((r

mid)>THRESHOLD)

mergeSort(data,temp,mid+1,r);

else

insertSort(data,mid+1,r

mid);

for(i=1;i

<=mid;i++){

temp[i]=data[i];

f

fbr(j=l；j

<=r

mid;j++){

temp[r-j+1]=data[j+mid];

inta=temp[l];

intb=temp[r];

fbr(i=I,j=r,k=l;k

<=r;k++){

if(a

<b){

data[k]=temp[i++]；

a=temp[i];

}else{

data[k]=temp[j-];

b=temp[j];

*@paramdata

*@param1

*@parami

*/

privatevoidinsertSort(int[]data,intstart,intlen){

fbr(inti=start+l;i

<start+len;i++){

fbr(intj=i;(j>start)

amp;

amp;data[j]

<data[j-l];j

)(

SortUtil.swap(data,j,j-l);

堆排序：

packageorg.rut.util.algorithm.support;

importorg.rut.util.algorithm.SortUtil;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassHeapSortimplementsSortUtiLSort{

/*(non-Javadoc)

*@seeorg.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

publicvoidsort(int[]data){

MaxHeaph=newMaxHeap();

h.init(data);

fbr(inti=0;i

<data.length;i++)

h.remove();

System.arraycopy(h.queue,1,data,O,data.length);

f

privatestaticclassMaxHeap{

voidinit(int[]data){

this.queue=newint[data.length+1]；

for(inti=0;i

<data.length;i++){

queue[++size]=data[i];

fixUp(size);

)

privateintsize=O;

privateint[]queue;

publicintget(){

returnqueuefl];

publicvoidremove(){

SortUtil.swap(queue,l,size

)；

fixDown(l);

//fixdown

privatevoidfixDown(intk){

intj;

while((j=k

<

<1)

<=size){

if(j

<size

amp;

amp;queue[j]

<queue[j+l])

j++;

if(queue[k]>queue[j])//不用交换

break;

SortUtil.swap(queueJ,k);

k=j；

}

ji

privatevoidfixUp(intk){

while(k>1){

intj=k»1;

if(queue[j]>queue[k])

break;

SortUtil.swap(queueJ,k);

k=j；

}

)

f

\

f

SortUtil：

packageorg.rut.util.algorithm;

importorg.rut.util.algorithm.support.BubbleSort;

importorg.rut.utiLalgorithm.support.HeapSort;

importorg.rut.util.algorithm.support.ImprovedMergeSort;

importorg.rut.util.algorithm.support.ImprovedQuickSort;

importorg.rut.utiLalgorithm.support.InsertSort;

importorg.rut.utiLalgorithm.support.MergeSort;

importorg.rut.util.algorithm.support.Quicksort;

importorg.rut.util.algorithm.support.SelectionSort;

importorg.rut.util.algorithm.support.ShellSort;

/**

*@authoreeroot

*@since2006-2-2

*@version1.0

*/

publicclassSortUtil{

publicfinalstaticintINSERT=1;

publicfinalstaticintBUBBLE=2;

publicfinalstaticintSELECTION=3;

publicfinalstaticintSHELL=4;

publicfinalstaticintQUICK=5;

publicfinalstaticintIMPROVEDQUICK=6;

publicfinalstaticintMERGE=7;

publicfinalstaticintIMPROVED_MERGE=8;

publicfinalstaticintHEAP=9;

publicstaticvoidsort(int[]data){

sort(data,IMPROVEDQUICK);

)

privatestaticSing[]name={

#8220;insert

#8220;bubble

#8220;selection

#8220;shell

#8220;quick

#8220;improved_quick

#8220;merge

#8220;improvedmerge

#8220;heap

)；

privatestaticSort[]impl=newSort[]{

newInsertSort(),

newBubbleSort(),

newSelectionSort(),

newShellSort(),

newQuickSort(),

newImprovedQuickSort(),

newMergeSort(),

newImprovedMergeSortO,

newHeapSort()

);

publicstaticSingtoSing(intalgorithm){

returnname[algorithm-1];

publicstaticvoidsort(int[]data,intalgorithm){

impl[algorithm-1].sort(data);

j

publicstaticinterfaceSort{

publicvoidsort(int[]data);

publicstaticvoidswap(int[]data,inti,intj){

inttemp=data[i];

data[i]=data[j];

data[j]=temp;

JAVA的事件委托机制和垃圾回收机制

一追雨制作

java事件委托机制的概念，一个源产生一个事件并将它送到一个或多

个监听器那里。在这种方案中，监听器简单的等待，直到它收到一个事件。一旦事

件被接受，监听器将处理这个事件，然后返回。

垃圾回收机制垃圾收集是将分配给对象但不再使用的内存回收或释放的过程。如

果一个对象没有指向它的引用或者其赋值为null,则次对象适合进行垃圾回收

编程输出如下图形

—追雨制作

****

***

**

*

代码如下：

publicclassPrint{

publicstaticvoidmain(Sing[]args){

for(inti=0;i

<5；i++)(

for(intj=5;j>i;j

){

System.out.print(

*

)；

System.out.println();

super。与this。的区别？

—追雨制作

This()：当前类的对象,super父类对象。

Super()：在子类访问父类的成员和行为，必须受类继承规则的约束

而this他代表当前对象，当然所有的资源都可以访问.

在构造函数中，如果第一行没有写super。,编译器会自动插入.但是如果父类没有不带

参数的构造函数，或这个函数被私有化了(用private修饰).此时你必须加入对父类的

实例化构造.而this就没有这个要求,因为它本身就进行实例化的构造.

而在方法中super和this使用的方法就差不多了.只不过super要考虑是否能访问其

父类的资源.

J2EE的优越性主要表现在哪些方面？

_追雨制作

J2EE的优越性主要表现在如下儿个方面：

1、J2EE基于JAVA技术，与平台无关

2、J2EE拥有开放标准，许多大型公司实现了对该规范支持的应用服务器。如

BEA,IBM,ORACLE等。

3、J2EE提供相当专业的通用软件服务。

4、J2EE提供了一个优秀的企业级应用程序框架，对快速高质量的开发应用系统

打下了基础

J2EE中的容器都包括哪些？

_追雨制作

J2EE中容器充当中间件的角色。主要的容器包括：

WEB容器：给处于其中的应用程序组件(JSP,SERVLET)提供一个环境，使

JSP,SERVLET直接更容器中的环境变量接口交互，不必关注其它系统问题。主要

有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提

供的接口严格遵守J2EE规范中的WEBAPPLICATION标准。我们把遵守以上标

准的WEB服务器就叫做J2EE中的WEB容器。

EJB容器：Enterprisejavabean容器。更具有行业领域特色。他提供给运行在其中

的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容

器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件

服务、事务管理。

WEB容器和EJB容器在原理上是大体相同的，更多的区别是被隔离的外界环境。

WEB容器更多的是跟基于HTTP的请求打交道。而EJB容器不是。它是更多的跟

数据库、其它服务打交道。但他们都是把与外界的交互实现从而减轻应用程序的负

担。例如SERVLET不用关心HTTP的细节，直接引用环境变量

session,request,response就行、EJB不用关心数据库连接速度、各种事务控制，直接

由容器来完成。

RMI/IIOP:远程方法调用/internet对象请求中介协议，他们主要用于通过远程调用服

务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在

本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之

间进行通信。RMI是JAVA特有的。

JNDLJAVA命名目录服务。主要提供的功能是：提供一个目录系统，让其它各地

的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的

功能。

JMS:JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。

JAVAMAIL:JAVA邮件服务。提供邮件的存储、传输功能。他是JAVA编程中实

现邮件功能的核心。相当MS中的EXCHANGE开发包。

JTA：JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接

口即可。

JAFJAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署

和自定义实现自己的个性安全控制策略。

EAI:企业应用集成。是一种概念，从而牵涉到好多技术。J2EE技术是一种很好的

集成实现。

JPA面试常见问题

一追雨制作

这篇文章是摘自PaickLinskey的一篇文章，主要是关于JPA相关内

容的问答，相信JPA面试会碰到很多这里面的问题

问题：EJB专家团队是如何摆脱事务描述符的？

回答：在会话bean和消息驱动bean中，可以通过描述符和注释来控制事务的行

为。此外，我们将默认的事务属性更改为“REQUIRED”，这个默认值比以前的值

“SUPPORTS”更常用。因此，完全不必为业务方法配置事务行为。

JPA实体仅供本地使用，重点关注域模型。因此，无法在JPA实体上配置事务性

（或远程边界或安全性）。而是必须使用会话beanfaqade（或消息驱动bean）,才可以

通过EJB协议使用这些实体。通常来说，这是一件好事，配置安全性、远程处理

和事务的粒度应该比持久化数据的粒度粗很多。JPA着重关注持久化数据，以及与

EJB的其他部分和JavaEE规范集成起来照管其他企业关注点。

问题：推荐对主键使用“long”还是“Long”?如果允许使用null作为值，将会如何？

回答：这实际上取决于您的数据模型。如果您的数据模型允许主键为null,那么使

用Long,如果您的数据模型规定主键列不能为null,则使用long更合适。总的来

说，我认为对于非复合主键，允许null作为合法值容易产生混淆，因此我倾向于

使用long,而不是Long。

问题：您说EJB2.0不支持继承，但是可以在几个不同位置（远程/bean）使用继承，

只是不在本地使用而已。请解释一下。

回答：根据EJB2.1规范的附录D3：

当前的EJB规范未指定组件继承的概念。

另一方面，JPA规范确实规定了实体继承的概念。我们已经处理了EJB2.1规范中

指出的各种问题和复杂性，现在允许完全的多态查询和关联。

问题：BEA计划什么时候支持/发布EJB3?

WcbLogicServer10TechnologyPreview是完全符合规范的JavaEE5应用服务器。

它包括完整的EJB3支持。WebLogicServer10大概于三月下旬发布。

此外，Kod。是完全符合规范的生产就绪JPA实现，并且已经发布。

问题：JPA是否支持组合主键？

回答：JPA支持自然ID和组合ID,以及数据库指派或实现指派的数字值。

问题：是否存在Spring模板，像JDBC模板一样可以在容器外部使用？

回答:是的，Spring2有JPA模板。但是，Spring2可以对任何标记着©Repository

的bean执行JPA异常转译。因此，总的来说，对于新的应用程序，最好直接使用

JPAAPI,而不是另一个模板层。对于使用模板和正在迁移到JPA的现有应用程序

来说，使用模板方法比较合理。

此外，可以像在JavaEE服务器中--样将JPA的持久化单元部署到Spring,Spring

对JPA规范中指出的EntityManager注入和查找服从容器规则。

问题：JPA是否支持JDKL4?

回答：JPA需要Java5或更新版本。

问题：使用范围查询时，它是否也会返回结果总数(例如，返回538项结果中的1-

10项)？

回答：不，要想获得总数，必须发出另外一个查询。通用模式是，在第一次执行搜

索时获得总数，然后通过页面浏览结果，将总数存储到方便的位置(会话状态、

cookie等)：

if(isFirstPage()){//thisisthefirsttimewe

#8217;reexecutingthisquery

Queryq=em.createQuery(

SELECTCOUNT(p)FROMProductpWHERE

#8230;

)；

longcount=((Long)q.getSingleResult()).longValue();

//storecountsomewherestateful

Queryq=em.createQuery(

SELECTpFROMProductpWHERE

#8230;

)；

q.sctFirstResult(page*PAGESIZE);//pageisstoredsomewherestateful

q.sctMaxResults(PAGESIZE);

问题：具有JPA包装器的Hibernate是不是一种EJB3实现？

回答：JPA规范是完整的EJB3规范的子集，因此JPA实现本身不是完整的EJB3

实现。我不了解RedHat的EJB3实现的情况如何。但，Hibernate是JPA实现。

问题：与Hibernate相比，JPA是不是更好？

回答：JPA是规范，而Hibernate是实现。因此，这是不同事物的比较。可以肯

定，使用标准API比使用专有API有更多优势，但不存在真正的劣势。

问题：是不是不再需要学习和使用Hibernate?

回答：规范团队关于JPA1的目标之一是制定一个可以由很多供应商实现的APL

并且开发人员可以编码来实现该API,而不是使用私有供应商特有的API。我们已

成功实现这个目标，因此您只需使用供应商特有的API来获得JPA规范没有解决

但您的应用程序中需要的功能。我的建议是尽可能地使用JPAAPI,但是当需要供

应商公开但是规范中没有提供的功能时，则使用供应商特有的APL

例如，OpenJPA提供了保存点功能，但JPA规范没有。因此，希望使用保存点的

OpenJPA开发人员应该对代码的大部分内容使用JPA规范，而借助

OpenJPAEntityManager来设置和管理保存点。

问题：规范是否解决了缓存问题？

回答：JPA规范没有解决二级缓存问题(EntityManagerFactory-级)，但是提供了实现

该缓存必须遵守的一些数据锁定和一致性规则，即使在启用缓存时也是如此。

有少量与缓存有关的主题可能会在将来的JPA规范版木中解决，但是大多数缓存

主题不必指定规则，这样，不同的供应商就可以轻松地完成不同的工作。此处增加

的最重要的内容是一些基本缓存控制APL如回收某些对象ID,或将一些经常访

问的ID固定到缓存中。

问题：既然实体管理器承担了所有繁重的工作负载，那么会话bean还有什么价值？

回答：EntityManager负责域对象模型和数据库之间的交互，但是仍然在会话中实

现安全性、事务控制、远程处理、有状态的临时数据存储，而操作单元编程模型无

法解决以上问题。会话bean还是部署单元和公用服务边界。因此，会话bean是定

义所有业务代码的地方。换而言之，会话bean是EJB容器关注的，而JPA实现是

在会话bean中使用的。

当然，您还可以直接从servlet或JSP或其他任何可以使用Java5的地方使用JPA。

但是这样的话，您就必须管理自己的事务、处理自己的集群服务故障转移、管理自

己的服务重部署等。

问题：相对于EJB2来说，EJB3可以处理多少个并发事务？

回答：从纯会话bean的观点来讲，至少在WebLogicServer中，并发事务的数目没

有什么差别。也就是，如果将您的应用程序从EJB2会话bean转换到EJB3会话

bean,但是完全没有修改持久化机制，可能不会发现重大差别。这是因为EJB3规

范对会话bean部分的大多数更改着重实现编程模型的改进。

从实体bean的观点来讲，我认为对于大多数应用程序，WebLogicServer的EJB

2.1和JPA支持的并发事务数目相同。您可能发现JPA对于非主键的查询来说，可

伸缩性更高。一旦开始钻研Kodo的锁定组之类的功能，则对于固定的域模型，可

以从基于JPA的系统中获得更多并发事务。

问题：如何为AquaLogicDSP应用JPA?

回答：AquaLogicDSP着重关注对数据的多重存储访问，并将数据作为数据服务提

供，通常作为XML或SDO呈现这些数据。JPA规范着重关注与数据存储交互的

JavaAPL可以设想，JPA绑定至UAquaLogicDSP,或SDO绑定到Kodo产品（BEA

的JPA实现）。

问题：什么是实现过程的最佳位置，例如，检查许多用户及其帐户（在银行应用程

序中）以付给利息?是在数据库的存储过程中实现，还是在EJB中使用JPA实现，

还是同时使用这两种方式？

回答：根据我的经验，这实际上取决于组织因素，而不是其他因素。一些工作室更

喜欢在存储过程中进行大量编码，而另一些则喜欢在Java中实现其业务逻辑。每

种方法各有优势和代价。

尽管如此，还是有一些问题可促使他们优先考虑其中的一种环境。在您的例子中，

在数据库中执行大量计算可能比将数据加载到内存中更快，因此使用存储过程可能

比较合理。另一方面，数据库承担这么多负载将对该应用程序的用户产生负面影

响，因此最好付出一定代价跨网络拉出这些数据，以便将该数据库用作严格的存储

系统，而不是计算引擎。或者，如果应用程序的其余部分主要使用JPA,则适用的

话，可能希望使用JPQL的大批量更新功能来进行更新。

问题：如果不先将数据加载到内存中，是否可以执行大批量更新？

回答：是的，可以通过JPQL执行大批量更新和大批量删除：

UPDATEEmployeeeSETe.salary=e.salary*1.1WHEREe.salary

<100000

问题：你们对KodoJDO有什么规戈|J?JPA是否会通过实现JDO的所有功能而将其

取代?如果是的话，是否存在任何时间表?如果不是，你们会不会继续积极地开发

JDO?

回答：BEA仍然完全忠于JDO。从规范的观点来看，我认为过一段时间之后，JPA

将包含当前的JDO规范中越来越多的功能。但是，我不了解Sun对JDO和JPA之

间的融合工作有什么规划。

问题：什么是持久化单元？

回答：持久化单元是类和配置设置的集合，可以根据该集合创建

EntityManagerFactory（,它在persistence.xml文件中作为一个条目出现。

问题：如何在WebLogic9.2中测试JPA

回答：现在可以在WebLogic9.2中使用OpenJPA或Kodo。该服务器不执行会话

bean持久化单元注入，但是在10.0服务器中可以这么作，并且在9.2中，没有任何

Kodo控制台集成。但是除了引导注入问题之外，应该能够在WebLogic9.2中成功

地使用JPA,包括参与托管事务。

问题：JDBC连接对应于JPA中的什么概念？

回答：JPAEntityManager大致相当于JDBC连接，而JPAEntityManagerFactory从

概念上类似于JDBC数据源。JPAEntityTransaction（仅在JTA/appserver上下文以

外可用）相当于JDBC连接的事务控制APL

在OpenJPA中,EntityManager在其生命周期中可能使用多个不同的JDBC连接。

请参阅openjpa.ConnectionRetainMode属性的文档了解详细信息。

问题：关于fetch类型，如果默认是主动（eager）加载，则提供程序可能忽略惰性

（lazy）加载指令。因此，即使将字段设置为惰性，也可能会加载不必要的数据。将

来的规范会不会将其修改为必须与fecth类型一致?这会涉及至U什么问题？

回答：通常，OpenJPA永远不会忽略用户配置的FetchMode。这是提示而不是规

则，因为惰性加载实际上是调优过程中一项关注事项，永远都不应该对应用程序产

生行为性的影响*。JPA规范力图避免要求使用任何明确的性能调优策略，因为不

同的网络拓扑结构、数据存储系统和应用程序行为需要不同的调优关注。

例如，OpenJPA允许在运行时动态控制fetch配置。这意味着，它可能静态地配置

对