初级Java工程师面试题（1）

开通VIP，畅享免费电子书等14项超值服

首页

好书

留言交流

下载APP

联系客服

2022.05.05湖北

1)抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象,二是数据抽象。

2)继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3)封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。

4)多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

区别如下

作用域当前类同包子孙类其他

public√√√√

protected√√√×

default√√××

private√×××

不写时默认为defual

不是。

不正确；精度不准确,应该用强制类型转换，如下所示：floatf=(float)3.4。

不能；应该用强制类型转换，如下所示：floatf=(float)1.3；。

shorts1=1;s1+=1;有什么错

shorts1=1;s1=s1+1;s1+1运算结果是int型，需要强制转换类型；

shorts1=1;s1+=1;可以正确编译,自动类型提升。

goto是java中的保留字，现在没有在java中使用。

Java提供两种不同的类型：引用类型和原始类型（或内置类型）；

int是java的原始数据类型，Integer是java为int提供的封装类。

Java为每个原始类型提供了封装类：

原始类型:boolean,char,byte,short,int,long,float,double

封装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

引用类型和原始类型的行为完全不同，并且它们具有不同的语义。引用类型和原始类型具有不同的特征和用法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储，当引用类型和原始类型用作某个类的实例数据时所指定的缺省值。对象引用实例变量的缺省值为null，而原始类型实例变量的缺省值与它们的类型有关。

&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。

区别主要有两点：a.条件操作只能操作布尔型的,而逻辑操作不仅可以操作布尔型,而且可以操作数值型b.逻辑操作不会产生短路。

栈是一种线形集合，其添加和删除元素的操作应在同一段完成，栈按照后进先出的方式进行处理；堆是栈的一个组成元素。

Math.round(11.5)==12Math.round(-11.5)==-11round方法返回与参数最接近的长整数，参数加1/2后求其floor。

switch（expr1）中，expr1是一个整数表达式。因此传递给switch和case语句的参数应该是int、short、char或者byte。long,string都不能作用于swtich。

2<<3。

数组没有length()这个方法，有length的属性。String有length()这个方法。

在最外层循环前加label标识,然后用break:label方法即可跳出多重循环。

构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

不对，有相同的hashcode。

String类是final类，故不可以继承。

A：“beijing”==“beijing”；

B：“beijing”.equalsIgnoreCase（newString（“beijing”））；

A和B。

是值传递。Java编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。

String的长度是不可变的；

StringBuffer的长度是可变的，如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后需要String，那么使用StringBuffer的toString()方法；线程安全；

StringBuilder是从JDK5开始，为StringBuffer该类补充了一个单个线程使用的等价类；通常应该优先使用StringBuilder类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写(Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

JVM中类的装载是由ClassLoader和它的子类来实现的,JavaClassLoader是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。

能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的。

会；存在无用但可达的对象，这些对象不能被GC回收，导致耗费内存资源。

都不能。

静态变量也称为类变量，归全类共有，它不依赖于某个对象，可通过类名直接访问；而实例变量必须依存于某一实例，只能通过对象才能访问到它。

不可以,如果其中包含对象的method()，不能保证对象初始化。

Clone有缺省行为：super.clone()，他负责产生正确大小的空间，并逐位复制。

GC是垃圾收集的意思（GabageCollection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc()或Runtime.getRuntime().gc()。

收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

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

两个对象，一个是"xyx",一个是指向"xyx"的引用对象s。

接口可以继承接口。抽象类可以实现(implements)接口，抽象类可继承实体类，但前提是实体类必须有明确的构造函数。

由于Java不支持多继承，而有可能某个类或对象要使用分别在几个类或对象里面的方法或属性，现有的单继承机制就不能满足要求。与继承相比，接口有更高的灵活性，因为接口中没有任何实现代码。当一个类实现了接口以后，该类要实现接口里面所有的方法和属性，并且接口里面的属性在默认状态下面都是publicstatic,所有方法默认情况下是public.一个类可以实现多个接口。

可以；必须只有一个类名与文件名相同。

常用的类：BufferedReaderBufferedWriterFileReaderFileWirterStringInteger；

常用的包：java.langjava.awtjava.iojava.utiljava.sql；

常用的接口：RemoteListMapDocumentNodeList

可以继承其他类或实现其他接口，在swing编程中常用此方式。

一个内部类对象可以访问创建它的外部类对象的内容。

方法的覆盖Overriding和重载Overloading是java多态性的不同表现；覆盖Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

表示该类不能被继承，是顶级类。

1）java.lang.Thread(T)

2）java.lang.Number(T)

3）java.lang.Double(F)

4）java.lang.Math(F)

5）java.lang.Void(F)

6）java.lang.Class(F)

7）java.lang.ClassLoader(T)

1、2、7可以被继承。

1)如何将数值型字符转换为数字？

2)如何将数字转换为字符？

3)如何取小数点前两位并四舍五入

1)调用数值类型相应包装类中的方法parse***(String)或valueOf(String)即可返回相应基本类型或包装类型数值；

2)将数字与空字符串相加即可获得其所对应的字符串;另外对于基本类型数字还可调用String类中的valueOf(…)方法返回相应字符串,而对于包装类型数字则可调用其toString()方法获得相应字符串；

3)可用该数字构造一java.math.BigDecimal对象,再利用其round()方法进行四舍五入到保留小数点后两位,再将其转换为字符串截取最后两位。

可用字符串构造一StringBuffer对象,然后调用StringBuffer中的reverse方法即可实现字符串的反转,调用replace方法即可实现字符串的替换。

示例代码如下:

Strings1="你好";

Strings2=newString(s1.getBytes("GB2312"),"ISO-8859-1");

JavaScript与Java是两个公司开发的不同的两个产品。Java是SUN公司推出的新一代面向对象的程序设计语言，特别适合于Internet应用程序开发；而JavaScript是Netscape公司的产品，其目的是为了扩展NetscapeNavigator功能,而开发的一种可以嵌入Web页面中的基于对象和事件驱动的解释性语言,它的前身是LiveScript；而Java的前身是Oak语言。下面对两种语言间的异同作如下比较：

1）基于对象和面向对象：

Java是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象；

JavaScript是种脚本语言，它可以用来制作与网络无关的，与用户交互作用的复杂软件。它是一种基于对象（ObjectBased）和事件驱动（EventDriver）的编程语言。因而它本身提供了非常丰富的内部对象供设计人员使用；

2）解释和编译：

Java的源代码在执行之前，必须经过编译；

JavaScript是一种解释性编程语言，其源代码不需经过编译，由浏览器解释执行；

2）强类型变量和类型弱变量：

4）代码格式不一样。

assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。一般来说，assertion用于保证程序最基本、关键的正确性。

assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。在实现中，断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为true；如果表达式计算为false，那么系统会报告一个Assertionerror。

断言用于调试目的：

assert(a>0);//throwsanAssertionerrorifa<=0

断言可以有两种形式：

assertExpression1;

assertExpression1:Expression2;

Expression1应该总是产生一个布尔值。

Expression2可以是得出一个值的任意表达式；这个值用于生成显示更多调试信息的String消息。

断言在默认情况下是禁用的，要在编译时启用断言，需使用source1.4标记：

javac-source1.4Test.java

要在运行时启用断言，可使用-enableassertions或者-ea标记。

要在运行时选择禁用断言，可使用-da或者-disableassertions标记。

要在系统类中启用断言，可使用-esa或者-dsa标记。还可以在包的基础上启用或者禁用断言。可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

error表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况exception表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况

主要从二方面来说.

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

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

HashMap与HashTable主要从三方面来说。一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java1.2引进的Map接口的一个实现二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的三.值：只有HashMap可以让你将空值作为一个表的条目的key或value。

字节流，字符流。字节流继承于InputStreamOutputStream，字符流继承于InputStreamReaderOutputStreamWriter。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。69、文件读写的基本类

FileReader类和FileWriter类分别继承自Reader类和Writer类。FileReader类用于读取文件，FileWriter类用于将数据写入文件，这两各类在使用前，都必须要调用其构造方法创建相应的对象，然后调用相应的read()或write()方法。

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口，同步的实现方面有两种，分别是synchronized,wait与notify。

启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

不能，一个对象的一个synchronized方法只能由一个线程访问。

线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。Java中的线程有四种状态分别是：运行、就绪、挂起、结束。

TCP——传输控制协议，具有极高的可靠性，保证数据包按照顺序准确到达，但其也有着很高的额外负担。UDP——使用者数据元协议，并不能保证数据包会被成功的送达，也不保证数据包到达的顺序，但其传输速度很快。

大多数我们会使用TCP，偶尔才会动用UDP，如声音讯号，即使少量遗失，也无关紧要。

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implementsSerializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Objectobj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

错。abstractmethod必须以分号结尾，且不带花括号。

错。局部变量前不能放置任何访问修饰符(private，public，和protected)。final可以用来修饰局部变量(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。

错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstractmethod封锁起来呢(同理，abstractmethod前不能加final)。

错。intx被修饰成final，意味着x不能在addOnemethod中被修改。

{publicstaticvoidmain(String[]args)

{

Othero=newOther();newSomething().addOne(o);

}

publicvoidaddOne(finalOthero)

{o.i++;}}

classOther{publicinti;}

和上面的很相似，都是关于final的问题，这有错吗

正确。在addOnemethod中，参数o被修饰成final。如果在addOnemethod里我们修改了o的reference，(比如:o=newOther();)，那么如同上例这题也是错的。但这里修改的是o的membervairable(成员变量)，而o的reference并没有改变。

正确。输出的是"i=0"。inti属於instantvariable(实例变量，或叫成员变量)。instantvariable有defaultvalue。int的defaultvalue是0。

错。finalinti是个final的instantvariable(实例变量，或叫成员变量)。final的instantvariable没有defaultvalue，必须在constructor(构造器)结束之前被赋予一个明确的值。可以修改为"finalinti=0;"。

错。看上去在main里calldoSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。staticmethod不能直接callnon-staticmethods。可改成"System.out.println("s.doSomething()returns"+s.doSomething());"。同理，staticmethod不能访问non-staticinstantvariable。

正确。从来没有人说过Java的Class名字必须和其文件名相同。但publicclass的名字必须和文件名相同。

A.+=B.<<=C.<<<=D.>>>=

A.很明显是赋值符号B.<<=左移赋值C.不是D.>>>=右移赋值，左边空出的位以0填充

A.ListB.SetC.SortedSetD.Map参考答案：D

A.FilterReaderB.InputStreamReaderC.PipedReaderD.Reader参考答案：D

参考答案：父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Mapinterface的一个实现HashMap允许将null作为一个entry的key或者value，而Hashtable不允许还有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

是值传递。Java编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

调用该访问返回一个以字符串指定类名的类的对象。

JDO是Java对象持久化的新的规范，为javadataobject的简称,也是一个用于存取某种数据仓库中的对

象的标准化API。JDO提供了透明的对象存储，因此对开发人员来说，存储数据对象完全不需要额外的代

码（如JDBCAPI的使用）。这些繁琐的例行工作已经转移到JDO产品提供商身上，使开发人员解脱出

只是面向关系数据库（RDBMS)JDO更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、

XML以及对象数据库（ODBMS）等等，使得应用可移植性更强。

Je22是Sun公司提出的多层(multi-diered),分布式(distributed),基于组件(component-base)的企业级应用

模型(enterprieseapplicationmodel).在这样的一个应用系统中，可按照功能划分为不同的组件，这些组件

又可在不同计算机上，并且处于相应的层次(tier)中。所属层次包括客户层(clietntier)组件,web层和组

件,Business层和组件,企业信息系统(EIS)层。

WebService描述语言WSDL

SOAP即简单对象访问协议(SimpleObjectAccessProtocol)，它是用于交换XML编码信息的轻量级协议。

UDDI的目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为WebService提供的、信息

注册中心的实现标准规范，同时也包含一组使企业能将自身提供的WebService注册，以使别的企业能够

发现的访问协议的实现标准。

每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过

这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。主要用到了MVC的设计模

标准建模语言UML。用例图,静态图(包括类图、对象图和包图),行为图,交互图(顺序图,合作图),实现图,

CORBA标准是公共对象请求代理结构(CommonObjectRequestBrokerArchitecture)，由对象管理

组织(ObjectManagementGroup，缩写为OMG)标准化。它的组成是接口定义语言(IDL),语言绑定

(binding:也译为联编)和允许应用程序间互操作的协议。其目的为：

用不同的程序设计语言书写

在不同的进程中运行为不同的操作系统开发

如何将数值型字符转换为数字（Integer，Double）

如何将数字转换为字符

如何去小数点前两位，并四舍五入。

Datedat=newDate();

dat.getYear();dat.getMonth();dat.getDay();dat.getHours();...

longnow=dat.getTime();

DateFormatedf=DateFormate.getInstance();

df.Format(dat);

如何列出某个目录下的所有文件

如何列出某个目录下的所有子目录

判断一个文件或目录是否存在

如何读写文件

1、基于JAVA技术，平台无关性表现突出

2、开放的标准，许多大型公司已经实现了对该规范支持的应用服务器。如BEA,IBM,ORACLE等。

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

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

(1)Easy:Java的语法比C++的相对简单,另一个方面就是Java能使软件在很小的机器上运行,基础解释其和

