计算机类基础问题

目录一

1、java

因为我投的职位主要是java相关的，所以这方面积累的经验比较多一下。这部分考查的重点主要有：java基本语

法，多线程，异常处理，抽象类，匿名类，接口，MVC架构，设计模式，Servlet,Struts,Spring,J2EE。以下是

我遇见过的面试问题：

1）transient和volatile是java关键字吗？（瞬联）

2）抽象类和接口有什么区别？（瞬联）

3）能说一下java的反射机制吗？（瞬联）

4）在java中怎样实现多线程？（瞬联）

5）你用过哪种设计模式？（瞬联，IBM,aspenTech）

6）请说一下MVC架构（瞬联，IBM,aspenTech）

7）如果类a继承类b,实现接口c,而类b和接口c中定义了同名变量，请问会出现什么问题？（瞬联）

8）请说一下java中为什么要引入内部类？还有匿名内部类？（瞬联，IBM）

9）请说一下final,finally和finalize的区别？（瞬联）

10）请说一下HTTP请示的基本过程（IBM）

11）java中存在内存泄漏问题吗？请举例说明？（IBM）

12）请说一下java中的内存回收机制所采用的算法（IBM,瞬联）

13）请说一下System.gc（）函数的作用。什么什么时候可以调用垃圾回收器？（瞬联）

14）你做过的项目中采用了什么安全认证机制？（IBM）

15）Math,round。什么作用？

2、C

C语言考查的重点一般是：指针、结构体、条件编译、全局变量/局部变量。以下是我遇见过的面试问题：

1）请说一下externC的作用（汉略）

2）请说一下#ifdef...的作用（汉略）

3）C语言里，哪些变量是存放在堆里，哪些是存放在栈里？（普天）

4）C语言里的static关键词是什么含义？（普天）

5）进程和线程有什么区别？（普天）

3、C++

C++语言考查的重点主要有：多继承，抽象类，虚函数，拷贝构造函数，析构函数，动态联编，多态，const,static。

以下是我面试中遇到的问题：

1）你听说过拷贝构造函数吗？能具体说一下它的作用吗？（汉略）

2）析构函数必须是虚函数吗？为什么？（汉略）

3）你听说过钻石结构吗？请具体说一下（aspenTech）

4）什么是深拷贝？什么是浅拷贝？他们有什么区别？（aspenTech）

5）什么是虚函数，什么是纯虚函数？为什么引入虚函数和纯虚函数？（汉略，aspenTech,普天）

6）请说一下面向对象的基本特性。（aspenTech）

7）C++中的const关键定代表什么含义？跟C语言中的const有什么区别？（aspenTech）

8）C++中的static关键定代表什么含义？跟C语言、Java中的static有什么区别？（普天）

4、数据结构

这是面试中几乎必考的部分。考查的重点有：链表，二叉树前序、中序、后序遍历（递归，非递归），二叉树结

点、层次的计算，树转二叉树，各种排序算法（冒泡排序，快速排序，堆排序是重点）。以下是我在面试中遇到过

的问题：

1）请编写程序，将一个链表倒置。（联发）

2）请编写二叉树的中序遍历非递归算法。（新华社）

3）请编写一个程序，实现将树转化成二叉树。（华为）

4）一棵满二叉树有x个结点，请问整棵二叉树有多少结点？（新华社，中国信保）

5）请编程实现一个堆排序算法/快速排序算法。（汉略）

5、数据库

这也是面试重点内容。主要考查点有：范式，1、2、3范式，事务，内连接，外连接，关系代数，数据库设计。以

下是我遇到过的面试问题：

1）什么是范式、1范式、2范式、3范式？（百度，中航信，新华社，中国信保）

2）事务具有哪些特性？（中航信）

3）请说说什么是外连接、左外连接、右外连接？（aspenTech）

4）请说说关系代表中的几种基本运算？（中航信）

5）请对一个论坛进行数据库设计，并说说你设计的数据库满足哪个范式（百度）

6）给你•个数据库需求，请对数据库进行设计，并根据要求写出查询语句（中国信保）

6、网络

这也是常考的部分。主要考查点有：OSI参考模型，TCP/IP参考模型。以下是我遇到过的具体面试问题：

1）请解释一下OSI参考模型。（中国信保）

2）请解释一下TCP/IP参考模型。（中国信保）

3）为什么现在的网络最后采用了TCP/IP参考模型而没用OSI参考模型？（中国信保）

Java

1)transient和volatile是java关键字吗

不常用到的关键字有：const,goto,native,strictfp,transient»volatileo

const和goto为java中的保留字。

1.native

