最全面的java面试题-----是你更好的掌握java知识
最全面的java面试题-----是你更好的掌握java知识
目录
l 概念题--- 1
一、 JAVA基础--- 1
1) 面向对象的特征--- 1
2) 什么是OOP？什么是类？请对比类和对象实例之间的关系。--- 1
3) 简述类与对象的概念--- 2
4) 什么是属性与方法？--- 2
5) 什么是封装？--- 2
6) 描述一下JVM加载class文件的原理机制--- 2
7) Java程序怎么优化？--- 2
8) 一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？--- 2
9) char型变量中能不能存贮一个中文汉字--- 3
10) 逻辑操作符 (&,|,^)与条件操作符(&&,||)的区别--- 3
11) Math.round(11.5)等於多少? Math.round(-11.5)等於多少？--- 3
12) Java有没有goto？--- 3
13) int 和 Integer 的区别--- 3
14) 如何将数值型字符转换为数字？如何去小数四舍五入保留小数点后两位。--- 3
15) short s1 = 1; s1 = s1 + 1;和short s1 = 1; s1 += 1;有什么错误--- 3
16) float f=3.4是否正确?- 4
17) String 和StringBuffer的区别--- 4
18) String是否是最基本的数据类型，能否被继承--- 4
19) String s = new String("xyz");创建了几个String Object？--- 4
20) 数组有没有length()这个方法? String有没有length()这个方法？--- 4
21) 排序都有哪几种方法？用JAVA实现一个快速排序--- 4
22) swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上--- 5
23) 在JAVA中，如何跳出当前的多重嵌套循环？--- 5
24) 关于日期和时间的几个问题--- 5
25) 一个对象被当作参数传递到一个方法，是值传递还是引用传递--- 5
26) 什么时候用assert？--- 5
27) GC是什么? 为什么要有GC？--- 5
28) 垃圾回收的优点和原理--- 5
29) 垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？--- 6
30) java中会存在内存泄漏吗，请简单描述--- 6
31) java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，他们分别是哪些类？--- 6
32) 文件和目录（I/O）操作--- 6
33) 什么是java序列化？如何实现java序列化？--- 7
34) JAVA事件委托机制的概念--- 7
35) 谈谈你对Swing的MVC模式的理解？--- 7
36) MVC结构在JTable中怎样实现的，这种结构有什么好处？--- 8
二、 类与继承--- 9
37) 说出一些常用的类，包，接口，请各举5个--- 9
38) 接口有什么优点？--- 9
39) 静态变量和实例变量的区别--- 9
40) 是否可以从一个static方法内部发出对非static方法的调用？--- 9
41) java 有几种修饰符？分别用来修饰什么？--- 9
42) 作用域public,private,protected,以及不写时的区别--- 10
43) final, finally, finalize的区别--- 10
44) 内部类可以引用他包含类的成员吗？有没有什么限制？--- 10
45) 匿名内部类是否可以继承其它类？是否可以实现接口？--- 10
46) java中实现多态的机制是什么？--- 11
47) Overload和Override的区别，Overloaded的方法能否改变返回值的类型？--- 11
48) abstract class和interface的区别--- 11
49) 接口是否可继承接口? 抽象类是否可实现接口? 抽象类是否可继承实体类?- 11
50) abstract的method是否可同时是static或native或synchronized？--- 11
51) 构造器Constructor是否可被override- 11
52) 写clone()方法时，通常都有一行代码，是什么？--- 12
53) Object类的概述--- 12
三、 异常--- 13
54) Java中的异常处理机制的简单原理和应用。--- 13
55) JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？ 13
56) error和exception的区别--- 13
57) 运行时异常与一般异常的区别--- 14
58) 给我一个你最常见到的runtime exception(运行时异常) 14
59) try 里有一个return语句，那finally 里的代码会不会被执行？在return前还是后执行？--- 14
四、 集合--- 15
60) 集合类都有哪些--- 15
61) 介绍JAVA中的Collection FrameWork- 15
62) ArrayList和Vector的区别--- 15
63) HashMap和Hashtable的区别--- 15
64) Collection 和 Collections的区别--- 16
65) 说出ArrayList,Vector, LinkedList的存储性能和特性--- 16
66) heap和stack的区别--- 16
67) List, Set, Map是否继承自Collection接口？--- 16
68) List, Set, Map三个接口，存取元素时，各有什么特点？--- 16
69) Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别？ 17
70) 两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对--- 17
五、 多线程--- 18
71) 启动一个线程是用run()还是start()？--- 18
72) sleep() 和 wait() 的区别--- 18
73) stop()和suspend()方法为何不推荐使用？--- 18
74) 同步和异步有何异同，在什么情况下分别使用他们--- 18
75) 当一线程进入一对象的一个synchronized方法后，其它线程可否进入此对象的其它方法--- 18
76) 线程同步的方法--- 19
77) 多线程有几种实现方法--- 19
78) 线程的基本概念、线程的基本状态以及状态之间的关系--- 19
79) 简述synchronized和java.util.concurrent.locks.Lock的异同--- 19
80) 多线程的优点--- 19
六、 JDBC及数据库相关--- 21
81) Class.forName的作用?为什么要用?- 21
82) JDBC调用数据库的基本步骤--- 21
83) 说出数据连接池的工作机制是什么？--- 21
84) JDO是什么?- 21
85) 动态查询如何实现？表的结构变化后，如果不需要修改程序，如何设计和实现查询？--- 21
86) 如何优化数据库，如何提高数据库的性能？--- 21
87) 设计数据库应注意那些问题--- 22
88) 表与表之间的关联关系--- 22
89) 主键和外键的区别--- 22
90) 名词解释：批、触发器、事务、锁、子查询、索引、视图、存储过程--- 22
91) 游标的作用？如何知道游标已经到了最后？--- 23
92) 事前触发和事后触发有何区别？语句级触发和行级触发有何区别？--- 23
93) 数据库设计的必要性及设计步骤--- 24
94) 什么是数据模型？什么是规范化？--- 24
95) 谈谈数据库设计的三范式--- 24
七、 JSP和Servlet 25
96) forward 和sendRedirect的区别--- 25
97) JSP中动态INCLUDE与静态INCLUDE的区别--- 25
98) JSP的内置对象及方法--- 25
99) JSP的常用指令--- 25
100) 说出Servlet的生命周期，并说出Servlet和CGI的区别--- 26
101) 什么情况下调用doGet()和doPost() 26
102) 如何现实servlet的单线程模式--- 26
103) 描述Cookie和Session的作用，区别和各自的应用范围，Session工作原理--- 26
104) 页面间对象传递的方法--- 27
105) JSP和Servlet有哪些相同点和不同点，他们之间的联系--- 27
106) 四种会话跟踪技术--- 27
107) Request对象的主要方法--- 27
108) Servlet执行时一般实现哪几个方法--- 28
109) 说出在JSP页面里是怎么分页的?- 28
八、 J2EE基础--- 29
110) J2EE是什么？--- 29
111) J2EE中常用的名词解释--- 29
112) 名词解释：WEB SERVICE、JAXP、JAXM、SOAP、UDDI、WSDL- 30
113) J2EE是技术还是平台还是框架？--- 30
114) XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？--- 30
115) 你在项目中用到了xml技术的哪些方面?如何实现的?- 31
116) j2ee常用的设计模式？说明工厂模式--- 31
九、 STRUTS- 32
117) MVC的各个部分都有那些技术来实现?如何实现?- 32
118) 概述struts，以及struts如何实现MVC架构的？--- 32
119) 简单描述STRUTS的主要功能--- 32
120) Struts的处理流程--- 32
十、 EJB- 34
121) EJB2.0有哪些内容?分别用在什么场合? EJB2.0和EJB1.1的区别?- 34
122) EJB与JAVA BEAN的区别？--- 34
123) EJB是基于哪些技术实现的？并说出SessionBean和EntityBean，StatefulBean和StatelessBean的区别 34
124) EJB包括SessionBean和EntityBean，说出他们的生命周期，及如何管理事务的？--- 35
125) EJB的角色和三个对象--- 35
126) EJB容器提供的服务--- 35
127) EJB规范规定EJB中禁止的操作有哪些？--- 35
128) remote接口和home接口主要作用--- 36
129) bean 实例的生命周期--- 36
130) EJB的激活机制--- 36
131) EJB的几种类型--- 36
132) 客服端调用EJB对象的几个基本步骤--- 36
133) EJB需直接实现它的业务接口或Home接口吗，请简述理由--- 36
十一、 应用服务器--- 37
134) 应用服务器有那些？--- 37
135) 应用服务器与WEB 服务器的区别？--- 37
136) 如何给weblogic指定大小的内存?- 37
137) 如何设定的weblogic的热启动模式(开发模式)与产品发布模式?- 37
138) 如何启动时不需输入用户名与密码?- 37
139) 在weblogic管理制台中对一个应用域进行jms及ejb或连接池等相关信息进行配置后,实际保存在什么文件中? 37
140) 说说weblogic中一个Domain的缺省目录结构--- 37
141) 在weblogic中发布ejb需涉及到哪些配置文件--- 37
142) 如何在weblogic中进行ssl配置与客户端的认证配置或说说j2ee(标准)进行ssl的配置--- 38
143) 如何查看在weblogic中已经发布的EJB?- 38
l 改错题--- 39
1) 39
2) 39
3) 39
4) 39
5) 40
6) 40
7) 40
8) 41
9) 41
10) 41
11) 42
l 编程题--- 44
1) 在控制台中输入一个字符串，然后按照逆序打印出来--- 44
2) 设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。--- 44
3) 将一个键盘输入的数字转化成中文输出(例如：输入1234567，输出:一百二拾三万四千五百六拾七),请用java语言编一段程序实现! 45
4) 写一个Singleton出来--- 49
5) 我们在web应用开发过程中经常遇到输出某种编码的字符，如iso8859-1等，如何输出一个某种编码的字符串 50
6) 现在输入n个数字，以逗号，分开；然后可选择升或者降序排序；按提交键就在另一页面显示按什么排序，结果为，提供reset 51
7) 继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么?- 52
8) 同上，关于内部类的实现方式--- 52
9) 关于内部类实现的一道选择题--- 53
10) 用JAVA实现一种排序--- 54
11) 编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。 55
12) 用JAVA SOCKET编程，读服务器几个字符，再写入本地显示--- 56
13) 写一段Jdbc连Oracle的程序,并实现数据查询. 58
14) ORACLE大数据量下的分页解决方法。一般用截取ID方法，还有是三层嵌套方法。--- 60
15) 用JAVA解析XML的方式. 61
16) 用jdom解析xml文件时如何解决中文问题?如何解析?- 63
l 其它--- 65
1) 描述一下你最常用的编程风格。--- 65
概念题
一、 JAVA基础
1) 面向对象的特征
1. 抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象包括两个方面，一是过程抽象，二是数据抽象。
2.继承：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
3.封装：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
4.多态：
多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。
2) 什么是OOP？什么是类？请对比类和对象实例之间的关系。
OOP是Object_oriented Programming(面向对象编程)的缩写。这主要是为了区别于以前的面向过程的程序设计！指的是用对象的观点来组织与构建系统，它综合了功能抽象和数据抽象，这样可以减少数据之间的耦合性和代码的出错几率。使用面向对象编程技术可以使得软件开发者按照现实世界里人们思考问题的模式编写代码,可以让软件开发者更好地利用代码直接表达现实中存在的对象,将问题空间直接映射到解空间!
类：即class 在面向对象的程序设计中，专门用“类”来表示用户定义的抽象数据类型（user_defined abstract type）。它将具有相同状态、操作和访问机制的多个对象进行了抽象。类具有继承、数据隐藏和多态三种主要特性。利用类的这三种特性可以更好地表示现实世界中事物。类是同一类对象实例的共性的抽象，对象是类的实例化。对象通常作为计算机模拟思维，表示真实世界的抽象，一个对象就像一个软件模块，可以为用户提供一系列的服务---可以改变对象的状态、测试、传递消息等。类定义了对象的实现细节或数据结构。类是静态的，对象是动态的，对象可以看作是运行中的类。类负责产生对象，可以将类当成生产对象的工厂（Object factory）
3) 简述类与对象的概念
所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。
类是具备某些共同特征的实体的集合，它是一种抽象的概念，用程序设计的语言来说，类是一种抽象的数据类型，它是对所具有相同特征实体的抽象。
4) 什么是属性与方法？
不同对象具有相同特点，就可能抽象为一定的类，那么这些特点基本上可以分为两类，一类是描述对象静态状态的，就是对象的属性，在程序设计中，可以称之为变量；另一类是描述对象的动作，就是对象的方法，在程序设计中我们称之为函数。属性和方法是一个对象所具备的两大基本要素，也是我们后面编程工作的核心。
5) 什么是封装？
只要有足够的方法，就没必要直接去操作对象属性，只要调用这些方法就可以实现要完成的任务，这种现象称为封装，它通过对象方法对其属性的操作把对象属性封装在一个对象内部，对象与外界打交道全部通过其自身的方法来实现，有效的把对象属性隐藏在对象内部。
6) 描述一下JVM加载class文件的原理机制
JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。
7) Java程序怎么优化？
答：提高JAVA的性能，一般考虑如下的四个主要方面：
1、程序设计的方法和模式
2、JAVA布署的环境。
3、JAVA应用程序的实现
4、硬件和操作系统
为了提高JAVA程序的性能，需要遵循如下的六个步骤。 a) 明确对性能的具体要求 b) 了解当前程序的性能 c) 找到程序的性能瓶颈 d) 采取适当的措施来提高性能 e) 只进行某一方面的修改来提高性能 f) 返回到步骤c) 继续作类似的工作，一直达到要求的性能为止。
8) 一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
可以。必须只有一个类名与文件名相同。
9) char型变量中能不能存贮一个中文汉字
能够定义成为一个中文的，因为java中以unicode编码，一个char占16个字节，所以放一个中文是没问题的
1)
2)
3)
4)
5)
6)
7)
8)
9)
10) 逻辑操作符 (&,|,^)与条件操作符(&&,||)的区别
1. 条件操作符：
只能用于关系运算，会产生短路，即该符号左边的表达式可以确定整个关系表达式的值时，便不再运算右边的表达式
2. 逻辑操作符：
不仅可以用于关系运算,还可以用于位运算。不会产生短路，即无论左边表达式取什么值都要运算右边的表达式
11) Math.round(11.5)等於多少? Math.round(-11.5)等於多少？
Math.round(11.5)等于12；Math.round(-11.5)等于-11。
1)
2)
3)
4)
5)
6)
7)
8)
9)
10)
11)
12) Java有没有goto？
Java中的保留字，现在没有在Java中使用。
13) int 和 Integer 的区别
Java 提供两种不同的类型：引用类型和原始类型(基本数据类型)。int是java的原始类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类：
Boolean-Boolean char-Character byte-Byte short-Short
int-Integer long-Long float-Float double-Double
引用类型和原始类型具有不同的特征和方法，它们包括：大小和速度问题，这种类型以哪种类型的数据结构存储等。当引用类型和原始类型用作某个类的实例数据时所指定的缺省值不同：对象引用实例变量的缺省值为 null，而原始类型实例变量的缺省值与它们的类型有关。
14) 如何将数值型字符转换为数字？如何去小数四舍五入保留小数点后两位。
1、Integer.parseInt(“111”);Double.parseDouble(“11.22”);
2、double num = 2.625; double tmp = Math.round(num * 100) / 100d;
15) short s1 = 1; s1 = s1 + 1;和short s1 = 1; s1 += 1;有什么错误
short s1 = 1; s1 = s1 + 1;有错，数据库类型不匹配
short s1 = 1; s1 += 1;没有错误
16) float f=3.4是否正确?
不正确。精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4或者 float f = 3.4f;
17) String 和StringBuffer的区别
String类提供了数值不可改变的字符串，而StringBuffer类提供的字符串可以进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用 StringBuffer来动态构造字符数据。
18) String是否是最基本的数据类型，能否被继承
不是。基本数据类型包括byte、short、int、long、char、float、double和boolean。String类是final类型的，因此不可以继承这个类、不能修改这个类。
19) String s = new String("xyz");创建了几个String Object？
创建了两个String Object对象
"xyz"本身作为字符常量，在汇编语言中应该作为常量放在数据段，Java有一个类似数据段的constant pool保存这个常量，在classloader加载这个类的时候就把"xyz"和这个类的其他一些信息放在constant pool。new String("xyz")根据常量"xyz"在heap上创建String对象。所以，一共两个对象
20) 数组有没有length()这个方法? String有没有length()这个方法？
数组没有length()这个方法，有length的属性。String有length()这个方法。
21) 排序都有哪几种方法？用JAVA实现一个快速排序
排序的方法有：插入排序（直接插入排序、希尔排序），交换排序（冒泡排序、快速排序），选择排序（直接选择排序、堆排序），归并排序，分配排序（箱排序、基数排序）
快速排序的伪代码。
/ /使用快速排序方法对a[ 0 :n- 1 ]排序
从a[ 0 :n- 1 ]中选择一个元素作为m i d d l e，该元素为支点
把余下的元素分割为两段left 和r i g h t，使得l e f t中的元素都小于等于支点，而right 中的元素都大于等于支点
递归地使用快速排序方法对left 进行排序
递归地使用快速排序方法对right 进行排序
所得结果为l e f t + m i d d l e + r i g h t
22) swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上
switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。Long，string 都不能作用于swtich。
23) 在JAVA中，如何跳出当前的多重嵌套循环？
用break; return 方法。
24) 关于日期和时间的几个问题
1、如何取得年、月、日，小时、分、秒：
Date dat=new Date();dat.getYear();dat.getMonth();dat.getDay();dat.getHours();...
2、如何取得从1970年到现在的毫秒数：
long now=dat.getTime();
3、如何格式化日期
DateFormate df=DateFormate.getInstance();df.Format(dat);
25) 一个对象被当作参数传递到一个方法，是值传递还是引用传递
是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。
26) 什么时候用assert？
assertion (断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个 boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。
27) GC是什么? 为什么要有GC？
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。
28) 垃圾回收的优点和原理
垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。
29) 垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？
对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。
30) java中会存在内存泄漏吗，请简单描述
会。如：int i,i2; return (i-i2); //when i为足够大的正数,i2为足够大的负数。结果会造成溢位，导致错误。
Java的一个重要优点就是通过垃圾收集器(Garbage Collection，GC)自动管理内存的回收，程序员不需要通过调用函数来释放内存。因此，很多程序员认为Java不存在内存泄漏问题，或者认为即使有内存泄漏也不是程序的责任，而是GC或JVM的问题。其实，这种想法是不正确的，因为Java也存在内存泄露，但它的表现与C++不同。
31) java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，他们分别是哪些类？
字节流，字符流。字节流继承于InputStream、 OutputStream，字符流继承于InputStreamReader 、OutputStreamWriter。
32) 文件和目录（I/O）操作
1、如何列出某个目录下的所有文件，如何列出某个目录下的所有子目录：
public void listFile(String rp) {
File file=new File(rp);
File list[]=file.listFiles();
for(int i=0;i
new ListFiles().listFile(list[i].toString());
}
else {
listFileStr+=list[i].getAbsolutePath()+"\r\n";
System.out.println(list[i].getAbsolutePath());
}
}
2、判断一个文件或目录是否存在：
File file=new File(“c:\aa.txt”);if(file.exists()){System.out.print(“存在”)};
3、如何读写文件
读：BufferdReader br = new BufferdReader(new FileReader(“c:\aa.txt”));br.readLine();
写：BufferdWriter bw = new BufferdWriter (new FileWriter(“c:\aa.txt”));bw.write(“Hello”);
33) 什么是java序列化？如何实现java序列化？
序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。
34) JAVA事件委托机制的概念
java 事件委托机制的概念：一个源产生一个事件并将它送到一个或多个监听器那里。在这种方案中，监听器简单的等待，直到它收到一个事件。一旦事件被接受，监听器将处理这个事件，然后返回。
35) 谈谈你对Swing的MVC模式的理解？
Swing号称是完全按照MVC的思路来进行设计的。在设计开始前，Swing的希望能够达到的目标就包括：
模型驱动（Model-Driven）的编程方式。提供一套单一的API，但是能够支持多种视感（look-and-feel），为用户提供不同的界面。严格的说，Swing中的MVC实际上是MVC的一个变体：M-VC。 Swing中只显示的定义了Model接口，而在一个UI对象中集成了视图和控制器的部分机制。View和Control比较松散的交叉组合在一起，而更多的控制逻辑是在事件监听者部分引入的。但是，这并没有妨碍在Swing中体现MVC的精髓。事实上，在Swing的开发初期，Swing确实是按照标准的MVC模式来设计的，但是很快的问题就出现了：View和Controller实际上是紧密耦合的，很难作出一个能够适应不同View的一般化的Controller来，而且，一般也没有很大的必要。
36) MVC结构在JTable中怎样实现的，这种结构有什么好处？
在JTable中不存储它的单元数据，它的所有实例把它们的单元值交给实现了TableModel接口的对象来维护和管理，所以在MVC结构中，Jtable的表格主要体现了一个V的作用，其表格将数据变化体现出来，而数据模型则体现了M的作用，封装数据和业务逻辑。
在这种MVC结构中，表示层和逻辑层分离，各部分可相互独立进行开发，便于开发和维护，提高了开发效率。
二、 类与继承
37) 说出一些常用的类，包，接口，请各举5个
常用的类：String，BufferedReader，Integer，ArrayList，Vector
常用的包：java.lang ，java.awt ，java.io ，java.util ，java.sql
常用的接口：Collection，List，Map，Serializable，Runnable
38) 接口有什么优点？
答：接口有以下优点：
1、接口只是一个框架而没有实现，因此在接口定义时不需要考虑接口中的方法如何实现。
2、利用接口可达到实现多继承的目地。
3、可以在不暴露对象的类的前提下，暴露对象的编程接口。
4、不用强迫类关系在无关类中截获相似处(采用适配器就可以了)。
5、声明想执行的一个或多个方法。
39) 静态变量和实例变量的区别
静态变量也称作类变量，由static修饰，如：static int ss; ss就是静态变量，它只能通过类来访问。
实例变量没有static修饰符，它只能通过实例对象来访问。
同一类的不同的实例对象有自己的实例变量，但是它们共享同一个静态变量。当一个实例对象修改了它的实例变量时，不会影响其他的实例对象。如果一个实例对象修改了静态变量，则会影响其他的对象实例。
40) 是否可以从一个static方法内部发出对非static方法的调用？
不可以,如果其中包含对象的method()，不能保证对象初始化.
41) java 有几种修饰符？分别用来修饰什么？
答：(注：修饰符是影响类、变量及成员方法的生存空间和可访问性的关键字)
修饰符 类 成员方法 成员变量 局部变量
abstract √ √ － －
static － √ √ －
public √ √ √ －
protected － √ √ －
private － √ √ －
private － √ √ －
protected － √ √ －
synchronized － √ － －
native － √ － －
volatile － － √ －
final √ √ √ －
transient － － √ √
42) 作用域public,private,protected,以及不写时的区别
区别如下：
作用域 当前类 同包 子孙类 不同包
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不写时默认为friendly
43) final, finally, finalize的区别
1.final ：
用于声明属性，方法和类，分别表示属性不可变（为常量），方法不可覆盖（不可重写），类不可继承。
2.finally：
是异常处理语句结构的一部分，表示总是执行。
3.finalize：
是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。
44) 内部类可以引用他包含类的成员吗？有没有什么限制？
根据内部类是否为static分为两种讨论：
1.静态内部类可以有静态和非静态的成员，但它们只能访问包含类的静态成员
2.非静态内部类不能有静态成员，它可以访问包含类的任何成员，无论它们有什么访问属性。它还可以访问包含类下任何静态内部类的静态成员
45) 匿名内部类是否可以继承其它类？是否可以实现接口？
可以继承其他类，也可以实现接口。
46) java中实现多态的机制是什么？
方法的重写Overriding和重载Overloading是Java多态性的不同表现。
47) Overload和Override的区别，Overloaded的方法能否改变返回值的类型？
方法的重写Overriding和重载Overloading是Java多态性的不同表现。
重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。
如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。
48) abstract class和interface的区别
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。
接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。
49) 接口是否可继承接口? 抽象类是否可实现接口? 抽象类是否可继承实体类?
接口可以继承接口。抽象类可以实现接口，抽象类可继承实体类，但前提是实体类必须有明确的构造函数。
50) abstract的method是否可同时是static或native或synchronized？
都不能
51) 构造器Constructor是否可被override
构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。
52) 写clone()方法时，通常都有一行代码，是什么？
Clone 有缺省行为，super.clone();他负责产生正确大小的空间，并逐位复制。
53) Object类的概述
Object类是所有其他的类的超类，Object的一个变量可以引用任何其他类的对象。因为数组是作为类实现的，所以Object的一个变量也可以引用任何数组，它包括以下几种方法：
clone() equals() finalize() getClass() hashCode() notify() notifyAll() toString() wait()
三、 异常
1)
2)
3)
4)
5)
6)
7)
8)
9)
10)
11)
12)
13)
14)
15)
16)
17)
18)
19)
20)
21)
22)
23)
24)
25)
26)
27)
28)
29)
30)
31)
32)
33)
34)
35)
36)
37)
38)
39)
40)
41)
42)
43)
44)
45)
46)
47)
48)
49)
50)
51)
52)
53)
54) Java中的异常处理机制的简单原理和应用。
当JAVA 程序违反了JAVA的语义规则时，JAVA虚拟机就会将发生的错误表示为一个异常。违反语义规则包括2种情况。一种是JAVA类库内置的语义检查。例如数组下标越界,会引发IndexOutOfBoundsException;访问null的对象时会引发NullPointerException。另一种情况就是JAVA允许程序员扩展这种语义检查，程序员可以创建自己的异常，并自由选择在何时用throw关键字引发异常。所有的异常都是 java.lang.Thowable的子类。
55) JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？
Java 通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。
用try来指定一块预防所有"异常"的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的"异常"的类型。
throw语句用来明确地抛出一个"异常"。
throws用来标明一个成员函数可能抛出的各种"异常"。
finally为确保一段代码不管发生什么"异常"都被执行一段代码。
可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，"异常"的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种"异常"进行处理，堆栈就会展开，直到遇到有处理这种"异常"的try语句。
56) error和exception的区别
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。一般要求程序对其进行捕获及处理。
57) 运行时异常与一般异常的区别
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
58) 给我一个你最常见到的runtime exception(运行时异常)
ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, ConcurrentModificationException, DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException, ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException
59) try 里有一个return语句，那finally 里的代码会不会被执行？在return前还是后执行？
会执行，在return前执行。
四、 集合
60) 集合类都有哪些
最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。
61) 介绍JAVA中的Collection FrameWork
答：Collection FrameWork如下：
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）
Map提供key到value的映射
62) ArrayList和Vector的区别
答：就ArrayList与Vector主要从二方面来说：
1、同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
2、数据增长:当需要增长时,Vector默认增长为原来一倍，而ArrayList却是原来的一半
63) HashMap和Hashtable的区别
HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值 （key）,由于非线程安全，效率上可能高于Hashtable。具体区别如下：
1、HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
2、HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。
3、Hashtable继承自Dictionary类，而HashMap是 Map接口的一个实现。
4、最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现 同步，而HashMap 就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异
64) Collection 和 Collections的区别
Collection是集合类的上级接口，继承与他的接口主要有Set 和List.
Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
65) 说出ArrayList,Vector, LinkedList的存储性能和特性
ArrayList 和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢
LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差
66) heap和stack的区别
栈是一种线形集合，其添加和删除元素的操作应在同一段完成。栈按照后进先出的方式进行处理。
堆是栈的一个组成元素
67) List, Set, Map是否继承自Collection接口？
由Collection接口派生的两个接口是List和Set。
List和Set的区别：List必须保持元素特定的顺序，而Set不能有重复元素。
Map不是继承自Collection接口
68) List, Set, Map三个接口，存取元素时，各有什么特点？
List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map保存key-value值，value可多值。
69) Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别？
Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。
==方法判断引用值是否指向同一对象，equals()是当两个分离的对象的内容和类型相配的话，返回真值。
70) 两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对
不对，有相同的hash code。
五、 多线程
一、
二、
三、
71) 启动一个线程是用run()还是start()？
启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。
1
2
3
4
5
6
7
8
9
10
72) sleep() 和 wait() 的区别
sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。
wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。
73) stop()和suspend()方法为何不推荐使用？
反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。
suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用 wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。
74) 同步和异步有何异同，在什么情况下分别使用他们
同步可以这样理解：使用同一个类产生的多个线程对象，可以同时分别执行对象中的方法，这在同时存取相同的资源时可能产生错误。当类在的方法设为synchronized时，在同一时刻只能有一个线程对象执行这个方法，其它想要执行这个方法的线程，必须等到它空闲时才能开始执行。
如果数据将在线程间共享，例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
75) 当一线程进入一对象的一个synchronized方法后，其它线程可否进入此对象的其它方法
此对象的synchronized方法不能进入了，但它的其他方法还是可以访问的。
76) 线程同步的方法
1.在类或者方法前加上synchronized前缀，一个synchronized对象或者一个synchronized方法只能由一个线程访问。
2.使用sleep()静态方法，使一个正在运行的线程处于睡眠状态，调用此方法要捕捉InterruptedException异常。
3.使用wait和notify方法
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
allnotify():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
77) 多线程有几种实现方法
多线程主要有两种实现方法，分别是继承Thread类、实现Runnable接口。还可以使用Timer类产生一个定时线程。
78) 线程的基本概念、线程的基本状态以及状态之间的关系
线程指在程序执行过程中，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，也就是程序本身。
Java中的线程有四种状态分别是：新建（New）、运行（Runnable）、挂起（NotRunnable）、结束（Dead）。
刚被实例化的线程对象处于New的状态，调用start方法后变为Runnable状态，通过sleep、wait、suspend方法或者I/O阻塞后变为NotRunnable，该状态若sleep结束或I/O操作结束，或者调用notify、resume方法后变回Runnable状态。若调用stop方法或者run方法退出，线程结束(Dead)
79) 简述synchronized和java.util.concurrent.locks.Lock的异同
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。
80) 多线程的优点
可分两方面来答：
1、相对于单线程而言 ：
可以响应多任务的并发操作。
多线程取消了主循环和轮流检测机制，一个线程可以暂停而不阻止系统其他的部分的执行，而且当程序中一个线程阻塞时，只有那个被阻塞的线程暂停，所有其他的线程继续执行。
2、相对于进程而言：(可以答也可以不答)
它所要求的开销比较小，转换成本较小。
所有线程共享同一地址空间，相互协作。
彼此之间通信很容易。
六、 JDBC及数据库相关
81) Class.forName的作用?为什么要用?
调用该方法返回一个以字符串指定类名的类的对象。在用JDBC连接时调用这个方法能够保证程序需要的JDBC驱动程序已经装入，从而保证在程序代码使用驱动程序之前已经完成了对该JDBC驱动程序的所有初始化。
82) JDBC调用数据库的基本步骤
导入必要的类，装入JDBC驱动程序，识别数据源，分配一个Connection对象，分配一个Statement对象，使用Statement执行一个查询，从返回的ResultSet对象中检索数据，关闭ResultSet，关闭Statement对象，关闭 Connection对象
83) 说出数据连接池的工作机制是什么？
J2EE 服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。
84) JDO是什么?
JDO 是Java对象持久化的新的规范，为java data object的简称,也是一个用于存取某种数据仓库中的对象的标准化API。JDO提供了透明的对象存储，因此对开发人员来说，存储数据对象完全不需要额外的代码（如JDBC API的使用）。这些繁琐的例行工作已经转移到JDO产品提供商身上，使开发人员解脱出来，从而集中时间和精力在业务逻辑上。另外，JDO很灵活，因为它可以在任何数据底层上运行。JDBC只是面向关系数据库（RDBMS）JDO更通用，提供到任何数据底层的存储功能，比如关系数据库、文件、XML以及对象数据库（ODBMS）等等，使得应用可移植性更强。
85) 动态查询如何实现？表的结构变化后，如果不需要修改程序，如何设计和实现查询？
将查询封装进存储过程中，通过调用存储过程实现动态调用；表结构发生变化后修改相应的存储过程即可再不修改程序的情况下实现查询。
86) 如何优化数据库，如何提高数据库的性能？
1.给数据库做索引，合理的索引能立即显著地提高数据库整个系统的性能。
2.在适当的情况下，尽可能的用存储过程而不是SQL查询。因为前者已经过了预编译，运行速度更快。
3.优化查询语句，通过高性能的查询语句提高数据库的性能。
87) 设计数据库应注意那些问题
首先应尽量满足三范式的要求，在一定程度上打破三范式的要求以提高数据库的性能。
88) 表与表之间的关联关系
分为3种：一对一、一对多、多对多。
89) 主键和外键的区别
主键在本表中是唯一的、不可为空的，外键可以重复可以唯空；外键和另一张表的主键关联，不能创建对应表中不存在的外键。
90) 名词解释：批、触发器、事务、锁、子查询、索引、视图、存储过程
1、批：
批是包含一个或多个 Transact-SQL 语句的组，从应用程序一次性地发送到 Microsoft SQL Server 执行。批作为一个整体执行，以GO命令结束。批处理是客户端作为一个单元发出的一个或多个 SQL 语句的集合。每个批处理编译为一个执行计划。
2、触发器：
触发器是在对表进行插入、更新或删除操作时自动执行的存储过程，触发器通常用于强制业务规则。触发器可以确保数据的完整性和一致性
3、事务：
事务是作为一个逻辑单元执行的一系列操作，一个逻辑工作单元必须有四个属性，称为 ACID（原子性、一致性、隔离性和持久性）属性，只有这样才能成为一个事务：原子性，事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。一致性，事务在完成时，必须使所有的数据都保持一致状态。在相关数据库中，所有规则都必须应用于事务的修改，以保持所有数据的完整性。事务结束时，所有的内部数据结构（如 B 树索引或双向链表）都必须是正确的。隔离性，由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。事务查看数据时数据所处的状态，要么是另一并发事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看中间状态的数据。这称为可串行性，因为它能够重新装载起始数据，并且重播一系列事务，以使数据结束时的状态与原始事务执行的状态相同。持久性，事务完成之后，它对于系统的影响是永久性的。该修改即使出现系统故障也将一直保持。
4、锁：
锁是在多用户环境中对数据访问的限制封锁就是事务 T 在对某个数据对象（如表、记录等）操作之前，先向系统发出请求，对其加锁。加锁后事务 T 就对该数据对象有了一定的控制，在事务T释放它的锁之前，其它的事务不能更新此数据对象。（锁蕴含的基本概念是用户需要对表的排它访问）。从程序员的角度看分为乐观锁和悲观锁。
乐观锁：完全依靠数据库来管理锁的工作。
悲观锁：程序员自己管理数据或对象上的锁处理。
5、子查询：一个 selecｔ 语句嵌套在另一个 selecｔ 语句中。
6、索引：
索引是一个数据库对象，它是某个表中一列或若干列值的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单,然后根据指定的排序次序排列这些指针，优点提高查询执行的速度。强制实施数据的唯一性。提高表之间联接的速度。 缺点存储索引要占用磁盘空间。数据修改需要更长的时间，因为索引也要更新。
7、视图：
视图是一种虚拟表，通常是作为来自一个或多个表的行或列的子集创建的。视图本质上讲，就是保存在数据库中的select查询。视图并不是数据库中存储的数据值的集合。
对最终用户的好处：结果更容易理解， 获得数据更容易
对开发人员的好处：限制数据检索更容易，维护应用程序更方便
8、存储过程：
使用一个名称存储的预编译T-SQL语句和流程控制语句的集合。由数据库开发人员或数据库管理员编写，用来执行管理任务或应用复杂的业务规则
优点：执行速度更快。首次运行时，进行优化和编译得到执行计划并将该计划存储在系统表中，以后直接运行。实现多个程序共享应用程序逻辑，组件式编程，能够屏蔽数据库的结构，实现更高的安全性，减少网络流通量
91) 游标的作用？如何知道游标已经到了最后？
游标用于定位结果集的行，通过判断全局变量@@FETCH_STATUS可以判断是否到了最后，通常此变量不等于0表示出错或到了最后。
92) 事前触发和事后触发有何区别？语句级触发和行级触发有何区别？
事前触发器运行于触发事件发生之前，而事后触发器运行于触发事件发生之后。通常事前触发器可以获取事件之前和新的字段值。语句级触发器可以在语句执行前或后执行，而行级触发在触发器所影响的每一行触发一次。
93) 数据库设计的必要性及设计步骤
好的数据库结构有利于：节省数据的存储空间，能够保证数据的完整性，方便进行数据库应用系统的开发
设计不好的数据库结构将导致：数据冗余、存储空间浪费和内存空间浪费
不管数据库的大小和复杂程度如何，可以用下列基本步骤来设计数据库：收集信息--标识对象--设计数据模型--标识每个对象--存储的信息类型–标识对象之间的关系
94) 什么是数据模型？什么是规范化？
数据模型是一种标识实体类型及其实体间联系的模型。典型的数据模型有网状模型、层次模型和关系模型。
从关系数据库的表中，除去冗余数据的过程称为规范化。包括：精简数据库的结构，从表中删除冗余的列，标识所有依赖于其它数据的数据
95) 谈谈数据库设计的三范式
第一范式的定义：如果一个表中没有重复组（即行与列的交叉点上只有一个值，而不是一组值），则这个表属于第一范式（常记成1NF）。简而言之："每一字段只存储一个值"。例如:职工号，姓名，电话号码组成一个表（一个人可能有一个办公室电话 和一个家里电话号码）
第二范式的定义：如果一个表属于1NF，任何属性只依赖于关键字，则这个表属于第二范式（常记成2NF ）。简而言之：必须先符合1NF的条件，且每一行都能被唯一的识别。将1NF转换成2NF的方法是添加主键。例如：学号，姓名，课程名，成绩
第三范式的定义：如果一个表属于2NF，且不包含传递依赖性，则这个表是第三范式（常记成 3NF）。满足3NF的表中不包含传递依赖。简而言之：没有一个非关键属性依赖于另一个非关键属性。例如：表一：学号，课程号，成绩。 表二：学号，姓名，所在系，系名称，系地址。表三：课程号，课程名，学分
七、 JSP和Servlet
96) forward 和sendRedirect的区别
前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；后者则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。所以，前者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接。在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。
97) JSP中动态INCLUDE与静态INCLUDE的区别
动态INCLUDE用jsp:include动作实现 它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。
静态INCLUDE用include指令实现,不会检查所含文件的动态内容，适用于包含静态页面
98) JSP的内置对象及方法
1.request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。
2.response表示HttpServletResponse对象，并提供了几个用于设置送回浏览器的响应的方法（如cookies,头信息等）
3.out对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。
4.pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。
5.session表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息
6.applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息
7.config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。
8.page表示从该页面产生的一个servlet实例
9.exception 针对错误网页，未捕捉的例外
99) JSP的常用指令
1.Jsp指令:负责告诉jsp引擎如何把页面翻译成servlet。语法:<%@ 指令名 属性="值"%>
page指令:用于定义jsp页面的各种属性,最好放在jsp页面的起始位置
include指令: 静态包含，不会检查所含文件的变化，适用于包含静态页面
2.Jsp动作指令:
100) 说出Servlet的生命周期，并说出Servlet和CGI的区别
Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。
与CGI的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。
101) 什么情况下调用doGet()和doPost()
Jsp页面中的form标签里的method属性为get时调用doGet()，为post时调用doPost()。
102) 如何现实servlet的单线程模式
基于线程的servlet本身就是多线程的，只能让线程安全，却没办法实现servlet的单线程。
在jsp页面用<%@ page isThreadSafe=”false”%>可以让该页面线程安全
103) 描述Cookie和Session的作用，区别和各自的应用范围，Session工作原理
Cookie是一种发送到客户浏览器的文本串句柄，并保存在客户机硬盘上，可以用来在某个Web站点会话之间持久地保持数据。
Session代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常会跨越多个客户机请求
session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。当程序需要为某个客户端的请求创建一个session的时候，服务器首先检查这个客户端的请求里是否已包含了一个session标识 - 称为session id，如果已包含一个session id则说明以前已经为此客户端创建过session，服务器就按照session id把这个session检索出来使用（如果检索不到，可能会新建一个），如果客户端请求不包含session id，则为此客户端创建一个session并且生成一个与此session相关联的session id，session id的值应该是一个既不会重复，又不容易被找到规律以仿造的字符串，这个session id将被在本次响应中返回给客户端保存。 保存这个session id的方式可以采用cookie，这样在交互过程中浏览器可以自动的按照规则把这个标识发挥给服务器。一般这个cookie的名字都是类似于SEEESIONID。
104) 页面间对象传递的方法
request，session，application，cookie等
page的生命周期最短,依次是request，session，application.他们保存在服务器端.
cookie是保存在客户端的,用来解决HTTP无状态问题.
105) JSP和Servlet有哪些相同点和不同点，他们之间的联系
JSP 是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。
106) 四种会话跟踪技术
page：代表与一个页面相关的对象和属性。一个页面由一个编译好的 Java servlet 类（可以带有任何的 include 指令，但是没有 include 动作）表示。这既包括 servlet 又包括被编译成 servlet 的 JSP 页面
request：代表与 Web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件（由于 forward 指令和 include 动作的关系）
session：代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常会跨越多个客户机请求
application：代表与整个 Web 应用程序相关的对象和属性。这实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域
107) Request对象的主要方法
setAttribute(String name,Object)：设置名字为name的request的参数值
getAttribute(String name)：返回由name指定的属性值
getAttributeNames()：返回request对象所有属性的名字集合，结果是一个枚举的实例
getCookies()：返回客户端的所有Cookie对象，结果是一个Cookie数组
getCharacterEncoding()：返回请求中的字符编码方式
getContentLength()：返回请求的Body的长度
getHeader(String name)：获得HTTP协议定义的文件头信息
getHeaders(String name)：返回指定名字的request Header的所有值，结果是一个枚举的实例
getHeaderNames()：返回所以request Header的名字，结果是一个枚举的实例
getInputStream()：返回请求的输入流，用于获得请求中的数据
getMethod()：获得客户端向服务器端传送数据的方法
getParameter(String name)：获得客户端传送给服务器端的有name指定的参数值
getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举的实例
getParameterValues(String name)：获得有name指定的参数的所有值
getProtocol()：获取客户端向服务器端传送数据所依据的协议名称
getQueryString()：获得查询字符串
getRequestURI()：获取发出请求字符串的客户端地址
getRemoteAddr()：获取客户端的IP地址
getRemoteHost()：获取客户端的名字
getSession([Boolean create])：返回和请求相关Session
getServerName()：获取服务器的名字
getServletPath()：获取客户端所请求的脚本文件的路径
getServerPort()：获取服务器的端口号
removeAttribute(String name)：删除请求中的一个属性
108) Servlet执行时一般实现哪几个方法
public void init(ServletConfig config)
public ServletConfig getServletConfig()
public String getServletInfo()
public void service(ServletRequest request,ServletResponse response)
public void destroy()
109) 说出在JSP页面里是怎么分页的?
页面需要保存以下参数：
总行数：根据sql语句得到总行数
每页显示行数：设定值
当前页数：请求参数
页面根据当前页数和每页行数计算出当前页第一行行数，定位结果集到此行，对结果集取出每页显示行数的行即可。
八、 J2EE基础
110) J2EE是什么？
J2EE 是Sun公司提出的多层(multi-diered),分布式(distributed),基于组件(component-base)的企业级应用模型 (enterpriese application model).在这样的一个应用系统中，可按照功能划分为不同的组件，这些组件又可在不同计算机上，并且处于相应的层次(tier)中。所属层次包括客户层(clietn tier)组件,web层和组件,Business层和组件,企业信息系统(EIS)层。
111) J2EE中常用的名词解释
1.web 容器：
给处于其中的应用程序组件（JSP，SERVLET）提供一个环境，使JSP,SERVLET直接更容器中的环境变量接口交互，不必关注其它系统问题。主要有WEB服务器来实现。例如：TOMCAT,WEBLOGIC,WEBSPHERE等。该容器提供的接口严格遵守J2EE规范中的WEB APPLICATION 标准。我们把遵守以上标准的WEB服务器就叫做J2EE中的WEB容器。
2.EJB容器：
Enterprise java bean 容器。更具有行业领域特色。他提供给运行在其中的组件EJB各种管理功能。只要满足J2EE规范的EJB放入该容器，马上就会被容器进行高效率的管理。并且可以通过现成的接口来获得系统级别的服务。例如邮件服务、事务管理。
3.JNDI：（Java Naming & Directory Interface）
JAVA命名目录服务。主要提供的功能是：提供一个目录系统，让其它各地的应用程序在其上面留下自己的索引，从而满足快速查找和定位分布式应用程序的功能。
4.JMS：（Java Message Service）
JAVA消息服务。主要实现各个应用程序之间的通讯。包括点对点和广播。
5.JTA：（Java Transaction API）
JAVA事务服务。提供各种分布式事务服务。应用程序只需调用其提供的接口即可。
6.JAF：（Java Action FrameWork）
JAVA安全认证框架。提供一些安全控制方面的框架。让开发者通过各种部署和自定义实现自己的个性安全控制策略。
7.RMI/IIOP: （Remote Method Invocation /internet对象请求中介协议）
他们主要用于通过远程调用服务。例如，远程有一台计算机上运行一个程序，它提供股票分析服务，我们可以在本地计算机上实现对其直接调用。当然这是要通过一定的规范才能在异构的系统之间进行通信。RMI是JAVA特有的。
112) 名词解释：WEB SERVICE、JAXP、JAXM、SOAP、UDDI、WSDL
1.Web Service：
是基于网络的、分布式的模块化组件，它执行特定的任务，遵守具体的技术规范，这些规范使得Web Service能与其他兼容的组件进行互操作。
2.JAXP(Java API for XML Parsing) ：
定义了在Java中使用DOM, SAX, XSLT的通用的接口。这样在你的程序中你只要使用这些通用的接口，当你需要改变具体的实现时候也不需要修改代码。
3.JAXM(Java API for XML Messaging) ：
是为SOAP通信提供访问方法和传输机制的API。
4.WSDL：
一种 XML 格式，用于将网络服务描述为一组端点，这些端点对包含面向文档信息或面向过程信息的消息进行操作。这种格式首先对操作和消息进行抽象描述，然后将其绑定到具体的网络协议和消息格式上以定义端点。相关的具体端点即组合成为抽象端点（服务）。
5.SOAP：
即简单对象访问协议(Simple Object Access Protocol)，它是用于交换XML编码信息的轻量级协议。
6.UDDI ：
其目的是为电子商务建立标准；UDDI是一套基于Web的、分布式的、为Web Service提供的、信息注册中心的实现标准规范，同时也包含一组使企业能将自身提供的Web Service注册，以使别的企业能够发现的访问协议的实现标准。
113) J2EE是技术还是平台还是框架？
J2EE本身是一个标准，一个为企业分布式应用的开发提供的标准平台。
J2EE也是一个框架，包括JDBC、JNDI、RMI、JMS、EJB、JTA等技术。
114) XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？
1.两种形式 dtd 和schema
2.本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)
3.解析XML文档的方式有DOM,SAX,STAX等
DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问
SAX:事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问
STAX:Streaming API for XML (StAX)
115) 你在项目中用到了xml技术的哪些方面?如何实现的?
用到了数据存贮，信息配置两方面。在做数据交换平台时，将不同数据源的数据组装成XML文件，然后将XML文件压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再同XML文件中还原相关信息进行处理。在做软件配置时，利用XML可以很方便的进行，软件的各种配置参数都存贮在XML文件中。
116) j2ee常用的设计模式？说明工厂模式
Java中的23种设计模式：
Factory（工厂模式）， Builder（建造模式）， Factory Method（工厂方法模式），
Prototype（原始模型模式），Singleton（单例模式）， Facade（门面模式），
Adapter（适配器模式）， Bridge（桥梁模式）， Composite（合成模式），
Decorator（装饰模式）， Flyweight（享元模式）， Proxy（代理模式），
Command（命令模式）， Interpreter（解释器模式）， Visitor（访问者模式），
Iterator（迭代子模式）， Mediator（调停者模式）， Memento（备忘录模式），
Observer（观察者模式）， State（状态模式）， Strategy（策略模式），
Template Method（模板方法模式）， Chain Of Responsibleity（责任链模式）
工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
九、 STRUTS
117) MVC的各个部分都有那些技术来实现?如何实现?
MVC 是Model－View－Controller的简写。"Model" 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）， "View" 是应用的表示面（由JSP页面产生），"Controller" 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。
118) 概述struts，以及struts如何实现MVC架构的？
Struts framework是一种基于java的技术，Web应用程序开发人员通过struts framework即可充分利用面向对象设计、代码重用以及“编写一次、到处运行”的优点。Struts提供了一种创建Web应用程序的框架，其中对应用程序的显示、表示和数据的后端代码进行了抽象。Struts采用jsp作为MVC的视图,由ActionServlet具体指定的action动作类作为控制器即MVC中的C，负责视图与模型之间的交互。控制器的每个入口点都由名为struts-config.xml的配置文件设置。该文件把来自视图的请求映射为特定的JAVA类以进行相应的处理，控制器还指定下一个视图的位置。Struts中的模型主要指的就是javabean，它是模型的代表，主要封装数据和业务逻辑。
119) 简单描述STRUTS的主要功能
Struts有如下的主要功能：
一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。
二.JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。
三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。
120) Struts的处理流程
1、控制器进行初始化工作，读取配置文件，为不同的Struts模块初始化相应的ModulConfig对象。
2、控制器接收Http请求，并从ActionConfig中找出对应于该请求的Action子类，如果没有对应的Action，控制器直接将请求转发给JSP或者静态页面，否则控制器将请求分发至具体的Action类进行处理。
3、在控制器调用具体的Action的Execute方法之前，ActionForm对象将利用Http请求中的参数来填充自已。还可以在ActionForm类中调用Validate方法来检查请求参数的合法性，并且可以返回一个包含所有错误信息的ActionErrors对象。
4、执行具体的的Execute的方法，它负责执行相应的业务逻辑。执行完后，返回一个ActionForward对象，控制器通过该ActionForward对象来进行转发工作。也可以把Action要处理的业务逻辑封装在JavaBean中，如果系统中还有EJB，那么通过JavaBean调用EJB以完成业务处理；如果没有EJB，那么就直接在JavaBean中连接数据库，进行数据库相关的操作。
十、 EJB
121) EJB2.0有哪些内容?分别用在什么场合? EJB2.0和EJB1.1的区别?
规范内容包括Bean提供者，应用程序装配者，EJB容器，EJB配置工具，EJB服务提供者，系统管理员。这里面，EJB容器是EJB之所以能够运行的核心。EJB容器管理着EJB的创建，撤消，激活，去活，与数据库的连接等等重要的核心工作。
122) EJB与JAVA BEAN的区别？
Java Bean 是可复用的组件，对Java Bean并没有严格的规范，理论上讲，任何一个Java类都可以是一个Bean。但通常情况下，由于Java Bean是被容器所创建（如Tomcat)的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。Java Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理， EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。
123) EJB是基于哪些技术实现的？并说出SessionBean和EntityBean，StatefulBean和StatelessBean的区别
EJB包括Session Bean、Entity Bean、Message Driven Bean，基于JNDI、RMI、JAT等技术实现。
SessionBean在J2EE应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调用其他EJB组件。EntityBean被用来代表应用系统中用到的数据。
对于客户机，SessionBean是一种非持久性对象，它实现某些在服务器上运行的业务逻辑。
对于客户机，EntityBean是一种持久性对象，它代表一个存储在持久性存储器中的实体的对象视图，或是一个由现有企业应用程序实现的实体。
Session Bean 还可以再细分为 Stateful Session Bean 与 Stateless Session Bean ，这两种的 Session Bean都可以将系统逻辑放在 method之中执行，不同的是 Stateful Session Bean 可以记录呼叫者的状态，因此通常来说，一个使用者会有一个相对应的 Stateful Session Bean 的实体。Stateless Session Bean 虽然也是逻辑组件，但是他却不负责记录使用者状态，也就是说当使用者呼叫 Stateless Session Bean 的时候，EJB Container 并不会找寻特定的 Stateless Session Bean 的实体来执行这个 method。换言之，很可能数个使用者在执行某个 Stateless Session Bean 的 methods 时，会是同一个 Bean 的 Instance 在执行。从内存方面来看， Stateful Session Bean 与 Stateless Session Bean 比较， Stateful Session Bean 会消耗 J2EE Server 较多的内存，然而 Stateful Session Bean 的优势却在于他可以维持使用者的状态。
124) EJB包括SessionBean和EntityBean，说出他们的生命周期，及如何管理事务的？
SessionBean：Stateless Session Bean 的生命周期是由容器决定的，当客户机发出请求要建立一个Bean的实例时，EJB容器不一定要创建一个新的Bean的实例供客户机调用，而是随便找一个现有的实例提供给客户机。当客户机第一次调用一个Stateful Session Bean 时，容器必须立即在服务器中创建一个新的Bean实例，并关联到客户机上，以后此客户机调用Stateful Session Bean 的方法时容器会把调用分派到与此客户机相关联的Bean实例。
EntityBean：Entity Beans能存活相对较长的时间，并且状态是持续的。只要数据库中的数据存在，Entity beans就一直存活。而不是按照应用程序或者服务进程来说的。即使EJB容器崩溃了，Entity beans也是存活的。Entity Beans生命周期能够被容器或者 Beans自己管理。
EJB通过以下技术管理事务：对象管理组织（OMG）的对象实务服务（OTS），Sun Microsystems的Transaction Service（JTS）、Java Transaction API（JTA），开发组（X/Open）的XA接口。
125) EJB的角色和三个对象
一个完整的基于EJB的分布式计算结构由六个角色组成，这六个角色可以由不同的开发商提供，每个角色所作的工作必须遵循Sun公司提供的EJB规范，以保证彼此之间的兼容性。这六个角色分别是EJB组件开发者（Enterprise Bean Provider）、应用组合者（Application Assembler）、部署者（Deployer）、EJB 服务器提供者（EJB Server Provider）、EJB 容器提供者（EJB Container Provider）、系统管理员（System Administrator）
三个对象是Remote（Local）接口、Home（LocalHome）接口，Bean类
126) EJB容器提供的服务
主要提供声明周期管理、代码产生、持续性管理、安全、事务管理、锁和并发行管理等服务。
127) EJB规范规定EJB中禁止的操作有哪些？
1.不能操作线程和线程API(线程API指非线程对象的方法如notify,wait等)
2.不能操作awt
3.不能实现服务器功能
4.不能对静态属生存取
5.不能使用IO操作直接存取文件系统
6.不能加载本地库
7.不能将this作为变量和返回
8.不能循环调用。
128) remote接口和home接口主要作用
remote接口定义了业务方法，用于EJB客户端调用业务方法。
home接口是EJB工厂用于创建和移除查找EJB实例
129) bean 实例的生命周期
对于Stateless Session Bean、Entity Bean、Message Driven Bean一般存在缓冲池管理，而对于Entity Bean和Statefull Session Bean存在Cache管理，通常包含创建实例，设置上下文、创建EJB Object（create）、业务方法调用、remove等过程，对于存在缓冲池管理的Bean，在create之后实例并不从内存清除，而是采用缓冲池调度机制不断重用实例，而对于存在Cache管理的Bean则通过激活和去激活机制保持Bean的状态并限制内存中实例数量。
130) EJB的激活机制
以Stateful Session Bean 为例：其Cache大小决定了内存中可以同时存在的Bean实例的数量，根据MRU或NRU算法，实例在激活和去激活状态之间迁移，激活机制是当客户端调用某个EJB实例业务方法时，如果对应EJB Object发现自己没有绑定对应的Bean实例则从其去激活Bean存储中（通过序列化机制存储实例）回复（激活）此实例。状态变迁前会调用对应的 ejbActive和ejbPassivate方法。
131) EJB的几种类型
会话（Session）Bean ，实体（Entity）Bean 消息驱动的（Message Driven）Bean
会话Bean又可分为有状态（Stateful）和无状态（Stateless）两种
实体Bean可分为Bean管理的持续性（BMP）和容器管理的持续性（CMP）两种
132) 客服端调用EJB对象的几个基本步骤
设置JNDI服务工厂以及JNDI服务地址系统属性，查找Home接口，从Home接口调用Create方法创建Remote接口，通过Remote接口调用其业务方法。
133) EJB需直接实现它的业务接口或Home接口吗，请简述理由
远程接口和Home接口不需要直接实现，他们的实现代码是由服务器产生的，程序运行中对应实现类会作为对应接口类型的实例被使用。
十一、 应用服务器
134) 应用服务器有那些？
BEA WebLogic Server，IBM WebSphere Application Server，Oracle9i Application Server，jBoss，Tomcat
135) 应用服务器与WEB 服务器的区别？
应用服务器如Weblogic、Tomcat、Jboss；WEB 服务器如IIS、 Apache
应用服务器处理业务逻辑，能处理动态页面，及相关的组件,web服务器只处理http请求的html等静态页面(资源) 。web服务器通常比应用服务器简单
136) 如何给weblogic指定大小的内存?
在启动Weblogic的脚本中（位于所在Domian对应服务器目录下的startServerName），增加set MEM_ARGS=-Xms32m -Xmx200m，可以调整最小内存为32M，最大200M
137) 如何设定的weblogic的热启动模式(开发模式)与产品发布模式?
可以在管理控制台中修改对应服务器的启动模式为开发或产品模式之一。或者修改服务的启动文件或者commenv文件，增加set PRODUCTION_MODE=true。
138) 如何启动时不需输入用户名与密码?
修改服务启动文件，增加 WLS_USER和WLS_PW项。也可以在boot.properties文件中增加加密过的用户名和密码.
139) 在weblogic管理制台中对一个应用域进行jms及ejb或连接池等相关信息进行配置后,实际保存在什么文件中?
保存在此Domain的config.xml文件中，它是服务器的核心配置文件。
140) 说说weblogic中一个Domain的缺省目录结构
Domain目录服务器目录applications，将应用目录放在此目录下将可以作为应用访问，如果是Web应用，应用目录需要满足Web应用目录要求，jsp文件可以直接放在应用目录中，Javabean需要放在应用目录的WEB-INF目录的classes目录中，设置服务器的缺省应用将可以实现在浏览器上无需输入应用名。
141) 在weblogic中发布ejb需涉及到哪些配置文件
不同类型的EJB涉及的配置文件不同，都涉及到的配置文件包括ejb-jar.xml,weblogic-ejb-jar.xml，CMP实体Bean一般还需要weblogic-cmp-rdbms-jar.xml
142) 如何在weblogic中进行ssl配置与客户端的认证配置或说说j2ee(标准)进行ssl的配置
缺省安装中使用DemoIdentity.jks和DemoTrust.jks KeyStore实现SSL，需要配置服务器使用Enable SSL，配置其端口，在产品模式下需要从CA获取私有密钥和数字证书，创建identity和trust keystore，装载获得的密钥和数字证书。可以配置此SSL连接是单向还是双向的。
143) 如何查看在weblogic中已经发布的EJB?
可以使用管理控制台，在它的Deployment中可以查看所有已发布的EJB
说说在weblogic中开发消息Bean时的persistent与non-persisten的差别
persistent方式的MDB可以保证消息传递的可靠性,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来，而non－persistent方式的消息将被丢弃。
改错题
1)
abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}
答案: 错。abstract method必须以分号结尾，且不带花括号。
2)
public class Something {
void doSomething () {
private String s = "";
int l = s.length();
}
}
答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量
(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。
3)
abstract class Something {
private abstract String doSomething ();
}
答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract
method封锁起来呢? (同理，abstract method前不能加final)。
4)
public class Something {
public int addOne(final int x) {
return ++x;
}
}
答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。
5)
public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference
(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable
(成员变量)，而o的reference并没有改变。
6)
class Something {
int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
有什么错呢? 看不出来啊。
答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。
7)
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。
8)
public class Something {
public static void main(String[] args) {
Something s = new Something();
System.out.println("s.doSomething() returns " + doSomething());
}
public String doSomething() {
return "Do something ...";
}
}
答案: 错。看上去在main里访问doSomething方法没有什么问题，毕竟两个方法都在同一个class里。但仔细看，main是静态的。静态方法不能直接访问非静态方法。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，静态不能访问非静态成员变量。
9)
此处，Something类的文件名叫OtherThing.java
class Something {
private static void main(String[] something_to_do) {
System.out.println("Do something ...");
}
}
答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。
10)
interface A{
int x = 0;
}
class B{
int x =1;
}
class C extends B implements A {
public void pX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。
11)
interface Playable {
void play();
}
interface Bounceable {
void play();
}
interface Rollable extends Playable, Bounceable {
Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
private String name;
public String getName() {
return name;
}
public Ball(String name) {
this.name = name;
}
public void play() {
ball = new Ball("Football");
System.out.println(ball.getName());
}
}
答案: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多个interfaces，所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任何在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()方法中，"ball = new Ball("Football");"改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。
编程题
1) 在控制台中输入一个字符串，然后按照逆序打印出来
import java.io.*;
public class test{
public static void main(String args[]){
StringBuffer str = new StringBuffer(new Scanner(System.in).next());
System.out.println(str.reverse().toString());
}
2) 设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。
public class ThreadTest1{
private int j;
public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.start();
}
}
private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+"-inc:"+j);
}
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+"-dec:"+j);
}
class Inc implements Runnable{
public void run(){
for(int i=0;i<100;i++){
inc();
}
}
}
class Dec implements Runnable{
public void run(){
for(int i=0;i<100;i++){
dec();
}
}
}
}
3) 将一个键盘输入的数字转化成中文输出(例如：输入1234567，输出:一百二拾三万四千五百六拾七),请用java语言编一段程序实现!
public class Reader {
private String strNum;
private String strNumChFormat;
private String strNumTemp;
private int intNumLen;
private String strBegin;
public Reader(String strNum) {
this.strNum = strNum;
}
public boolean check(String strNum) {
boolean valid = false;
if (strNum.substring(0,1).equals("0")){
this.strNum = strNum.substring(1);
}
try {
new Double(strNum);
valid = true;
} catch (NumberFormatException ex) {
System.out.println("Bad number format!");
}
return valid;
}
public void init() {
strNumChFormat = "";
intNumLen = strNum.length();
strNumTemp = strNum;
strNumTemp = strNumTemp.replace('1', '一');
strNumTemp = strNumTemp.replace('2', '二');
strNumTemp = strNumTemp.replace('3', '三');
strNumTemp = strNumTemp.replace('4', '四');
strNumTemp = strNumTemp.replace('5', '五');
strNumTemp = strNumTemp.replace('6', '六');
strNumTemp = strNumTemp.replace('7', '七');
strNumTemp = strNumTemp.replace('8', '八');
strNumTemp = strNumTemp.replace('9', '九');
strNumTemp = strNumTemp.replace('0', '零');
strNumTemp = strNumTemp.replace('.', '点');
strBegin = strNumTemp.substring(0, 1);
}
public String readNum() {
if (check(strNum)) {
init();
try {
for (int i = 1, j = 1, k = 1; i < intNumLen; i++) {
if (strNumTemp.charAt(intNumLen - 1) == '零' && i == 1) {
strNumChFormat = "位";
}
else if (strNumTemp.charAt(intNumLen - i) == '零' && j == 1) {
strNumChFormat = "位" + strNumChFormat;
}
else if (strNumTemp.charAt(intNumLen - i) == '点') {
j = 1;
k = 1;
strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
continue;
}
else {
strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
}
if (strNumTemp.charAt(intNumLen - i - 1) != '位' &&
strNumTemp.charAt(intNumLen - i - 1) != '零') {
if (j == 1 && i < intNumLen) {
strNumChFormat = '拾' + strNumChFormat;
}
else if (j == 2 && i < intNumLen) {
strNumChFormat = '百' + strNumChFormat;
}
else if (j == 3 && i < intNumLen) {
strNumChFormat = '千' + strNumChFormat;
}
}
if (j == 4 && i < intNumLen) {
j = 0;
}
if (k == 4 && i < intNumLen) {
strNumChFormat = '万' + strNumChFormat;
}
else if (k == 8 && i < intNumLen) {
k = 0;
strNumChFormat = '亿' + strNumChFormat;
}
j++;
k++;
}
while (strNumChFormat.indexOf("位") != -1) {
strNumChFormat = strNumChFormat.replaceAll("位", " ");
}
if (strNumChFormat.substring(0, 2) == "一拾") {
strNumChFormat = strNumChFormat.substring(1, strNumChFormat.length());
}
if (strNumChFormat.indexOf("点") >= 0) {
String rebegin = strNumChFormat.substring(0,
strNumChFormat.indexOf("点"));
String relast = strNumChFormat.substring(strNumChFormat.indexOf("点"),
strNumChFormat.length());
for (int i = 1; i <= relast.length(); i++) {
relast = relast.replaceAll("拾", "");
relast = relast.replaceAll("百", "");
relast = relast.replaceAll("千", "");
relast = relast.replaceAll("万", "");
relast = relast.replaceAll("亿", "");
}
strNumChFormat = rebegin + relast;
}
}
catch (ArrayIndexOutOfBoundsException ex) {
ex.printStackTrace();
}
catch (Exception ex) {
ex.printStackTrace();
}
int off = strNumChFormat.indexOf("点");
strNumChFormat = strBegin + strNumChFormat.substring(0);
}
else {
strNumChFormat = "";
}
return strNumChFormat;
}
public static void main(String args[]) {
try {
String number = args[0].toString();
System.out.println("The number is: " + number);
Reader reader = new Reader(number);
System.out.println("Output String: " + reader.readNum());
}
catch (Exception ex) {
System.out.println("Please input like that: javac Reader
}
}
}
4) 写一个Singleton出来
Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
一般Singleton模式通常有几种种形式:
第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例化，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。
public class Singleton {
private Singleton(){}
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
第二种形式:
public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance;
}
}
其他形式:
定义一个类，它的构造函数为private的，所有方法为static的。
一般认为第一种形式要更加安全些
5) 我们在web应用开发过程中经常遇到输出某种编码的字符，如iso8859-1等，如何输出一个某种编码的字符串
Public String translate (String str) {
String tempStr = "";
try {
tempStr = new String(str.getBytes("ISO-8859-1"), "GBK");
tempStr = tempStr.trim();
}
catch (Exception e) {
System.err.println(e.getMessage());
}
return tempStr;
}
6) 现在输入n个数字，以逗号，分开；然后可选择升或者降序排序；按提交键就在另一页面显示按什么排序，结果为，提供reset
import java.util.*;
public class bycomma{
public static String[] splitStringByComma(String source){
if(source==null||source.trim().equals(""))
return null;
StringTokenizer commaToker = new StringTokenizer(source,",");
String[] result = new String[commaToker.countTokens()];
int i=0;
while(commaToker.hasMoreTokens()){
result[i] = commaToker.nextToken();
i++;
}
return result;
}
public static void main(String args[]){
String[] s = splitStringByComma("5,8,7,4,3,9,1");
int[] ii = new int[s.length];
for(int i = 0; i ii[i] =Integer.parseInt(s[i]); } Arrays.sort(ii); //asc for(int i=0;i System.out.println(ii[i]); } //desc for(int i=(s.length-1);i>=0;i--){ System.out.println(ii[i]); } } } 父类： package test; public class FatherClass { public FatherClass() { System.out.println("FatherClass Create"); } } 子类： package test; import test.FatherClass; public class ChildClass extends FatherClass { public ChildClass() { System.out.println("ChildClass Create"); } public static void main(String[] args) { FatherClass fc = new FatherClass(); ChildClass cc = new ChildClass(); } } 输出结果： C:\>java test.ChildClass FatherClass Create FatherClass Create ChildClass Create 示例代码如下： package test; public class OuterClass { private class InterClass { public InterClass() { System.out.println("InterClass Create"); } } public OuterClass() { InterClass ic = new InterClass(); System.out.println("OuterClass Create"); } public static void main(String[] args) { OuterClass oc = new OuterClass(); } } 输出结果： C:\>java test/OuterClass InterClass Create OuterClass Create public class OuterClass { private double d1 = 1.0; //insert code here } 你需要在第三行插入一个内部类.，下面哪两个选项是正确的？ A. class InnerOne{ public static double methoda() {return d1;} } B. public class InnerOne{ static double methoda() {return d1;} } C. private class InnerOne{ double methoda() {return d1;} } D. static class InnerOne{ protected double methoda() {return d1;} } E. abstract class InnerOne{ public abstract double methoda(); } 说明如下： 1.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 故 A、B 错 2.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；故 D 错 3.非静态内部类的非静态成员可以访问外部类的非静态变量。 故 C 正确 4.答案为C、E 用插入法进行排序代码如下： package test; import java.util.*; class InsertSort { ArrayList al; public InsertSort(int num,int mod) { al = new ArrayList(num); Random rand = new Random(); System.out.println("The ArrayList Sort Before:"); for (int i=0;i al.add(new Integer(Math.abs(rand.nextInt()) % mod + 1)); System.out.println("al["+i+"]="+al.get(i)); } } public void SortIt() { Integer tempInt; int MaxSize=1; for(int i=1;i tempInt = (Integer)al.remove(i); if(tempInt.intValue()>=((Integer)al.get(MaxSize-1)).intValue()) { al.add(MaxSize,tempInt); MaxSize++; System.out.println(al.toString()); } else { for (int j=0;j if (((Integer)al.get(j)).intValue()>=tempInt.intValue()) { al.add(j,tempInt); MaxSize++; System.out.println(al.toString()); break; } } } } System.out.println("The ArrayList Sort After:"); for(int i=0;i System.out.println("al["+i+"]="+al.get(i)); } } public static void main(String[] args) { InsertSort is = new InsertSort(10,100); is.SortIt(); } } 代码如下： package test; class SplitString { String SplitStr; int SplitByte; public SplitString(String str,int bytes) { SplitStr=str; SplitByte=bytes; System.out.println("The String is:'"+SplitStr+"';SplitBytes="+SplitByte); } public void SplitIt() { int loopCount; loopCount=(SplitStr.length()%SplitByte==0)?(SplitStr.length()/SplitByte):(SplitStr.length()/SplitByte+1); System.out.println("Will Split into "+loopCount); for (int i=1;i<=loopCount ;i++ ) { if (i==loopCount){ System.out.println(SplitStr.substring((i-1)*SplitByte,SplitStr.length())); } else { System.out.println(SplitStr.substring((i-1)*SplitByte,(i*SplitByte))); } } } public static void main(String[] args) { SplitString ss = new SplitString("test中dd文dsaf中男大3443n中国43中国人0ewldfls=103",4); ss.SplitIt(); } } Server端程序： package test; import java.net.*; import java.io.*; public class Server{ private ServerSocket ss; private Socket socket; private BufferedReader in; private PrintWriter out; public Server() { try { ss=new ServerSocket(10000); while(true) { socket = ss.accept(); String RemoteIP = socket.getInetAddress().getHostAddress(); String RemotePort = ":"+socket.getLocalPort(); System.out.println("A client come in!IP:"+RemoteIP+RemotePort); in = new BufferedReader(new InputStreamReader(socket.getInputStream())); String line = in.readLine(); System.out.println("Cleint send is :" + line); out = new PrintWriter(socket.getOutputStream(),true); out.println("Your Message Received!"); out.close(); in.close(); socket.close(); } }catch (IOException e) { out.println("wrong"); } } public static void main(String[] args) { new Server(); } } Client端程序： package test; import java.io.*; import java.net.*; public class Client { Socket socket; BufferedReader in; PrintWriter out; public Client() { try { System.out.println("Try to Connect to 127.0.0.1:10000"); socket = new Socket("127.0.0.1",10000); System.out.println("The Server Connected!"); System.out.println("Please enter some Character:"); BufferedReader line = new BufferedReader(new InputStreamReader(System.in)); out = new PrintWriter(socket.getOutputStream(),true); out.println(line.readLine()); in = new BufferedReader(new InputStreamReader(socket.getInputStream())); System.out.println(in.readLine()); out.close(); in.close(); socket.close(); }catch(IOException e) { out.println("Wrong"); } } public static void main(String[] args) { new Client(); } } 程序如下： package hello.ant; import java.sql.*; public class jdbc { String dbUrl="jdbc:oracle:thin:@127.0.0.1:1521:orcl"; String theUser="admin"; String thePw="manager"; Connection c=null; Statement conn; ResultSet rs=null; public jdbc() { try{ Class.forName("oracle.jdbc.driver.OracleDriver").newInstance(); c = DriverManager.getConnection(dbUrl,theUser,thePw); conn=c.createStatement(); }catch(Exception e){ e.printStackTrace(); } } public boolean executeUpdate(String sql) { try { conn.executeUpdate(sql); return true; } catch (SQLException e) { e.printStackTrace(); return false; } } public ResultSet executeQuery(String sql) { rs=null; try { rs=conn.executeQuery(sql); } catch (SQLException e) { e.printStackTrace(); } return rs; } public void close() { try { conn.close(); c.close(); } catch (Exception e) { e.printStackTrace(); } } public static void main(String[] args) { ResultSet rs; jdbc conn = new jdbc(); rs=conn.executeQuery("selecｔ * from test"); try { while (rs.next()) { System.out.println(rs.getString("id")); System.out.println(rs.getString("name")); } }catch(Exception e) { e.printStackTrace(); } } } 一种分页方法： <% int i=1; int numPages=14; String pages = request.getParameter("page") ; int currentPage = 1; currentPage=(pages==null)?(1):{Integer.parseInt(pages)} sql = "selecｔ count(*) from tables"; ResultSet rs = DBLink.executeQuery(sql) ; while(rs.next()) i = rs.getInt(1) ; int intPageCount=1; intPageCount=(i%numPages==0)?(i/numPages):(i/numPages+1); int nextPage ; int upPage; nextPage = currentPage+1; if (nextPage>=intPageCount) nextPage=intPageCount; upPage = currentPage-1; if (upPage<=1) upPage=1; rs.close(); sql="selecｔ * from tables"; rs=DBLink.executeQuery(sql); i=0; while((i %> 输出内容： //输出翻页连接 合计:<%=currentPage%>/<%=intPageCount%>首页上页 <% for(int j=1;j<=intPageCount;j++){ if(currentPage!=j){ %> <% }else{ out.println(j); } } %> 用SAX方式解析XML，XML文件如下： 事件回调类SAXHandler.java import java.io.*; import java.util.Hashtable; import org.xml.sax.*; public class SAXHandler extends HandlerBase { private Hashtable table = new Hashtable(); private String currentElement = null; private String currentValue = null; public void setTable(Hashtable table) { this.table = table; } public Hashtable getTable() { return table; } public void startElement(String tag, AttributeList attrs) throws SAXException { currentElement = tag; } public void characters(char[] ch, int start, int length) throws SAXException { currentValue = new String(ch, start, length); } public void endElement(String name) throws SAXException { if (currentElement.equals(name)) { table.put(currentElement, currentValue); } } } JSP内容显示源码，SaxXml.jsp： <%@ page errorPage="ErrPage.jsp" contentType="text/html;charset=GB2312" %> <%@ page import="java.io.*" %> <%@ page import="java.util.Hashtable" %> <%@ page import="org.w3c.dom.*" %> <%@ page import="org.xml.sax.*" %> <%@ page import="javax.xml.parsers.SAXParserFactory" %> <%@ page import="javax.xml.parsers.SAXParser" %> <%@ page import="SAXHandler" %> <% File file = new File("c:\\people.xml"); FileReader reader = new FileReader(file); Parser parser; SAXParserFactory spf = SAXParserFactory.newInstance(); SAXParser sp = spf.newSAXParser(); SAXHandler handler = new SAXHandler(); sp.parse(new InputSource(reader), handler); Hashtable hashTable = handler.getTable(); out.println(" out.println(" (String)hashTable.get(new String("name")) + " out.println(" (String)hashTable.get(new String("college"))+" out.println(" (String)hashTable.get(new String("telephone")) + " out.println(" (String)hashTable.get(new String("notes")) + " out.println(" %> 看如下代码,用编码方式加以解决： package test; import java.io.*; public class DOMTest { private String inFile = "c:\\people.xml"; private String outFile = "c:\\people.xml"; public static void main(String args[]) { new DOMTest(); } public DOMTest() { try { javax.xml.parsers.DocumentBuilder builder =javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder(); org.w3c.dom.Document doc = builder.newDocument(); org.w3c.dom.Element root = doc.createElement("老师"); org.w3c.dom.Element wang = doc.createElement("王"); org.w3c.dom.Element liu = doc.createElement("刘"); wang.appendChild(doc.createTextNode("我是王老师")); root.appendChild(wang); doc.appendChild(root); javax.xml.transform.Transformer transformer = javax.xml.transform.TransformerFactory.newInstance().newTransformer(); transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, "gb2312"); transformer.setOutputProperty(javax.xml.transform.OutputKeys.INDENT, "yes"); transformer.transform(new javax.xml.transform.dom.DOMSource(doc), new javax.xml.transform.stream.StreamResult(outFile)); } catch (Exception e) { System.out.println (e.getMessage()); } } }7) 继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么?
8) 同上，关于内部类的实现方式
9) 关于内部类实现的一道选择题
10) 用JAVA实现一种排序
11) 编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如“我ABC”4，应该截为“我AB”，输入“我ABC汉DEF”，6，应该输出为“我ABC”而不是“我ABC+汉的半个”。
12) 用JAVA SOCKET编程，读服务器几个字符，再写入本地显示
13) 写一段Jdbc连Oracle的程序,并实现数据查询.
14) ORACLE大数据量下的分页解决方法。一般用截取ID方法，还有是三层嵌套方法。
15) 用JAVA解析XML的方式.
");姓名 " + "" +
学院 " + "" +
电话 " + "" +
备注 " + "" +
16) 用jdom解析xml文件时如何解决中文问题?如何解析?
其它
1) 描述一下你最常用的编程风格。
(1) 类名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。 Java包（Package）属于一种特殊情况：它们全都是小写字母，即便中间的单词亦是如此。对于域名扩展名称，如com，org，net或者edu 等，全部都应小写（这也是Java 1.1和Java 1.2的区别之一）。
(2) 为了常规用途而创建一个类时，请采取“经典形式”，并包含对下述元素的定义：equals()hashCode()toString()clone()（implement Cloneable）implement Serializable
(3) 对于自己创建的每一个类，都考虑置入一个main()，其中包含了用于测试那个类的代码。为使用一个项目中的类，我们没必要删除测试代码。若进行了任何形式的改动，可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。
(4) 应将方法设计成简要的、功能性单元，用它描述和实现一个不连续的类接口部分。理想情况下，方法应简明扼要。若长度很大，可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用（有些时候，方法必须非常大，但它们仍应只做同样的一件事情）。
(5) 设计一个类时，请设身处地为客户程序员考虑一下（类的使用方法应该是非常明确的）。然后，再设身处地为管理代码的人考虑一下（预计有可能进行哪些形式的修改，想想用什么方法可把它们变得更简单）。
(6) 使类尽可能短小精悍，而且只解决一个特定的问题。下面是对类设计的一些建议：一个复杂的开关语句：考虑采用“多形”机制数量众多的方法涉及到类型差别极大的操作：考虑用几个类来分别实现许多成员变量在特征上有很大的差别：考虑使用几个类
(7) 让一切东西都尽可能地“私有”——private。可使库的某一部分“公共化”（一个方法、类或者一个字段等等），就永远不能把它拿出。若强行拿出，就可能破坏其他人现有的代码，使他们不得不重新编写和设计。若只公布自己必须公布的，就可放心大胆地改变其他任何东西。在多线程环境中，隐私是特别重要的一个因素——只有private字段才能在非同步使用的情况下受到保护。
(8) 谨惕“巨大对象综合症”。对一些习惯于顺序编程思维、且初涉OOP领域的新手，往往喜欢先写一个顺序执行的程序，再把它嵌入一个或两个巨大的对象里。根据编程原理，对象表达的应该是应用程序的概念，而非应用程序本身。
(9) 若不得已进行一些不太雅观的编程，至少应该把那些代码置于一个类的内部。
(10) 任何时候只要发现类与类之间结合得非常紧密，就需要考虑是否采用内部类，从而改善编码及维护工作（参见第14章14.1.2小节的“用内部类改进代码”）。
(11) 尽可能细致地加上注释，并用javadoc注释文档语法生成自己的程序文档。
(12) 避免使用“魔术数字”，这些数字很难与代码很好地配合。如以后需要修改它，无疑会成为一场噩梦，因为根本不知道“100”到底是指“数组大小”还是“其他全然不同的东西”。所以，我们应创建一个常数，并为其使用具有说服力的描述性名称，并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。
(13) 涉及构建器和异常的时候，通常希望重新丢弃在构建器中捕获的任何异常——如果它造成了那个对象的创建失败。这样一来，调用者就不会以为那个对象已正确地创建，从而盲目地继续。
(14) 当客户程序员用完对象以后，若你的类要求进行任何清除工作，可考虑将清除代码置于一个良好定义的方法里，采用类似于cleanup()这样的名字，明确表明自己的用途。除此以外，可在类内放置一个boolean（布尔）标记，指出对象是否已被清除。在类的finalize()方法里，请确定对象已被清除，并已丢弃了从RuntimeException继承的一个类（如果还没有的话），从而指出一个编程错误。在采取象这样的方案之前，请确定finalize ()能够在自己的系统中工作（可能需要调用System.runFinalizersOnExit(true)，从而确保这一行为）。
(15) 在一个特定的作用域内，若一个对象必须清除（非由垃圾收集机制处理），请采用下述方法：初始化对象；若成功，则立即进入一个含有finally从句的try块，开始清除工作。
(16) 若在初始化过程中需要覆盖（取消）finalize()，请记住调用super.finalize()（若Object属于我们的直接超类，则无此必要）。在对finalize()进行覆盖的过程中，对super.finalize()的调用应属于最后一个行动，而不应是第一个行动，这样可确保在需要基础类组件的时候它们依然有效。
(17) 创建大小固定的对象集合时，请将它们传输至一个数组（若准备从一个方法里返回这个集合，更应如此操作）。这样一来，我们就可享受到数组在编译期进行类型检查的好处。此外，为使用它们，数组的接收者也许并不需要将对象“造型”到数组里。
(18) 尽量使用interfaces，不要使用abstract类。若已知某样东西准备成为一个基础类，那么第一个选择应是将其变成一个interface（接口）。只有在不得不使用方法定义或者成员变量的时候，才需要将其变成一个abstract（抽象）类。接口主要描述了客户希望做什么事情，而一个类则致力于（或允许）具体的实施细节。
(19) 在构建器内部，只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法，因为那些方法可能被其他人覆盖或取消，从而在构建过程中产生不可预知的结果（参见第7章的详细说明）。
(20) 对象不应只是简单地容纳一些数据；它们的行为也应得到良好的定义。
(21) 在现成类的基础上创建新类时，请首先选择“新建”或“创作”。只有自己的设计要求必须继承时，才应考虑这方面的问题。若在本来允许新建的场合使用了继承，则整个设计会变得没有必要地复杂。
(22) 用继承及方法覆盖来表示行为间的差异，而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色，这是绝对应该避免的：应直接使用一个“颜色”字段。
(23) 为避免编程时遇到麻烦，请保证在自己类路径指到的任何地方，每个名字都仅对应一个类。否则，编译器可能先找到同名的另一个类，并报告出错消息。若怀疑自己碰到了类路径问题，请试试在类路径的每一个起点，搜索一下同名的.class文件。
(24) 在Java 1.1 AWT中使用事件“适配器”时，特别容易碰到一个陷阱。若覆盖了某个适配器方法，同时拼写方法没有特别讲究，最后的结果就是新添加一个方法，而不是覆盖现成方法。然而，由于这样做是完全合法的，所以不会从编译器或运行期系统获得任何出错提示——只不过代码的工作就变得不正常了。
(25) 用合理的设计方案消除“伪功能”。也就是说，假若只需要创建类的一个对象，就不要提前限制自己使用应用程序，并加上一条“只生成其中一个”注释。请考虑将其封装成一个“独生子”的形式。若在主程序里有大量散乱的代码，用于创建自己的对象，请考虑采纳一种创造性的方案，将些代码封装起来。
(26) 警惕“分析瘫痪”。请记住，无论如何都要提前了解整个项目的状况，再去考察其中的细节。由于把握了全局，可快速认识自己未知的一些因素，防止在考察细节的时候陷入“死逻辑”中。
(27) 警惕“过早优化”。首先让它运行起来，再考虑变得更快——但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候，才应进行优化。除非用专门的工具分析瓶颈，否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解，而且难于维护。
(28) 请记住，阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序，但注释、细致的解释以及一些示例往往具有不可估量的价值。无论对你自己，还是对后来的人，它们都是相当重要的。如对此仍有怀疑，那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折，这样或许能将你说服。