类库的支持的大小约为40kb,增加基本的标准库和线程支持的内存需要增加125kb.

(2)分布式:Java带有很强大的TCP/IP协议族的例程库,Java应用程序能够通过URL来穿过网络来访问远程对

象,由于servlet机制的出现,使Java编程非常的高效,现在许多的大的webserver都支持servlet.

(3)OO:面向对象设计是把重点放在对象及对象的接口上的一个编程技术.其面向对象和C++有很多不同,在

与多重继承的处理及Java的原类模型.

(4)健壮特性:Java采取了一个安全指针模型,能减小重写内存和数据崩溃的可能性。

(5)安全:Java用来设计网路和分布系统,这带来了新的安全问题,Java可以用来构建防病毒和防攻击的

System.事实证明Java在防毒这一方面做的比较好.

(6)中立体系结构:Java编译其生成体系结构中立的目标文件格式可以在很多处理器上执行,编译器产生的指

令字节码(Javabytecode)实现此特性,此字节码可以在任何机器上解释执行.

(7)可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定所以可移植性很好.

(8)多线程:Java处理多线程的过程很简单,Java把多线程实现交给底下操作系统或线程程序完成.所以多线程

是Java作为服务器端开发语言的流行原因之一

(9)Applet和servlet:能够在网页上执行的程序叫Applet,需要支持Java的浏览器很多,而applet支持动态的网

页,这是很多其他语言所不能做到的.

游标用于定位结果集的行，通过判断全局变量@@FETCH_STATUS可以判断是否到了最后，通常此变量

不等于0表示出错或到了最后。

SessionFacadePattern：使用SessionBean访问EntityBean

MessageFacadePattern：实现异步调用

EJBCommandPattern：使用CommandJavaBeans取代SessionBean，实现轻量级访问

DataTransferObjectFactory：通过DTOFactory简化EntityBean数据提供特性

GenericAttributeAccess：通过AttibuteAccess接口简化EntityBean数据提供特性

BusinessInterface：通过远程（本地）接口和Bean类实现相同接口规范业务逻辑一致性

ＥＪＢ架构的设计好坏将直接影响系统的性能、可扩展性、可维护性、组件可重用性及开发效率。项目越

复杂，项目队伍越庞大则越能体现良好设计的重要性

C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、

Sybase、Informix或SQLServer。客户端需要安装专用的客户端软件。B/S是Brower/Server的缩写，客户机上只要安装

一个浏览器(Browser),如NetscapeNavigator或InternetExplorer，服务器安装Oracle、Sybase、Informix或SQLServer

等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端

实现。浏览器通过webServer同数据库进行数据交互。

C/S与B/S区别：

1.硬件环境不同:

C/S一般建立在专用的网络上,小范围里的网络环境,局域网之间再通过专门服务器提供连接和数据交换服务.

应范围,一般只要有****作系统和浏览器就行

2.对安全要求不同

C/S一般面向相对固定的用户群,对信息安全的控制能力很强.一般高度机密的信息系统采用C/S结构适宜.可以通

过B/S发布部分可公开信息.

B/S建立在广域网之上,对安全的控制能力相对弱,可能面向不可知的用户。3.对程序架构不同

C/S程序可以更加注重流程,可以对权限多层次校验,对系统运行速度可以较少考虑.

B/S对安全以及访问速度的多重的考虑,建立在需要更加优化的基础之上.比C/S有更高的要求B/S结构的程序架构

是发展的趋势,从MS的.Net系列的BizTalk2000Exchange2000等,全面支持网络的构件搭建的系统.SUN和IBM推的

JavaBean构件技术等,使B/S更加成熟.

4.软件重用不同

C/S程序可以不可避免的整体性考虑,构件的重用性不如在B/S要求下的构件的重用性好.

B/S对的多重结构,要求构件相对独立的功能.能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石

头桌子

5.系统维护不同

C/S程序由于整体性,必须整体考察,处理出现的问题以及系统升级.升级难.可能是再做一个全新的系统

B/S构件组成,方面构件个别的更换,实现系统的无缝升级.系统维护开销减到最小.用户从网上自己下载安装就可以实

现升级.

6.处理问题不同

B/S建立在广域网上,面向不同的用户群,分散地域,这是C/S无法作到的.与****作系统平台关系最小.

7.用户接口不同

C/S多是建立的Window平台上,表现方法有限,对程序员普遍要求较高

B/S建立在浏览器上,有更加丰富和生动的表现方式与用户交流.并且大部分难度减低,减低开发成本.

8.信息流不同

C/S程序一般是典型的中央集权的机械式处理,交互性相对低

B/S信息流向可变化,B-BB-CB-G等信息、流向的变化,更像交易中心。

Java中的23种设计模式：

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

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

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

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

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

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

Observer（观察者模式），State（状态模式），Strategy（策略模式），TemplateMethod（模板方法模式），ChainOfResponsibility（责任链模式）

工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，

通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的****作。首先需要

定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同

的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

应用服务器：Weblogic、Tomcat、Jboss

WEBSERVER：IIS、Apache

BEAWebLogicServer，IBMWebSphereApplicationServer，Oracle9iApplicationServer，jBoss，Tomcat

J2EE服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，池驱动

程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的

数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。

request，session，application，cookie等

Servlet类（可以带有任何的include指令，但是没有include动作）表示。这既包括Servlet又包括被编译成Servlet

属性。这实质上是跨越整个Web应用程序，包括多个页面、请求和会话的一个全局作用域。

J2EE本身是一个标准，一个为企业分布式应用的开发提供的标准平台。J2EE也是一个框架，包括JDBC、JNDI、RMI、

JMS、EJB、JTA等技术。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程

并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。

这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。

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

有两种实现方法，分别是继承Thread类与实现Runnable接口

用synchronized关键字修饰同步方法

反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程

能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，

目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程

恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该

使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用

wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

主要有以下四方面：

1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了

解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。

2.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可

以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为

新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的

需要。

3.封装：封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世

界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

4.多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵

活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

A)表对应类

B)记录对应对象

C)表的字段对应类的属性

D)表之间的参考关系对应类之间的依赖关系

A)对于每个数据库事务，应该创建一个SessionFactory对象

B)一个SessionFactory对象对应一个数据库存储源。

C)SessionFactory是重量级的对象，不应该随意创建。如果系统中只有一个数据库存储源，只需要创建一个。

D)SessionFactory的load()方法用于加载持久化对象

A)none

B)save

C)delete

D)save-update

A)load()

B)save()

C)delete()

D)update()

E)open()

F)close()

原理：1.读取并解析配置文件2.读取并解析映射信息，创建SessionFactory3.打开Sesssion4.创建事务Transation5.持久化操作6.提交事务7.关闭Session8.关闭SesstionFactory