native是方法修饰符。Native方法是由另外一种语言(如c/c++,FORTRAN,汇编)实现的本地方法。因为在外部

实现了方法，所以在java代码中，就不需要声明了，有点类似于借口方法。Native可以和其他一些修饰符连用，但

是abstract方法和Interface方法不能用native来修饰。

Example：代码

publicinterfaceTestinterface)

voiddoMethod();

)

publicclassTestimplementsTestinterface{

publicnativevoiddoMethod();

privatenativeintdoMethodB();

publicnativesynchronizedStringdoMethodC();

staticnativevoiddoMethodD();

)

render_code();

为什么需要使用nativemethod?请参考：

/topic/72543javaNativeMethod初涉

2.strictfp

修饰类和方法，意思是FP-strict,精确浮点，符合IEEE-754规范的。当一个class或interface用strictfp声明，内部

所有的float和double表达式都会成为strictfp的。Interfacemethod不能被声明为strictfp的，class的可以。

Example：

代码

strictfpinterfaceFPTest{publicstrictfpvoidmethodC(){

voidmethodA();}

classFPClassimplementsFPTest{classFPClassB{

publicvoidmethodA(){strictfpvoidmethodA(){

publicvoidmethodB(){

render_code();

3.transient

变量修饰符。标记为transient的变量，在对象存储时，这些变量状态不会被持久化。当对象序列化的保存在存储器

上时，不希望有些字段数据被保存，为了保证安全性，可以把这些字段声明为transient。

4.volatile

volatile修饰变量。在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化

时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

看看JavaLanguageSpecification中的例子。

条件：一个线程不停的调用方法。ne(),一个线程不停的调用方法two()。我测试过多次，这种情况好像一直没有出

现。

5.抽象类和接口有什么区别？(瞬联)

声明方法的存在而不去实现它的类被叫做抽象类(abstractclass),它用于要创建一个体现某些基本行为的类，并

为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract类的实例。然而可以创建一个变量，其类型

是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract类的子类为它们

父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类

可以在类中实现这些方法。

接口(interface)是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接

口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义staticfinal成员变量。接口的实现与子类相似，

除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义(即将程序体给予)所有这种接口的方法。

然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量

的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof运算符可以用来决定某

对象的类是否实现了接口。

6)能说一下java的反射机制吗？(瞬联)

JAVA反射机制是在运行状态中，对于任意•个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都

能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

Java反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在

运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

1.得到某个对象的属性

1publicObjectgetProperly(Objectowner,StringfieldName)throwsException{

2ClassownerClass=owner.getClass();//得到该对象的Class

3

4Fieldfield=ownerClass.getField(fieldName);//通过Class得到类声明的属性

5

6Objectproperty=field.get(owner);//通过对象得到该属性的实例，如果这个属性是非公有的，这里

会报IllegalAccessExceptiono

7

8returnpnperty;

9)

2.得到某个类的静态属性

1publicObjectgetStaticProperty(StringclassName,StringfieldName)

2throwsException{

3ClassownerClass=Class.forName(className);//首先得到这个类的Class.,

4

5Fieldfield=ownerClass.getField(fieldName);〃和上面一样，通过Class得到类声明的属性

6

7Objectproperty=field.get(ownerClass);〃这里和上面有些不同，因为该属性是静态的，所以直接从类

的Class里取。

8

9returnpnperty;

10)

3.执行某对象的方法

1publicObjectinvokeMethod(Objectowner,StringmethodName,Object[]args)throwsException{

2

3ClassownerClass=owner.getClass();〃首先还是必须得到这个对象的Classo

4

5Class[]argsClass=newClassfargs.length];〃配置参数的Class数组，作为寻找Method的条件。

6

7for(inti=0,j=args.length;i<j;i++){〃配置参数的Class数组，作为寻找Method的条件。

8argsClass[i]=args[i].getClass();

9)

10

11Methodmethod=ownerClass.getMethod(methodName,argsClass);通过Method名和参数的Class数组得到要执行

的Methodo

12

13returnmethod.invoke(owner,args);执行该Method,invoke方法的参数是执行这个方法的对象，和参数数组。返

回值是Object,也既是该方法的返回值。

14)

Classowner_class=owner.getClass()：

4.执行某个类的静态方法

1publicObjectinvokeStaticMethod(StringclassName,StringmethodName,

2Object[]args)throwsException{

3ClassownerClass=Class.forName(className);

4

5Class[]argsClass=newClass[args.length];

6

7for(inti=0,j=args.length;i<j;i++){

8argsClass[i]=args[i].getClass();

9)

10

11Methodmethod=ownerClass.getMethod(methodName,argsClass);

12

13returnmethod.invoke(null,args);

14)

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null,因为这是静态方法，不需要借助实例运

行。

5.新建实例

1

2publicObjectnewInstance(StringclassName,Object[]args)throwsException{

3ClassnewoneClass=Class.forName(className);〃第一步，得到要构造的实例的Classo

4

5Class[]argsClass=newClass[args.length];//得到参数的Class数组。

6

7for(inti=0J=args.length;i<j;i++){//得到参数的Class数组。

8argsClass[i]=args[i].getClass();

9)

10

11Constructorcons=newoneClass.getConstructor(argsClass);//得到构造子。

12

13return©ns.newlnstance(args);//新建实例。

14

15)

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用

newoneClass.newInstance()来实现。

6.判断是否为某个类的实例

1publicbooleanisInstance(Objectobj,Classcis){

2returnds.islnstance(obj);

3)

7.得到数组中的某个元素

1publicObjectgetByArray(Objectarray,iniindex){

2returnArray.get(array.index);

3)

4)在java中怎样实现多线程？(瞬联)

与其他语言不一样的是，线程的观念在java是语言中是重要的，根深蒂固的，因为在java语言中的线程系统是java

语言自建的，java中有专门的支持多线程的API库，所以你可以以最快的速度写一个支持线程的程序。在使用java

创建线程的时候，你可以生成一个Thread类或者他的子类对象，并给这个对象发送start。消息(程序可以向任何

一个派生自Runnable接口的类对象发送start。消息的),这样一来程序会一直执行，直到run返回为止，此时该

线程就死掉了。

在java语言中,线程有如下特点:

§在一个程序中而言，主线程的执行位置就是maino而其他线程执行的位置，程序员是可以自定义的。值得注意

的是对Applet也是一样。

§每个线程执行其代码的方式都是一次顺序执行的。

§一个线程执行其代码是与其他线程独立开来的。如果诸线程之间又相互协作的话，就必须采用•定的交互机制。

§前面H经说过，线程是共享地址空间的，如果控制不当，这里很有可能出现死锁。

各线程之间是相互独立的，那么本地变量对一个线程而言就是完全独立，私有的。所以呢，线程执行时，每个线程

都有各自的本地变量拷贝。对象变量(instancevariable)在线程之间是可以共享的，这也就是为什么在java中共享数

据对象是如此的好用，但是java线程不能够武断地访问对■象变量：他们是需要访问数据对象的权限的。

二、准备知识

在分析这个例子之前，然我们先看看关于线程的几个概念，上锁，信号量，和java所提供的API。

上锁

对于大多数的程序而言，他们都需要线程之间相互的通讯来完成整个线程的生命周期，二实现线程之间同步的最简

单的办法就是上锁。为了防止相互关联的两个线程之间错误地访问共享资源，线程需要在访问资源的时候上锁和解

锁，对于锁而言，有读锁，写锁和读写锁等不同的同步策略。在java中，所有的对象都有锁；线程只需要使用

synchronized关键字就可以获得锁。在任一时刻对于给定的类的实例，方法或同步的代码块只能被一个线程执行。

这是因为代码在执行之前要求获得对象的锁。

信号量

通常情况下，多个线程所访问为数不多的资源，那怎么控制呢？一个比较非常经典而起非常简单的办法就是采用信

号量机制。信号量机制的含义就是定义一个信号量，也就是说能够提供的连接数；当有一个线程占用了•个连接时,

信号量就减一；当一个线程释放了连接时，信号量就加一。采用这种方法就可以简单有效地控制线程的同步问题，

而且实现起来也特别方便。看下面的代码：

classSemaphore{)

privateintcount;count-;

publicSemaphore(intcount){)

this.count=count;

)publicsynchronizedvoidrelease(){

count++;

publicsynchronizedvoidacquire(){notify();//alertathreadstttdbckingonthis

while(count==0){semaphore

trycatch(InterruptedExceptione){)

//keeptrying)

java中提供了哪些api以编写多线程程序。这里只列出几个常用的方法和属性值。

属性值，有三个MAX_PRIORITY,MIN_PRIORITY,NORM_PRIORITY

方法：

Thread。;〃建立一个线程

voidrun();〃对于一个继承了Runnable接口的class而言，他运行一个线程，否着他什么都不做

voidsetPriority(intnewPriority);〃设置优先级

voidstart。;〃运行一个程序

voidsleep(longmillis);〃线程睡眠millis毫秒

staticvoidyield。;〃临时pause一个程序以便起他线程运行

三、程序示例

例一、

让我们看看下面的例子。取钱的流程是输入密码，然后确定要取得金额，如果所取的金额小于或等于可以取出的

金额，WITHDRAW则返回TRUE,然后ATM机出钱，然后打印清单；否则返回FALSE,然后打印清单。如下图:

publicclassAutomatedTellerMachineextendsTeller{publicclassAccount{

publicvoidwithdraw(floatamount){privatefloattotal;

Accounta=getAccount();publicbooleandeduct(floatt){

if(a.deduct(amount))if(t<=total){

dispense(amount);total-=t;

printReceipt();returntrue;

))

)returnfalse;

)

)

就这个例子而言，假设有这种情况，对同一个账号可以在不同的地方取钱，在同一时间，不同地点，妻子和丈夫

取钱，妻子输入了账号上的最大金额，丈夫也是一样，假如妻子输入后已经得到true的返回值，但是丈夫的线程所

得到的值还没有更新，这样丈夫也能够得到true的返回值，这样就出现了问题！这个问题怎么解决呢？在java里面

提供了控制机制以保证deduct操作时的原子性，那就是关键字synchronizedo

在Account的deduct方法加入synchronized就可以解决这个问题。

例二、

在这里我们用多线程中最典型的例子，生产者与消费者问题。在这个例子里面我们定义了生产者Producer,消费者

Consumer和仓库Warehouse三个类，在整个程序的生命周期里，生产者随机地制造出产品放到仓库中，消费者也

是随即地从仓库中取出产品。

importexception.ProducerConsumerException;

publicvoidrun(){

/**

*Consumer.javainttmp=(int)Math.random()*10;

*Consumer

*By:Jiabotry(

*Date:Mar21,2004warehouse.get(tmp);

*Time:2:47:58PMSystem.out.println(nConsumer#"+this.id+"getH+

*/tmp);

publicclassConsumerextendsThread{}catch(ProducerConsumerExceptione)

privateWarehousewarehouse;try{

privateStringid;sleep((int)(Math.random()*100));

}catch(IntemjptedExceptione)

publicConsumer(Warehousewarehouse,Stringid){)

this,warehouse=warehouse;)

this.id=id;

）

在这个类中，值得注意的一点是run方法中必须使用try-catch,因为，消费者从仓库中取东西时有可能诸如仓库中

的储量不够得异常，在消费者里面也是一样，只不过异常变为仓库已满。

importexception.*;

publicvoidrun(){

/**

*Producer.javainttmp=(int)Math.random()*10;

*Producer

*By:Jiaboif(tmp!=0){

*Date:Mar21,2004try(

*Time:2:47:45PMwarehouse.put(tmp);

*/System.out.println("Consumer#"+this.id+"putu+

publicclassProducerextendsThread{tmp);

}catch(ProducerConsumerExceptione)

privateWarehousewarehouse;)

privateStringid;

try(

publicProducer(Warehousewarehouse,Stringid){sleep((int)(Math.random()*100));

this.warehouse=warehouse;}catch(InterruptedExceptione)

this.id=id;}

最重要的一部分在Warehouse类，如上所说为了保证get何set的原子性，在这里使用了synchronized关键字，并且

在操作时抛出了可能跑出的异常。

5）你用过哪种设计模式？（瞬联，IBM,aspenTech）

MVC模式，静态工厂模式，适配器模式，门面模式,DAO模式，单例模式,Template模式.command模式

在网上看见了这篇文章，作者以轻松的语言比喻了java的23种模式，有很好的启发作用。

创建型模式

1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，

但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。麦当劳和肯德基就是生产鸡翅的Factory

工厂模式：客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以

接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。

2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦,

我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出

“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你"builder。（这一定比美军在伊拉克用的翻译

机好卖）

建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品

对象。建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。建造模式可以强制实行一

种分步骤进行的建造过程。

3、FACTORYMETHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情,

我一般采用FactoryMethod模式，带着MM到服务员那儿，说“要•个汉堡”，具体要什么样的汉堡呢，让MM直

接跟服务员说就行了。

工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂

角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy

出来放到QQ里面就行了，这就是我的情话prototype了。（100块钱一份，你要不要）

原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更

多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原

始模型模式适用于任何的等级结构。缺点是每一个类都必须配备一个克隆方法。

5、SINGLETON—俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton,她们只要说道“老

公”，都是指的同一个人，那就是我（刚才做了个梦啦，哪有这么好的事）

单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。单例模

式只应在有真正的“单一实例”的需求时才可使用o

结构型模式

6、ADAPTER—在朋友聚会上碰到了一个美女Sarah,从香港来的，可我不会说粤语，她不会说普通话，只好求助

于我的朋友kent了，他作为我和Sarah之间的Adapter,让我和Sarah可以相互交谈了（也不知道他会不会耍我）

适配器（变压器）模式：把一个类的接口变换成客户端所期待的另•种接口，从而使原本因接口原因不匹配而无

法一起工作的两个类能够一起工作。适配类可以根据参数返还一个合适的实例给客户端。

7、BRIDGE-早上碰到MM,要说早上好，晚上碰到MM,要说晚上好；碰到MM穿了件新衣服，要说你的衣服

好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。不要问我“早上碰到MM新做了个发型怎么说”这种问

题，自己用BRIDGE组合一下不就行了

桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就

是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。

8、COMPOSITE—Mary今天过生日。“我过生日，你要送我一件礼物。”“嗯，好吧，去商店，你自己挑。”“这件T

恤挺漂亮，买，这条裙子好看，买，这个包也不错，买。”“喂，买了三件了呀，我只答应送一件礼物的哦。”“什么

呀，T恤加裙子加包包，正好配成一套呀，小姐，麻烦你包起来。……”，MM都会用Composite模式了，你会了

没有？

合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。合成模式就是一个处理对象的树

结构的模式。合成模式把部分与整体的关系用树结构表示出来。合成模式使得客户端把一个个单独的成分对象和由

他们复合而成的合成对象同等看待。

9、DECORATOR—Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月伙食费肯定玩完，拿出我去

年在华山顶上照的照片，在背面写上“最好的的礼物，就是爱你的Fita”，再到街上礼品店买了个像框（卖礼品的MM

也很漂亮哦），再找隔壁搞美术设计的Mike设计了一个漂亮的盒子装起来我们都是Decorator,最终都在修

饰我这个人呀，怎么样，看懂了吗？

装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵

活性。动态给一个对象增加功能，这些功能可以再动态的撤消。增加由一些基本功能的排列组合而产生的非常大量

的功能。

10、FACADE—我有一个专业的Nikon相机，我就喜欢自己手动调光圈、快门，这样照出来的照片才专业，但MM

可不懂这些，教了半天也不会。幸好相机有Facade设计模式，把相机调整到自动档，只要对准目标按快门就行了，

一切由相机自动调整，这样MM也可以用这个相机给我拍张照片了。

门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。门面模式提供一个高层次的接口，使得

子系统更易于使用。每一个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。但

整个系统可以有多个门面类。

11、FLYWEIGHT-每天跟MM发短信，手指都累死了，最近买了个新手机，可以把一些常用的句子存在手机里,

要用的时候，直接拿出来，在前面加上MM的名字就可以发送了，再不用一个字一个字敲了。共享的句子就是

Flyweight,MM的名字就是提取出来的外部特征，根据上下文情况使用。

享元模式：FLYWEIGHT在拳击比赛中指最轻量级。享元模式以共享的方式高效的支持大量的细粒度对象。享元

模式能做到共享的关键是区分内蕴状态和外蕴状态。内蕴状态存储在享元内部，不会随环境的改变而有所不同。外

蕴状态是随环境的改变而改变的。外蕴状态不能影响内蕴状态，它们是相互独立的。将可以共享的状态和不可以共

享的状态从常规类中区分开来，将不可以共享的状态从类里剔除出去。客户端不可以直接创建被共享的对象，而应

当使用一个工厂对象负责创建被共享的对象。享元模式大幅度的降低内存中对象的数量。

6）请说一下MVC架构（瞬联，IBM,aspenTech）

MVC指的是Model,View,Controller,简单来说，Model是负责数据层，负责与数据库连接；View是负责资料的呈

现方式，可以是网页，统计图等；Controller是负责系统的流程及决定如何呈现数据

1解释一：

模型一视图一控制器（MVC）是XeroxPARC在八十年代为编程语言Smalltalk-80发明的一种软件设计模式，至

今已被广泛使用。最近几年被推荐为Sun公司J2EE平台的设计模式，并且受到越来越多的使用ColdFusion和PHP

的开发者的欢迎。模型一视图一控制器模式是一个有用的工具箱，它有很多好处，但也有一些缺点。

MVC如何工作

MVC是一个设计模式，它强制性的使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件:

模型、视图、控制器。它们各自处理自己的任务。

模型

模型表示企业数据和业务规则。在MVC的三个部件中，模型拥有最多的处理任务。例如它可能用象EJBs和

ColdFusionComponents这样的构件对象来处理数据库。被模型返回的数据是中立的，就是说模型与数据格式无关,

这样一个模型能为多个视图提供数据。由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码

的重复性。

视图

视图是用户看到并与之交互的界面。对老式的Web应用程序来说，视图就是由HTML元素组成的界面，在新式的

Web应用程序中,HTML依I口在视图中扮演着重要的角色，但一些新的技术已层出不穷，它们包括MacromediaFlash

和象XHTML,XML/XSL,WML等一些标识语言和Webservices.如何处理应用程序的界面变得越来越有挑战性。

MVC一个大的好处是它能为你的应用程序处理很多不同的视图。在视图中其实没有真正的处理发生，不管这些数

据是联机存储的还是一个雇员列表，作为视图来讲，它只是作为一种输出数据并允许用户操纵的方式。

控制器

控制器接受用户的输入并调用模型和视图去完成用户的需求。所以当单击Web页面中的超链接和发送HTML表单

时，控制器本身不输出任何东西和做任何处理。它只是接收请求并决定调用哪个模型构件去处理请求，然后用确定

用哪个视图来显示模型处理返回的数据。

现在我们总结MVC的处理过程，首先控制器接收用户的请求，并决定应该调用哪个模型来进行处理，然后模型用

业务逻辑来处理用户的请求并返回数据，最后控制器用相应的视图格式化模型返回的数据，并通过表示层呈现给用

户。

为什么要使用MVC

大部分Web应用程序都是用像ASP,PHP,或者CFML这样的过程化语言来创建的。它们将像数据库查询语句这

样的数据层代码和像HTML这样的表示层代码混在一起。经验比较丰富的开发者会将数据从表示层分离开来，但这

通常不是很容易做到的，它需要精心的计划和不断的尝试。MVC从根本上强制性的将它们分开。尽管构造MVC

应用程序需要一些额外的工作，但是它给我们带来的好处是无庸质疑的。

首先，最重要的一点是多个视图能共享一个模型，正如我所提及的，现在需要用越来越多的方式来访问你的应用程

序。对此，其中一个解决之道是使用MVC,无论你的用户想要Flash界面或是WAP界面；用一个模型就能处理

它们。

由于你已经将数据和业务规则从表示层分开，所以你可以最大化的重用你的代码了。由于模型返回的数据没有进行

格式化，所以同样的构件能被不同界面使用。例如，很多数据可能用HTML来表示，但是它们也有可能要用

MacromediaFlash和WAP来表示。模型也有状态管理和数据持久性处理的功能，例如，基于会话的购物车和电子

商务过程也能被Flash网站或者无线联网的应用程序所重用.因为模型是自包含的，并且与控制器和视图相分离，

所以很容易改变你的应用程序的数据层和业务规则。如果你想把你的数据库从MySQL移植到Oracle,或者改变你

的基于RDBMS数据源到LDAP,只需改变你的模型即可。一旦你正确的实现了模型，不管你的数据来自数据库或

是LDAP服务器，视图将会正确的显示它们。

由于运用MVC的应用程序的三个部件是相互对立，改变其中一个不会影响其它两个，所以依据这种设计思想你能

构造良好的松偶合的构件。对我来说，控制器的也提供了一个好处，就是可以使用控制器来联接不同的模型和视图

去完成用户的需求，这样控制器可以为构造应用程序提供强有力的手段。给定一些可重用的模型和视图，控制器可

以根据用户的需求选择模型进行处理，然后选择视图将处理结果显示给用户。

MVC的缺点

MVC的缺点是山于它没有明确的定义，所以完全理解MVC并不是很容易。使用MVC需要精心的计划，由于它的

内部原理比较复杂，所以需要花费一些时间去思考。你将不得不花费相当可观的时间去考虑如何将MVC运用到你

的应用程序，同时由于模型和视图要严格的分离，这样也给调试应用程序到来了一定的困难。每个构件在使用之前

都需要经过彻底的测试。一旦你的构件经过了测试，你就可以毫无顾忌的重用它们了。

根据我个人经验，由于我们将一个应用程序分成了三个部件，所以使用MVC同时也意味着你将要管理比以前更多

的文件，这•点是显而易见的。这样好像我们的工作量增加了，但是请记住这比起它所能带给我们的好处是不值一

提。MVC并不适合小型甚至中等规模的应用程序，花费大量时间将MVC应用到规模并不是很大的应用程序通常会

得不偿失。MVC是一条创建软件的好途径MVC设计模式是•个很好创建软件的途径，它所提倡的一些原则，像内

容和显示互相分离可能比较好理解。但是如果你要隔离模型、视图和控制器的构件，你可能需要重新思考你的应用

程序，尤其是应用程序的构架方面。如果你肯接受MVC,并且有能力应付它所带来的额外的工作和复杂性，MVC

将会使你的软件在健壮性，代码重用和结构方面上一个新的台阶。

2解释二http://www.ask321.com/ask8/ask151598.htmModel-View-Controller

问题如果开发一个企业级应用，只需要一种客户端的话，那么一切都非常容易解决。但真实情况是，我们必须面对

运行在各种设备上客户端，象PDA,WAP浏览器以及运行在桌面上的浏览器，我们不得不开发不同的应用程序来

处理来自不同客户端的请求。数据访问与现实将混淆在•起，可能会出现重复的数据访问，导致整个开发周期没有

必要的延长。

建议的解决方法Model-View-Controller(MVC)开发模式被证明是有效的处理方法之一。它可以分离数据访问和数

据表现。你可以开发一个有伸缩性的，便于扩展的控制器，来维护整个流程。

如图1所示为整个模式的结构。MVC模式可以被映射到多层企业级的J2EE应用上。

§所有的企业数据以及商业逻辑可以作为模式。

§视图可以通过模式访问数据，并根据客户端的要求来显示数据。视图必须保证当模式改变的时候，数据显示也必

须同时改变。

§控制器用来结合模式和视图，把客户端来的请求转换成模式能够理解并执行的请求，并且根据请求以及执行结果

来决定下一次显示那一个视图。根据以上的逻辑，你可以象这样建立一个应用：

§应用的商业逻辑山MVC中的模式也就是EJB来表现。模式必须处理由控制器传递过来的对数据的访问请求。

§多个页面组成了MVC中的视图，这些视图必须随模式一起更新。

§控制器是•系列接收用户动作的对象，他们把用户的请求转换成模式可理解的请求，并决定显示那一个页面当模

式处理完请求后。图1c.

要点

§MVC结构适用于那些多用户的，可扩展的，可维护的，具有很高交互性的系统。

§MVC可以很好的表达用户的交互和系统模式。

§很方便的用多个视图来显示多套数据，是系统很方便的支持其他新的客户端类型。

§代码重复达到最低。

§由于分离了模式中的流控制和数据表现，可以分清开发者的责任，另外，也可以加快产品推向市场的时间

3解释三http:〃/bbsjh/14/1135.html［转帖］

了解MVC架构对于用Struts构建的强大的Web应用程序很重要

Struts是雅加达的一个项目，它提供了一个方法，可以在一个Web应用程序中一起使用JavaServerPages(JSP)和

servletso它的目的是要解决完全由JSP或完全由servlet实现的应用程序中的固有的问题。

例如，servelts可以生成HTML页面，但这么做很麻烦。

另一方面，JSP可以很容易地用于传统的HTML页面，但JSP页面有其它的缺点。特别是，用JSP很难将内容同内

容的显示分开。

很容易将Java代码同HTML混在一起，结果做出的东西又慢又难以维护。

然而，因为JSP页面容易使用，所以它们成为用Java构建动态的Web应用程序的首选方法。除了容易编程外，JSP

页面也被改进了，所以现在它们克服了以前的某些局限性。JavaBeans和标记库只是在基础的JSP技术上的几个改

进。这种类型的方法一JSP页面单独负责处理输入的请求和回复客户端——被称为Modell架构。

JavaServerPages是servlets的特殊情况，所以两者可以一起工作以弥补每个的不足，这似乎是合乎逻辑的。这种类

型的方法——你的Web架构包含截然不同的但又互联的处理数据模式、显示代码和程序控制逻辑的JSP和servlet

组件——被称为Model2架构，或Model-View-Controller(MVC)架构。

为了使用Struts架构以及用JSP和servlets有效地编程，对MVC架构的了解是很必要的。Model1和MVC架构的

主要不同就是请求是在哪里处理的。

在Model1架构中，请求通过JSP接收，主要通过JSP处理。如果JSP页面需要来自任何其它应用程序组件的服务，

如一个数据库，那么你就从页面做适当的调用，把数据返回到页面，安排数据的格式并显示出来。你可以把一些代

码放到一个或多个JavaBean中，但是这么做本身没有将逻辑同显示完全分离。

MVC方法采用「JSP和servlet方法的最佳特性，使这两种技术可以协同工作。明确的是，servlet是处理层(控制

器)。Servlet接收请求，很像Model1架构中JSP页面所做的那样，并确定如何满足那些请求。这就意味着，servlet

控制输入的请求和输出的回应。

商业逻辑体现了MVC架构中的模式。商业逻辑代码为页面做处理。如果进入servlet的请求是一个数据库查询，

servlet就将这个请求传送到一个SQL调用或类似的数据库代码。如果请求是一个包括输入信用卡号的购买请求，那

么事物处理代码就接管了。在某种意义上，架构的模式部分是让应用程序处于领先地位的全部原因。

JSP页面是显示层(视图)，是用户与应用程序交互的地方。它提供输入并显示结果。页面不应该包括任何脚本。

它只是将数据传送到servlet,并接收和显示返回的数据。

该架构的优势应该是很明显的。首先，它将计算和显示清楚地分开了。结果很理想，在JSP页面上没有出现处理过

程，在servlet或商业逻辑中没有数据格式。这种分离的另一个好处是Java程序员可以专注于servlet代码，HTML

编写者可以专注于JSP。

第二点，控制器servlet做页面上的所有的决定.在你的页面和逻辑中不会出现任何决策。这就提高了一个应用程序

的性能和可扩展性，因为请求可以被导向架构的不同的组件，甚至是不同的服务器。

运用MVC架构

MVC架构没有必要成为用于所有Java应用程序的最佳方法。如你想象的那样，它在准备和编码时往往很复杂——

这对简单的应用程序来说是没必要的。当页面导航相对来说比较简单和固定，而且应用程序中的页面结构可以由一

个简单的目录结构管理时,Model1架构仍然是最好的方法。这些应用程序往往将页面流动信息嵌入到页面间的链

接中。（JSP中出现forward。就告诉你，在该页中有嵌入的逻辑，让你对显示下一页作出决定。）对于对流量或可

扩展性需求有限的静态的应用程序来说，标准的JSP模式仍然是•个可行的选择方案。

在一些情况下，你可能想把一个JSP应用程序移植到MVC架构中。例如，你可能开始时用的是Model1,简单的

JSP架构，随着你的需求的增加，你会发现维护起来太复杂或太难了。如果你花很长的时间对应用程序做相时来说

较简单的修改，或者如果你经常在你的代码中发现bug,那么你的JSP导向的应用程序也许就不再是合适的方法了。

随着应用程序的发展和变化，页面的流动和商业逻辑也增加了。应用程序变得难以维护，因为页面流动逻辑跨多个

页面分布，而且商业逻辑可能开始存在于未计划的地方。从Model1转到MVC的最佳时机就是当这些类型的维护

问题出现的时候。

你也可以预先计划将你的应用程序从一个架构移植到另一个架构。当你的应用程序中的JSP页面包含脚本元素，定

制标记或JavaScript来执行」•个forward。操作时，你可能想调整你最初的设计，变成•种用MVC架构的设计。

Refactoring用在这儿是个不错的术语。它指的是以一种高度严谨的方式重建代码结构的一种技术。当你的代码变得

难以理解、修改和调试时，你通常就开始考虑调整了。你可以用几种方式来调整代码：你可以简单地重新命名变量

和方法，或者将部分代码移植到不同类型的执行模式中。更多的关于调整及其技术方面的信息，请访问MartinFowler

的网站或者阅读他写的书Refactoring:ImprovingtheDesignofExistingCode。

在许多情况下，一开始就选择MVC架构是很有意义的，例如你的应用程序是为广泛的企业应用而设计的，或者在

几年内，你的应用程序可能扩展到一个相当高的流量。

设计一个MVC架构需要有深谋远虑。大多数程序员发现写逻辑脚本或JavaBeans,以及用HTML显示很容易。当

你设计一个MVC架构时，你必须首先进行一个完整的设计。这就意味着，分析需要处理的请求的类型，确定哪些

组件（JavaBean、数据库或其它servlets）将处理这些请求，以及对那些请求的回应是如何显示给用户的。

该设计的关键就是请求和数据的流动性。为MVC架构设计应用程序组件只是对你现在用JSP和servlets所做工作的

扩展。

面临的挑战就是构建一个servlet,它接收请求并把那些请求分到应用程序的不同的组件。将一个数据库请求传送

到一个数据库，或将一个处理请求传送到一个JavaBean是很容易的，但是如果一个请求包含这两种元素，会怎样

呢？或者如果请求的性质在一些处理出现前不能确定，又怎样呢？

Struts构架

该挑战使我们又回到Struts构架。Struts提供了一个实现MVC架构的高度自动化的方式。它的结构实现了MVC,

并包括一个控制器servlet、一组JSP页面和应用程序的商业逻辑。控制器将用户请求打包，并把它们导向架构中的

其他对象。

Struts构架是围绕一个ActionMapping结构的。控制器用ActionMapping把HTTP消息形式的用户请求转换成应用

程序