为什么要用：

1.对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。2.Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作3.hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。4.hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

1.Hibernate2延迟加载实现：a)实体对象b)集合（Collection）2.Hibernate3提供了属性的延迟加载功能当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。

1.内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存2.二级缓存：a)应用及缓存b)分布式缓存条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据c)第三方缓存的实现

1.使用双向一对多关联，不使用单向一对多2.灵活使用单向一对多关联3.不用一对一，用多对一取代4.配置对象缓存，不使用集合缓存5.一对多集合使用Bag,多对多集合使用Set6.继承类使用显式多态7.表字段要少，表关联不要怕多，有二级缓存撑腰

一种分页方法

<%

inti=1;

intnumPages=14;

Stringpages=request.getParameter("page");

intcurrentPage=1;

currentPage=(pages==null)(1):{Integer.parseInt(pages)}

sql="selectcount(*)fromtables";

ResultSetrs=DBLink.executeQuery(sql);

while(rs.next())i=rs.getInt(1);

intintPageCount=1;

intPageCount=(i%numPages==0)(i/numPages):(i/numPages+1);

intnextPage;

intupPage;

nextPage=currentPage+1;

if(nextPage>=intPageCount)nextPage=intPageCount;

upPage=currentPage-1;

if(upPage<=1)upPage=1;

rs.close();

sql="select*fromtables";

rs=DBLink.executeQuery(sql);

i=0;

while((i

%>

//输出内容

//输出翻页连接

for(intj=1;j<=intPageCount;j++){

if(currentPage!=j){

}else{

out.println(j);

后页

存储过程是用户定义的一系列sql语句的集合，涉及特定表或其它对象的任务，用户可以调用存储过程，而函数通常是数据库已定义的方法，它接收参数并返回某种类型的值并且不涉及特定用户表。

事务是作为一个逻辑单元执行的一系列操作，一个逻辑工作单元必须有四个属性，称为ACID（原子性、

一致性、隔离性和持久性）属性，只有这样才能成为一个事务：

原子性

事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。

一致性

改，以保持所有数据的完整性。事务结束时，所有的内部数据结构（如B树索引或双向链表）都必须是

正确的。

隔离性

由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。事务查看数据时数据所处的状态，要么

是另一并发事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看中间状态的数据。

这称为可串行性，因为它能够重新装载起始数据，并且重播一系列事务，以使数据结束时的状态与原始事

务执行的状态相同。

持久性

事务完成之后，它对于系统的影响是永久性的。该修改即使出现系统故障也将一直保持。

事前触发器运行于触发事件发生之前，而事后触发器运行于触发事件发生之后。通常事前触发器可以获取

事件之前和新的字段值。

语句级触发器可以在语句执行前或后执行，而行级触发在触发器所影响的每一行触发一次。

EJB角色主要包括Bean开发者应用组装者部署者系统管理员EJB容器提供者EJB服务器提供者

三个对象是Remote（Local）接口、Home（LocalHome）接口，Bean类

会话（Session）Bean，实体（Entity）Bean消息驱动的（MessageDriven）Bean

会话Bean又可分为有状态（Stateful）和无状态（Stateless）两种

实体Bean可分为Bean管理的持续性（BMP）和容器管理的持续性（CMP）两种

对于StatelessSessionBean、EntityBean、MessageDrivenBean一般存在缓冲池管理，而对于Entity

Bean和StatefullSessionBean存在Cache管理，通常包含创建实例，设置上下文、创建EJBObject

（create）、业务方法调用、remove等过程，对于存在缓冲池管理的Bean，在create之后实例并不从内存

清除，而是采用缓冲池调度机制不断重用实例，而对于存在Cache管理的Bean则通过激活和去激活机制保

持Bean的状态并限制内存中实例数量。

以StatefullSessionBean为例：其Cache大小决定了内存中可以同时存在的Bean实例的数量，根据MRU

或NRU算法，实例在激活和去激活状态之间迁移，激活机制是当客户端调用某个EJB实例业务方法时，如

果对应EJBObject发现自己没有绑定对应的Bean实例则从其去激活Bean存储中（通过序列化机制存储实

例）回复（激活）此实例。状态变迁前会调用对应的ejbActive和ejbPassivate方法。

remote接口定义了业务方法，用于EJB客户端调用业务方法

home接口是EJB工厂用于创建和移除查找EJB实例

一、设置JNDI服务工厂以及JNDI服务地址系统属性

二、查找Home接口

三、从Home接口调用Create方法创建Remote接口

四、通过Remote接口调用其业务方法

工作机制：

Struts的工作流程:在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将执行如下流程.-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;-(4)如果ActionForm的validate()方法返回或返回一个不包含ActionMessage的ActuibErrors对象,就表示表单验证成功;-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件;-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;

为什么要用：JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。

在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。

MVC模式:web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。

Ans:AsJSPcannotbeconfiguredasadefaultmappingtobecalledbasedonaURLpatterninweb.xmlfile.Inthatcase,notallrequestgoesthroughaJSPcontroller,andtheverypurposeofcontrollerisnotachieved.AsServletcanbemappedtoaparticularURLinweb.xmllike,

SampleController/*

Ans:AsJSPiseasilyconfigurableatruntimeandbyusingTaglibrary,XSL,andmanymorescriptinglanguage,productivityincreasesbyusingJSPinsteadofServlet.

Ans:ItistruethatconnectionpoolcanbeinstantiatedininitmethodofServletandisavailableforthewebapplicationtouse,butgenerallytherecanbemanywebapplicationrequiredtousedatabaseconnectionpool,andmultiplewebapplicationsdonothaveaccessbeyondServletContext.Soitisdesirabletohaveexternalresourcesdefinedatserverlevel,notatanapplicationlevel.

Ifyoufeelanyofthequestionand/oranswerisnotcorrectorincomplete,pleasewritetous,yoursuggestionsandafterthoroughreview,itwillbeplacedonthispage.Addyoursuggestionsatbelow.

MVC是Model－View－Controller的简写。"Model"代表的是应用的业务逻辑（通过JavaBean，EJB组

件实现），"View"是应用的表示面（由JSP页面产生），"Controller"是提供应用的处理过程控制（一般

是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可

以进行交互和重用。

Struts是采用JavaServlet/JavaServerPages技术，开发Web应用程序的开放源码的framework。采

用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。Struts有如下的主要功能：

一.包含一个controllerservlet，能将用户的请求发送到相应的Action对象。

二.JSP自由tag库，并且在controllerservlet中提供关联支持，帮助开发员创建交互式表单应用。

三.提供了一系列实用对象：XML处理、通过JavareflectionAPIs自动处理JavaBeans属性、国际化的提示

和消息。

在struts-config.xml加入一个插件，通过它加载applicationContext.xml在struts-config.xml修改action-mapping标记，具体action交给了DelegateActionProxy通过DelegateActionProxy进入一spring的环境。u在spring的applicationContext.xml加入

strusts：是一种基于MVC模式的一个web层的处理。Spring:提供了通用的服务，ioc/diaop,关心的不仅仅web层，应当j2ee整体的一个服务，可以很容易融合不同的技术strutshibernateibatisejbremotespringJDBCspringMVC

国际化:不用修改代码，就适用于不同的语言国家本地化:如果要适应一个国家，要修改源代码实现过程:在struts-config.xml中用如下标签说明资源文件名，注意其只是文件名，没有语言_国家在资源文件对应的目录struts中加入适应不同语言、国家的properties文件ApplicationResources_zh_CN.properties中国ApplicationResources_en_US.propertiesus如果不是英语要转码native2ascii-encodinggb2312源ApplicationResources_zh_CN.properties在jsp页面中用取出信息

手动:publicclassmyFormextendsActionForm{publicActionErrorsvalidate(){actionErrors.add(ActionErrors.GLOBAL_MESSAGE,newActionMessage(”properties中的键名”));}}struts-config.xml中修改action的标签validate=trueinput=”错误页面”如果validate方法中的ActionErrors不为空且size>0时会回到input页面。自动publicclassmyFormextendsValidateForm{不能覆盖validate方法。//publicvoidvalidate()//{//}}在struts-config.xml文件中加入插件修改validation.xml中的内容errors.required={0}isrequired.errors.minlength={0}cannotbelessthan{1}characters.

minlength6struts-config.xml中修改action的标签validate=trueinput=”/错误页面”

Struts-config.xml

DataSourceds=(DataSource)this.getServlet().getServletContext().getAttribute(”data”);Connectioncon=ds.getConnection();

消息资源文件是一些简单的.properties文件，这些文件包含有可以被struts项目使用的消息信息，消息资源文件可以以标签的形式添加到struts-config.xml文件，例如

可以使用标签来进行基于validation.xml的客户端验证。例如代码会按照validation.xml中的定义为logonForm生成客户端javascript代码。

Struts1Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。Struts2Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

SSH：Struts（表示层）+Spring（业务层）+Hibernate（持久层）Struts：Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。（View：沿用JSP，HTTP，Form，Tag，Resourse；Controller：ActionServlet，struts-config.xml，Action）Hibernate：Hibernate是一个持久层框架，它只负责与关系数据库的操作。Spring：Spring是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。

${db.driver}${db.url}${db.username}${db.password}

java:comp/env/jdbc/myDatasource

1、使用配置文件中的destory-method属性与初始化属性init-methods类似，在Bean的类中实现一个撤销Bean的方法，然后在配置文件中通过destory-method指定，那么当bean销毁时，Spring将自动调用指定的销毁方法。

2、实现org.springframwork.bean.factory.DisposebleBean接口如果实现了DisposebleBean接口，那么Spring将自动调用bean中的Destory方法进行销毁，所以，Bean中必须提供Destory方法。

通过xml配置文件

bean配置在xml里面，spring提供多种方式读取配置文件得到ApplicationContext.

第一种方式：FileSystemXmlApplicationContext

通过程序在初始化的时候，导入Bean配置文件，然后得到Bean实例:ApplicationContextac=newFileSystemXmlApplicationContext(”applicationContext.xml”)ac.getBean(”beanName”);

第二种方式：WebApplicationContextUtil

在B/S系统中,通常在web.xml初始化bean的配置文件，然后由WebAppliCationContextUtil得到ApplicationContext.例如：ApplicationContextctx=WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContextsc);ApplicationContextctx=WebApplicationContextUtils.getWebApplicationContext(ServletContextsc);

其中servletContextsc可以具体换成servlet.getServletContext()或者this.getServletContext()或者request.getSession().getServletContext();

另外，由于spring是注入的对象放在ServletContext中的，所以可以直接在ServletContext取出WebApplicationContext对象：

WebApplicationContextwebApplicationContext=(WebApplicationContext)servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

SetterInterfaceconstructor

使用applicationContext.getResource(“classpath:文件名”):在src根目录下，在类路径下applicationContext.getResource(“classpath:/chap01/文件名”):以src根目录下的基准往下走。applicationContext.getResource(“file:c:/a.properties”)：在系统文件目录下。

在web.xml中加入如下同容,在启动web服务器时加载/WEB-INF/applicationContext.xml中的内容。contextorg.springframework.web.context.ContextLoaderServlet1通过如下类得到ApplicationContext实例WebApplicationContextUtils.getWebApplicationContext

事件ExtendsApplicationEvent监听器ImplementsApplicationListener事件源ImplementsApplicationContextAware在applicationContext.xml中配置事件源、监听器先得到事件源，调用事件源的方法，通知监听器。

Ioc:程序在运行过程中，根据配置文件动态加载所依赖的配置类

测试:Spring:pojoEjb:二个接口一个类,一堆配置文件事务类型Spring:jdbcjtahibernateEjb:jta成本Spring:普通容器(tomcatjboss)Ejb:weblogicjboss开发的周期:Spring远比ejb快.

代码管理的事务处理TransactonTemplate的execute方法中的内部类TransactionCallback中的doInTransaction方法中使用。publicvoidmake(){TransactionTemplatejtm=newTransactionTemplate(this.getTransactionManager());jtm.execute(newmyClass1());}publicclassmyClass1implementsTransactionCallback{publicObjectdoInTransaction(TransactionStatustrans){JdbcTemplatejdbc=newJdbcTemplate(dataSource);jdbc.execute("insertintocustomer(customerName)values('b')");jdbc.execute("insertintocustomer(customerName)values('b')");returnnull;}}容器管理的事务处理

DatasoucetransactionManageruserDao要注入DatasoucetransactionManager通过如下类实现TransactionTemplateJdbcTemplate

DatasoucetransactionManageruserDao要注入DatasouceProxy代理Target:userDao：代理对象(目标对象)transactionAttributes(那些方法需要事务处理)transactionManager(事务处理服务)

不需要

在myeclipse中先加入spring环境再加入hibernate环境。如果spring与hibernate结合在一起可以不需要hibernate.cfg.xml文件是否正确spring+hibernate的配置文件中的主要类有那些如何配置dataSourcesessionFactory:hibernate.cfg.xmltransactionManageruserDao(extendsHibernateDaoSupport)sessionFactoryfacadeproxysessionFactorytransactionManagerfacade

extendsHibernateDaoSupport，可以节省代码。

在struts-config.xml加入一个插件，通过它加载applicationContext.xml在struts-config.xml修改action-mapping标记，具体action交给了DelegateActionProxy

通过DelegateActionProxy进入一spring的环境。在spring的applicationContext.xml加入

org.springframework.web.context.ContextLoaderListener或：contextorg.springframework.web.context.ContextLoaderServlet1通过如下方法取出applicationContext实例:ApplicationContext

ac=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext);

一个用于多行html标签元素的显示，span多用于文本显示

html框架只有frameset和iframe两个标签可以代表html框架

\r\n

如果有数据提交到server端时用webcontrol好。一般为了提高效率能用htmlcontrol在客户端执行，就用htmlcontrol。

JavaScript中的Object是一组数据的key-value的集合,有点类似于Java中的有这些数据都是Object里的property.通常情况下,JavaScript中建立一个对象用”new”加上constructorfunction来实现.如newDate(),newObject()等.

varbook=newObject();

book.name="JavaScriptisCool";

book.author="tom";

book.pages=514;HashMap,所

上面例子中的name和page就是名为book的对象中的property.我们可以用delete来删除Object中的property:“deletebook.name;”.除了Object,Date等buildin的对象外,我们可以写自己的constructorfunction,然后使用new就可以建立自己的对象.如上面的book可以写成:

functionBook(name,author,page){

this.name=name;

this.author=author;

this.page=page;

varabook=newBook("JavaScriptisCool","tom",514);

在JavaScript中,function是一种数据类型,所有的function都是从buildin的Functionobject衍生的对象.所以在JavaScript中function可以作为参数传递,可以作为Object的property,也可以当作函数返回值.function在JavaScript中有两种用法,一种是当作constructor,前面加上newkeyword用来建立对象.一种是当作method,为其他对象调用.

注意function和method在中文里的意思相当,在有些语言里也可以通用.但是在JavaScript中,它们还是有所区别的.function本身是是一个对象,而当作为一个方法他属于一个对象时,就成为了一个这个对象的method,相当于一个对象种的属性.也就是说method是相对于一个对象而言的,function在某些情况下成为了一个对象的method.

this.getReader=Book_getReader;

functionBook_getReader(){

//....

上面的例子种,functionBook_getReader()就成为了Book的一个名为getReader的method.call()和apply()是Functionobject的两个方法,它们也可以使一个function作为另一个对象的method来调用用.call()和apply()都需要参数,而第一个参数就是调用对象,也就是当function内部出现this时,this所指的对象.call()和apply()的区别在于call()可以传递任意长度参数,只要第一个参数时调用对象.而apply只接受两个参数,需要将除调用对象外的所有参数放入一个数组中.即:

functiongetBooksWithSameAuthor(form,to){

varname=this.author;

varbooks=...

//getbookswrittenbynameandfromyear"from"toyear"to"

returnbooks;

varbooks=getBooksWithSameAuthor.call(abook,1990,2005);

或

varbooks=getBooksWithSameAuthor.apply(abook,[1990,2005]);

当一个function不作为一个对象的method时,JavaScript会认为它是属于一个GlobleObject对象的method,这个GlobleObject在Browser中就是window类.所以从这个角度来说,function和method又可以统一起来了.

Functionobject还有一个非常重要的property:prototype.它是一个predefined的prototypeobject.当一个Function用作对象的constructor时,protptypeproperty将发挥作用,中文翻译叫原型.JavaScript的新对象就是通过function的原型来建立的.同时我们还可以利用prototype来动态的向对象中添加属性,如:

Book.prototype.getInfo=getInfo;

functiongetInfo(){

returnthis.name+"writtenby"+this.author+"with"+this.page+"pages";

alert(abook.getInfo());

这里有一个例子,用prototype方法来实现callback:

Function.prototype.andThen=function(g){

varf=this;

returnfunction(){

f();g();

};

functionManager(){

this.callback=function(){};//donothing

this.registerCallback=function(callbackFunction){

this.callback=(this.callback).andThen(callbackFunction);

varmanager=newManager();

manager.registerCallback(sayHi);

manager.registerCallback(sayBye);

manager.callback();

JavaScript有多种方式模拟继承.

1.利用function:

functionsuperClass(){

this.bye=superBye;

this.hello=superHello;

functionsubClass(){

this.inheritFrom=superClass;

this.inheritFrom();

this.bye=subBye;

或者:

superClass.call(this);

先定义subClass的inheritFrom方法,再调用这个方法(方法名称并不重要),或者直接使用FunctionObject的call方法将this做参数,都可以模拟实现从superClass的继承.注意调用superClass时的this指向.这个方法就是在执行subClass的cunstructorfunction时,先执行supperClass的cunstructorfunction.这个方法的缺点在于子类仅仅是在自己的构造函数中,将this作为参数调用了父类的构造函数,将构造函数赋予父类的所有域赋予子类.所以,任何父类在构造函数之外(通过prototype)定义的域,子类都无法继承.而且子类的构造函数一定要在定义自己的域之前调用父类的构造函数,免得子类的定义被父类覆盖.使用这种方法子类也尽量不要使用prototype来定义子类的域,因为prototype的定义在子类new的之后就执行,所以它一定会在调用父类构造函数前,同样会有被父类的定义覆盖的危险.

2.利用prototype:

subClass.prototype=newsuperClass();

subClass.prototype.constructor=superClass;

这里将一个superClass的实例设置成subclass的原型:protytype,由于newsuperClass实例一定会调用父类prototype定义的所有域,所以这种方法避免了上一种方法的一个问题,父类可以通过prototype来描述域.可以实现从superClass的继承.而这个方法也有缺点,由于子类的peototype已经是父类的实例(Object实例),不能再被实例化,所以new子类实例的时候,父类的所有非基本数据类型(见JavaScript数据类型)都将是referencecopy而非数据copy.简单说就是所有的父类域在子类中虽然存在,但看起来就像Java中的static域一样在子类间share.被一个子类改变,所有子类都会改变.

注意这里的最后一句,改变了子类prototype中的constructor属性.它对子类使用没有影响,仅仅是为了在调用instanceOf方法时它使得子类实例返回subClass.

3.ParasiticInheritance(寄生继承)

this.base=newsupperClass();

base.sayBye=subBye;

returnbase;

这种继承其实是一种扩展,因为在调用instanceOf时,子类会返回父类名称,它的好处在于在构造函数继承的基础上解放了父类,父类可以使用prototype定义自己的域,但是子类仍然不建议使用prototype,以免被父类覆盖.为了可以使子类的instanceof返回正确类型,我们可以再改进一下:

for(varkeyinthis.base){

if(!this[key]){

this[key]=this.base[key];

this.sayBye=subBye;

将所有的父类域拷贝给子类一份,不再返回父类,instanceof子类实例时就可以返回正确类型.

通常情况下,this代表的是前面提到的GlobleObject.也就是Browser环境时的windowObject.当function作为某一对象的method时,this代表这个function所属的object.下面这段代码有格错误,涉及到this的使用:

functionEmployee(a){

this.name=a;

functioninit(){

John=Employee("Johnson");

alert(John.name);

在init()中我们少了一个newkeyword.于是这个代码就会报错,因为Browser把Employee当作是windowobect的一个method,里面的this指的就是windowobject.init()应该改为:

John=newEmployee("Johnson");

同时我们也可以将Employee的constructor函数修改,防止类似的错误:

if(!(thisinstanceofEmployee))returnnewEmployee(a);

这样,我们即使使用原来的init()方法,也不会报错了.

Array和Object本质上是一样的,只是Array需要由index来索引它其中的属性.index为>=0的整数.

Array有一系列buildin的方法:

1.jion()将array中的所有element以string的形式连在一起:

1

2

3

vara=[1,2,3];

s=a.join();//s=="1,2,3"

s=a.join(":");//s=="1:2:3"

2.reverse()将Array的element顺数颠倒

a.reverse();

s=a.join();//s=="3,2,1"

3.sort()排序,默认按字母顺序排序casesensitive,可以自定义排序方式.

vara=[111,4,33,2];

a.sort();//a==[111,2,33,4]

a.sort(function(a,b){//a==[2,4,33,111]

returna-b;//Returns<0,0,or>0

});

4.concat()连接多个Array

a.concat(4,5);//return[1,2,3,4,5]

a.concat([4,5]);//return[1,2,3,4,5]

a.concat([4,5],[6,7])//return[1,2,3,4,5,6,7]

a.concat(4,[5,[6,7]]);//return[1,2,3,4,5,6,7]

5.slice()返回Array的切片,原Array不变.

vara=[1,2,3,4,5];

a.slice(0,3);//Returns[1,2,3]

a.slice(3);//Returns[4,5]

a.slice(1,-1);//Returns[2,3,4],-1meansthelastindexofthearray

a.slice(-3,-2);//Returns[3],fromthethirdlastindextothesecondlastindex

6.splice向一个Array中添加或删除element.第一个参数表示位置,第二个参数表示删除长度,后面任意长的参数表示在1删除位置添加的elements.

vara=[1,2,3,4,5,6,7,8];

a.splice(4);//Returns[5,6,7,8];ais[1,2,3,4]

a.splice(1,2);//Returns[2,3];ais[1,4]

a.splice(1,1);//Returns[4];ais[1]

a.splice(2,0,'a','b');//Returns[];ais[1,2,'a','b',3,4,5]

a.splice(2,2,[1,2],3);//Returns['a','b'];ais[1,2,[1,2],3,3,4,5]

7.push()andpop()向Array末尾添加或删除element

8.unshift()andshift()向Array的开头添加或删除eleme

10.用js实现主、二级页面刷新、传值以及实现页面跳转

JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）：request用户端请求，此请求会包含来自GET/POST请求的参数response网页传回用户端的回应pageContext网页的属性是在这里管理session与请求有关的会话期applicationservlet正在执行的内容out用来传送回应的输出configservlet的构架部件pageJSP网页本身exception针对错误网页，未捕捉的例外

JSP共有以下6种基本动作jsp:include：在页面被请求的时候引入一个文件。jsp:useBean：寻找或者实例化一个JavaBean。jsp:setProperty：设置JavaBean的属性。jsp:getProperty：输出某个JavaBean的属性。jsp:forward：把请求转到一个新的页面。jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

动态INCLUDE用jsp:include动作实现它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面<%@includefile="included.htm"%>

有两种，分别为：前者页面不会转向include所指的页面，只是显示该页的结果，主页面还是原来的页面。执行完后还会回来，相当于函数调用。并且可以带参数.后者完全转向新页面，不会再回来。相当于goto语句。

只需增加如下指令<%@pageisThreadSafe="false"%>

通过内置的request对象即可，如下：<%Stringitem=request.getParameter("item");inthowMany=newInteger(request.getParameter("units")).intValue();%>

静态包含如下：<%@includefile="copyright.html"%>动态包含如下：

主要有四中方法：1。<%--与--%>2。//3。/**与**/4。

把如下脚本加入到JSP文件的开始即可：<%response.setHeader("Cache-Control","no-store");//HTTP1.1response.setHeader("Pragma","no-cache");//HTTP1.0response.setDateHeader("Expires",0);//preventscachingattheproxyserver%>

COOKIE是作为HTTPHEADER的一部分被发送的，如下方法即可设置：<%Cookiemycookie=newCookie("aName","aValue");response.addCookie(mycookie);%>

如下例：<%if(request.getParameter("wen")!=null){//dosomething}else{return;}%>

可以使用SUN的专用包：sun.net.smtp包。如下脚本使用SmtpClient类发送EMAIL。<%@pageimport="sun.net.smtp.SmtpClient,java.io.*"%><%Stringfrom="ybwen@sina.com";Stringto="hewenjun@yeah.net,lei@who.com.cn";try{SmtpClientclient=newSmtpClient("mail.xxxxx.xxx");client.from(from);client.to(to);PrintStreammessage=client.startMessage();message.println("To:"+to);message.println("Subject:SendingemailfromJSP!");message.println("ThiswassentfromaJSPpage!");message.println();message.println("Cool!:-)");message.println();message.println("GoodBoy");message.println("Imingenius.com");message.println();client.closeServer();}catch(IOExceptione){System.out.println("ERRORSENDINGEMAIL:"+e);}%>

当然没问题，如下展示了如何在一个SERVLET控制逻辑单元内调用一个JSP错误页面。protectedvoidsendErrorRedirect(HttpServletRequestrequest,HttpServletResponseresponse,StringerrorPageURL,Throwablee)throwsServletException,IOException{request.setAttribute("javax.servlet.jsp.jspException",e);getServletConfig().getServletContext().getRequestDispatcher(errorPageURL).forward(request,response);}publicvoiddoPost(HttpServletRequestrequest,HttpServletResponseresponse){try{//dosomething}catch(Exceptionex){try{sendErrorRedirect(request,response,"/jsp/MyErrorPage.jsp",ex);}catch(Exceptione){e.printStackTrace();}}}

可以用URLConnection

下面的代码段作了很好的示范<%@pageimport="javax.naming.*,javax.rmi.PortableRemoteObject,foo.AccountHome,foo.Account"%><%!//定义一个对SessionBeanHome接口实例的全局引用AccountHomeaccHome=null;publicvoidjspInit(){//获得Home接口实例InitialContextcntxt=newInitialContext();Objectref=cntxt.lookup("java:comp/env/ejb/AccountEJB");accHome=(AccountHome)PortableRemoteObject.narrow(ref,AccountHome.class);}%><%//实例化SessionBeanAccountacct=accHome.create();//调用远程方法acct.doWhatever(...);//如此等等%>

可以定义一个简单的函数来达到目的，如下：<%!Stringblanknull(Strings){return(s==null)"":s;}%>然后在JSP的FORM中，可以这样使用">

现提供两个解决方案：A：使用HTTP，B：在Servlet中，通过设置ContentType和使用java.io包的Stream等类可作到.例如：response.setContentType("application/x-msword");然后想输出缓冲中写一些东东即可。

使用如下两标签即可：

使用request.getHeader(String)即可

当然可以，用

因为没有热替换。

前一个为静态包含，而后一个为动态包含

1。对JAVA程序进行调试没有好东东2。因大多数的servlet引擎不支持connectionpooling3。Servlet引擎没有标准4。JSP与其它脚本语言的交互

为各种版本提供resourcebundles属性文件即可

当然可以，HttpSessionsession=request.getSession(true);session.putValue("variable","value");

用Cookie.setMaxAge(int)

可以使用HttpSessionListeners来跟踪

当然可能

使用response.sendRedirect("newURL")

可使用sed/awk即可

JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。

代码：

newAjax.Request(’/your_url’),

method:'get’,

onSuccess:function(transport){

varresponse=transport.responseText||“noresponsetext”;

alert(”Success!”);

},

onFailure:function(){alert(’failure’)}

页面需要保存以下参数：

总行数：根据sql语句得到总行数

每页显示行数：设定值

当前页数：请求参数

页面根据当前页数和每页行数计算出当前页第一行行数，定位结果集到此行，对结果集取出每页显示行数

的行即可。

动态INCLUDE用jsp:include动作实现它总是会检查所含文

件中的变化，适合用于包含动态页面，并且可以带参数。静态INCLUDE用include伪码实现,定不会检查所含文件的变化，

适用于包含静态页面<%@includefile="included.htm"%>

<%@pagelanguage="java"contenType="text/html;charset=gb2312"session="true"buffer="64kb"

autoFlush="true"isThreadSafe="true"info="text"errorPage="error.jsp"isErrorPage="true"

isELIgnored="true"pageEncoding="gb2312"import="java.sql.*"%>

isErrorPage(是否能使用Exception对象)，

isELIgnored(是否忽略表达式)

<%@includefile="filename"%>

Jsp页面中的form标签里的method属性为get时调用doGet()，为post时调用doPost()。

JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。

Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而

JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。

setAttribute(Stringname,Object)：设置名字为name的request的参数值

getAttribute(Stringname)：返回由name指定的属性值

getAttributeNames()：返回request对象所有属性的名字集合，结果是一个枚举的实例

getCookies()：返回客户端的所有Cookie对象，结果是一个Cookie数组

getCharacterEncoding()：返回请求中的字符编码方式

getContentLength()：返回请求的Body的长度

getHeader(Stringname)：获得HTTP协议定义的文件头信息

getHeaders(Stringname)：返回指定名字的requestHeader的所有值，结果是一个枚举的实例

getHeaderNames()：返回所以requestHeader的名字，结果是一个枚举的实例

getInputStream()：返回请求的输入流，用于获得请求中的数据

getMethod()：获得客户端向服务器端传送数据的方法

getParameter(Stringname)：获得客户端传送给服务器端的有name指定的参数值

getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例

getParameterValues(Stringname)：获得有name指定的参数的所有值

getProtocol()：获取客户端向服务器端传送数据所依据的协议名称

getQueryString()：获得查询字符串

getRequestURI()：获取发出请求字符串的客户端地址

getRemoteAddr()：获取客户端的IP地址

getRemoteHost()：获取客户端的名字

getServerName()：获取服务器的名字

getServletPath()：获取客户端所请求的脚本文件的路径

getServerPort()：获取服务器的端口号

removeAttribute(Stringname)：删除请求中的一个属性

JSP共有以下6种基本动作

jsp:inlude：在页面被请求的时候引入一个文件。

jsp:useBean：寻找或者实例化一个JavaBean。

jsp:setProperty：设置JavaBean的属性。

jsp:getProperty：输出某个JavaBean的属性。

jsp:forward：把请求转到一个新的页面。

jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。

有两种，分别为：

前者页面不会转向include所指的页面，只是显示该页的结果，主页面还是原来的页面。执行完后还会回来，相当于函数调

用。并且可以带参数.后者完全转向新页面，不会再回来。相当于goto语句。

AJAX的全称是AsynchronousJavaScriptAndXML.AJAX是2005年由Google发起并流行起来的编程方法，AJAX不是一个新的编程语言，但是它是一个使用已有标准的新的编程技术。使用AJAX可以创建更好，更快，更用户界面友好的Web应用。AJAX技术基于Javascript和HTTPRequest.

*Dojo（dojotoolkit.org）；*Prototype和Scriptaculous（www.prototypejs.org和script.aculo.us）；*DirectWebReporting（getahead.org/dwr）；*Yahoo!UserInterfaceLibrary（developer.yahoo.com/yui）；*GoogleWebToolkit（code.google.com/webtoolkit）。*JQuery

通过XMLHttpRequest对象，Web开发人员可以在页面加载以后进行页面的局部更新。AJAX开始流行始于Google在2005年使用的”GoogleSuggest”。“GoogleSuggest”就是使用XMLHttpRequest对象来创建动态的Web接口：当用户开始输入google的搜索框，Javascript发送用户输入的字符到服务器，然后服务器返回一个建议列表。XMLHttpRequest对象在IE5.0+,Safari1.2,Mozilla1.0/Firefox,Opera8+和NetScapt7开始被支持。

在传统的Javascript编程中，如果想得到服务器端数据库或文件上的信息，或者发送客户端信息到服务器，需要建立一个HTMLform然后GET或者POST数据到服务器端。用户需要点击”Submit”按钮来发送或者接受数据信息，然后等待服务器响应请求，页面重新加载。因为服务器每次都会返回一个新的页面，所以传统的web应用有可能很慢而且用户交互不友好。使用AJAX技术，就可以使Javascript通过XMLHttpRequest对象直接与服务器进行交互。通过HTTPRequest，一个web页面可以发送一个请求到web服务器并且接受web服务器返回的信息(不用重新加载页面)，展示给用户的还是通一个页面，用户感觉页面刷新，也看不到到Javascript后台进行的发送请求和接受响应。

可以使用jQuery的插件–jQuery-validate表单验证插件来进行表单验证

例子：

可以使用Prototype的Ajax.PeriodicalUpdater来实现页面的局部刷新。

比如如果页面上需要定时刷新的部分为