java常见笔试面试题

第三、Java面向对象
1、抽象类和接口的区别？
(1)接口可以被多重implements,抽象类只能被单一extends
(2)接口只有定义,抽象类可以有定义和实现
(3)接口的字段定义默认为:public static final,
(4)抽象类是典型的一个模板方法
2、java中常见的异常类：
(1). java.lang.nullpointerexception “程序遇上了空指针”，
(2). java.lang.arrayindexoutofboundsexception “数组下标越界”，
(3). java.lang.IndexOutOfBoundsException 索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时，抛出该异常。
(4). java.lang.OutOfMemoryError 内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。

第四、线程
3、sleep() 和 wait() 有什么区别
Sleep是指休眠给定的时间，当这个时间达到之后，线程会再次醒来。
Wait是等待状态，多长时间不清楚，由另一个线程将其唤醒。

、启动一个线程是用run()还是start()?
启动一个线程是调用start()方法，启动线程并调用run方法。
3、线程的基本概念、线程的基本状态以及状态之间的关系
线程是进程内的并发，没有自已内存空间，共享进程的，线程间的通信成本较低。
Java中的线程有四种状态分别是：运行、就绪、挂起、结束。
4、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么? 用什么关键字修饰同步方法?
stop()和suspend()方法为何不推荐使用？

多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被”挂起”的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用 wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

第四、Jsp与servlet的区别 ：
1.jsp经编译后就变成了Servlet.(JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码,Web容器将JSP的代码编译成JVM能够识别的java类)
2.jsp更擅长表现于页面显示,servlet更擅长于逻辑控制.
3.Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象以及HttpServlet对象得到.
Jsp是Servlet的一种简化，使用Jsp只需要完成程序员需要输出到客户端的内容，Jsp中的Java脚本如何镶嵌到一个类中，由Jsp容器完成。而Servlet则是个完整的Java类，这个类的Service方法用于生成对客户端的响应。

2、JSP中动态INCLUDE与静态INCLUDE的区别？
jsp:include:在运行时调用另一个页面，变量是可以重复的。
<%@include file=””%>:在转译时合在一起，会成为同一个类，变量不可以重复。
3、forward和redirect的区别？
forward: 转发，在下一个页面中,request保留上一个页面中的request的所有值
redirect: 跳转，不传递request对象。

3 、请罗列jsp中的脚本、指令及动作?
指令
<%@page contentType=”text/html;charset=utf-8”language=”java” import=””%> 配置字符集错误页面等等
<%@include file=””%> 包含一下js jsp等
<%@taglib uri=”” prefix=””%> 导包
动作:
<jsp:useBean class=”” id=”” scope=””> 在scope中如果没有实例化一个对象，如果有直接用以前的。
<jsp:getProperty name=”” property=””> 向一个bean中设置属性值
<jsp:forward > jsp页的转发
<jsp:include page=””> 导入一个jsp页面

1、ArrayList,Vector, LinkedList的存储性能和特性HashMap和Hashtable的区别：
ArrayList Vector:以数组的方式存储，增、删慢，查、改快
ArrayList:线程不安全，速度快
Vector:线程安全，速度慢(synchoronized)
LikedList: 以单链表的方式存储，增、删快，查、改慢
HashMap与Hashtable都实现的Map接口,HashTable线程安全，HashMap线程不安全。

2、集合的通用方法有那些?通用方法是什么?(操作)
(1)集合List 的遍历方法有：
Iterator:
Enumeration
For
Get
set
(2)Collection的通用方法有：
Iterator()
Add()
Clear();
remove()

2.char类型的变量中是否可以存储中文汉字，为什么。

3.写出常用的两种解析xml方式，各自有什么优缺点。

可以使用SAX来查询或者阅读XML文档。SAX可以快速扫描一个大型的XML文档，当它找到查询标准时就会立即停止，然后再处理之。DOM是把XML全部加载到内存中建立一棵树之后再进行处理。所以DOM不适合处理大型的XML【会产生内存的急剧膨胀】。

同理，DOM的弱项就是SAX的强项，SAX不必把全部的xml都加载到内存中。但是SAX的缺点也很明显，它只能对文件顺序解析一遍，不支持对文件的随意存取。SAX也仅仅能够读取文件的内容，并不能修改内容。DOM可以随意修改文件树，从而修改了xml文件。

4.代码实现判断字符串“abcdefg”是以“abc”开头的。

5.Singleton是什么，有几种实现，写一个Singleton类。

6.Jsp有那些内置对象，功能时什么

7.MVC是什么，怎么实现的，

8.在Spring+Struts2+ibtas组成框架，三种框架各有什么特点

NaN 属性是代表非数字值的特殊值。该属性用于指示某个值不是数字。

isNaN() 函数用于检查其参数是否是非数字值。

../表示相对当前路径的上一级目录；

./表示相对当前的路径；

1.==  两边值类型不同的时候，要先进行类型转换，再比较。

  === 不做类型转换，类型不同的一定不等。

  "=="和"==="的规则如下：

先说 ===，这个比较简单，具体比较规则如下：

1、如果类型不同，就[不相等]

2、如果两个都是数值，并且是同一个值，那么[相等]；(！例外)的是，如果其中至少一个是NaN，那么[不相等]。（判断一个值是否是NaN，只能用isNaN()来判断）

3、如果两个都是字符串，每个位置的字符都一样，那么[相等]；否则[不相等]。

4、如果两个值都是true，或者都是false，那么[相等]。

5、如果两个值都引用同一个对象或函数，那么[相等]；否则[不相等]。

6、如果两个值都是null，或者都是undefined，那么[相等]。

再说 ==，具体比较规则如下：

1、如果两个值类型相同，进行 === 比较，比较规则同上

2、如果两个值类型不同，他们可能相等。根据下面规则进行类型转换再比较：

a、如果一个是null、一个是undefined，那么[相等]。

b、如果一个是字符串，一个是数值，把字符串转换成数值再进行比较。

c、如果任一值是 true，把它转换成 1 再比较；如果任一值是 false，把它转换成 0 再比较。

d、 如果一个是对象，另一个是数值或字符串，把对象转换成基础类型的值再比较。对象转换成基础类型，利用它的toString或者valueOf方法。js核心内置类，会尝试valueOf先于toString；例外的是Date，Date利用的是toString转换。非js核心的对象，令说（比较麻烦，我 也不大懂）

e、任何其他组合（array数组等），都[不相等]。

面试遇到的问题：

1.黑盒与白盒的不同

黑盒测试也称功能测试或数据驱动测试，它是在已知产品所应具有的功能，通过测试来检测每个功能是否都能正常使用，在测试时，把程序看作一个不能打开的黑盆子，在完全不考虑程序内部结构和内部特性的情况下，

白盒测试也称结构测试或逻辑驱动测试，它是知道产品内部工作过程，

可通过测试来检测产品内部动作是否按照规格说明书的规定正常进行，

按照程序内部的结构测试程序，检验程序中的每条通路是否都有能按预

定要求正确工作，而不顾它的功能，白盒测试的主要方法有逻辑驱动、基路测试等，

主要用于软件验证。

2.标识符的是否正确

标识符必须以字母、下划线_、美元符$开发

其他部分可以是字母、下划线_、美元符$、数字的任意组合

接口类中方法只能用public 和default,不能用protected,private;

java 初始化块的作用是什么?

静态代码块在加载类的时候运行，就意味着静态代码块在程序中只会运行一次

class Demo{

 {

 System.out.println("构造块");

 }

   static{

   System.out.println("类中静态构造块");

   }

  public Demo(){

      System.out.println("构造方法");

   }

 public staticvoid main(String args[]){

  new Demo();

 System.out.println("---------------------------------");

  new Demo();

 System.out.println("---------------------------------");

  new Demo();

 }

 static{

 System.out.println("---------------主类中的静态代码块---------------------------------");

 }

}

 

运行结果：类中静态构造块

---------------主类中的静态代码块---------------------------------

构造块

构造方法

---------------------------------

构造块

构造方法

总结：最先执行静态初始化块，多个静态初始化块，按顺序依次执行，而且静态初始化块只执行一次，然后在执行构造块，最后执行构造方法

1. super()与this()的区别？

2. 作用域public,protected,private,以及不写时的区别？

3. 在JAVA中，如何跳出当前的多重嵌套循环？

4. 一个“.java”源文件中是否可以包括多个类（不是内部类）？有什么限制？

5.排序都有哪几种方法？   插入排序、交换排序、归并排序、选择排序。

6. Overload和Override的区别?

7. Final类有什么特点？

8. &和&&的区别？

9. GC是什么? 为什么要有GC?

10. Math.round(11.5)等於多少?Math.round(-11.5)等於多少?

11.什么是类的反射机制?

12.得到Class的三个过程是什么? 对象.getClass() 类.class或   Class.forName();

13.说出一些常用的类，包，接口，请各举5个？

14.静态变量和实例变量的区别？

15. String and StringBuffer的区别？

16.集合的作用是什么?

17. List, Set, Map是否继承自Collection接口?

18. String是最基本的数据类型吗?

19. char型变量中能不能存贮一个中文汉字?为什么?

20.启动一个线程是用run()还是start()?

21. sleep() 和 wait() 有什么区别?

22. JDBC如何做事务处理？

23. Java中访问数据库的步骤？

24. Class.forName的作用?为什么要用?

25. String and StringBuffer的区别？

26. forward和redirect的区别？

27.如何实现一个自定义的Servlet?

28. Servlet的生命周期是什么?

29. JSP就是一个Servlet是否正确?

30. JSP有哪些内置对象 ？

31. include的两种实现方式的区别?

<% include %> <jsp:include></jsp:include>

32. JSP页面中两种跳转方式分别是什么?有什么区别?

请求转发和重定向

33.在JSP中如何读取客户端的请求，如何确定某个JSP文件的真实路径？

34.描述Cookie和Session的作用，区别和各自的应用范围，Session工作原理。

35.什么情况下调用doGet()和doPost()？

36. Hibernate的核心配置文件是什么及其作用?

37. Hibernate中有哪几种关联关系？

38. Hibernate对象的三大状态？

39. Struts 2处理请求的全过程是什么?

40.什么是AOP和IOC，它们的作用是什么?

5、String是最基本的数据类型吗?

基本数据类型包括byte、int、char、long、float、double、boolean和short。

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类

6、int 和Integer 有什么区别

Java提供两种不同的类型：引用类型和原始类型（或内置类型）。Int是java的原始数据类型，Integer是java为int提供的封装类。Java为每个原始类型提供了封装类。

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

7、String 和StringBuffer的区别

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

8、运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

9、说出Servlet的生命周期，并说出Servlet和CGI的区别。

Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候调用其destroy方法。

与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

10、说出ArrayList,Vector, LinkedList的存储性能和特性

ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差， 而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

12、Collection 和Collections的区别。

Collection是集合类的上级接口，继承与他的接口主要有Set 和List.

Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

13、&和&&的区别。

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

15，HashMap和Hashtable的区别。

都属于Map接口的类，实现了将惟一键映射到特定的值上。

HashMap类没有分类或者排序。它允许一个 null 键和多个 null 值。

Hashtable类似于 HashMap，但是不允许 null 键和 null 值。它也比HashMap 慢，因为它是同步的。

15、final, finally, finalize的区别。

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

16、sleep() 和wait() 有什么区别?

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，把执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

17、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

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

19、同步和异步有何异同，在什么情况下分别使用他们？举例说明。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

20、abstract class和interface有什么区别?

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到 接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

22、forward 和redirect的区别

forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。

redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。

24、Static Nested Class 和 Inner Class的不同。

StaticNested Class是被声明为静态（static）的内部类，它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。

25、JSP中动态INCLUDE与静态INCLUDE的区别？

动态INCLUDE用jsp:include动作实现 <jsp:include page=”included.jsp” flush=”true” />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。

静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面<%@ include file=”included.htm” %>

26、什么时候用assertion。

assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语 句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正 确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为 了提高性能，在软件发布后，assertion检查通常是关闭的。

36、说出数据连接池的工作机制是什么?

连接客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。

38、数组有没有length()这个方法? String有没有length()这个方法？

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

39、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。

equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

43、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

会执行，在return前执行。

47、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

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

51、垃圾回收的优点和原理。并考虑2种回收机制。

Java语言中一个显着的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再 需要考虑内存管理。由于有个垃圾回收机制， Java中的对象不再有”作用域”的概念，只有对象的引用才有”作用域”。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是 作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

52、请说出你所知道的线程同步的方法。

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

53、你所知道的集合类都有哪些？主要方法？

最常用的集合类是 List 和 Map。 List 的具体实现包括

ArrayList和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。

List适用于按数值索引访问元素的情形。

Map提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作”键”和”值”），其中每个键映射到一个值。

62、如何现实servlet的单线程模式

<%@page isThreadSafe=”false”%>

64、JSP和Servlet有哪些相同点和不同点，他们之间的联系是什么？

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

70、XML文档定义有几种形式？它们之间有何本质区别？解析XML文档有哪几种方式？

a:两种形式 dtd,schema，b: 本质区别:schema本身是xml的，可以被XML解析器解析(这也是从DTD上发展schema的根本目的)，c:有DOM,SAX,STAX等

DOM:处理大型文件时其性能下降的非常厉害。这个问题是由DOM的树结构所造成的，这种结构占用的内存较多，而且DOM必须在解析文件之前把整个文档装入内存,适合对XML的随机访问

SAX:不现于DOM,SAX是事件驱动型的XML解析方式。它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML的顺序访问STAX:Streaming API for XML (StAX)

92、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（策略模式），

TemplateMethod（模板方法模式），ChainOf Responsibleity（责任链模式）

工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某一个类的实例，通常这一组类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后需要 定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

96、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语句。

98、MVC的各个部分都有那些技术来实现?如何实现?

MVC是Model－View－Controller的简写。”Model” 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现），“View” 是应用的表示面（由JSP页面产生），”Controller”是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。

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

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

103、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

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

106、是否可以从一个static方法内部发出对非static方法的调用？

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

109、List、Map、Set三个接口，存取元素时，各有什么特点？

List以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。

113、开发中都用到了那些设计模式?用在什么场合?

每个模式都描述了一个在我们的环境中不断出现的问题，然后描述了该问题的解决方案的核心。通过这种方式，你可以无数次地使用那些已有的解决方案，无需在重复相同的工作。主要用到了MVC的设计模式。用来开发JSP/Servlet或者J2EE的相关应用。简单工厂模式等。

117、BS与CS的联系与区别。

C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQLServer。客户端需要安装专用的客户端软件。

B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQLServer等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Ｗeb Server 同数据库进行数据交互。

C/S与 B/S 区别：

１．硬件环境不同:

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

B/S建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行

２．对安全要求不同

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

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

３．对程序架构不同

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

B/S对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean构件技术等,使 B/S更加成熟.

４．软件重用不同

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

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

５．系统维护不同

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

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

６．处理问题不同

C/S程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统

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

７．用户接口不同

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

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

８．信息流不同

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

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

119、STRUTS的应用(如STRUTS架构)

Struts是采用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。

Struts有如下的主要功能：

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

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

三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。

48、编程题: 写一个Singleton出来。

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

一般Singleton模式通常有几种种形式:

第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

publicclass Singleton {

privateSingleton(){}

//在自己内部定义自己一个实例，是不是很奇怪？

//注意这是private 只供内部调用

privatestatic Singleton instance = new Singleton();

//这里提供了一个供外部访问本class的静态方法，可以直接访问

publicstatic Singleton getInstance() {

returninstance;

}

}

第二种形式:

publicclass Singleton {

privatestatic Singleton instance = null;

publicstatic synchronized Singleton getInstance() {

//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次

//使用时生成实例，提高了效率！

if(instance==null)

instance＝new Singleton();

returninstance; 　　}

}

打乱排序

importjava.util.HashSet;

importjava.util.Iterator;

importjava,util.Set;

publicclass Iterator overSetDemo{

publicstatic void main(String[] args){

Set<String>set=new HashSet<String>();

set.add(“D”);

set.add(“A”);

set.add(“C”);

set.add(“B”);

for(Iteractori=set.iterator() : i.hasNext();){

Strings=(String)i.next();

System.out.print(s+”“);

}

}

}

//MySQL中的分页查询实现

importjava.io.InputStream;

importjava.sql.Connection;

importjava.sql.PreparedStatement;

importjava.sql.ResultSet;

importjava.sql.SQLException;

importjava.util.ArrayList;

importjava.util.List;

importweek07.domain.Flight;

importweek07.domain.News;

importweek07.util.ConnectionUtils;

publicclass FlightDaoImplForMySQL {

/**

* 分页查询flight表的所有列的数据

*

*@param page

*           第几页

*@param rowsPerPages

*           每页显示行数

*@param con

*           数据库连接

*@return 查询到的数据以News对象的形式存储到List中返回

*@throws Exception

*/

publicList<Flight> listPagesNewsDB(int page, int rowsPerPage,

Connectioncon) throws Exception {

intfrom = (page – 1) * rowsPerPage;

Stringsql = “select * from flight limit ?, ?;”;

Connectionconn = null;

PreparedStatementpStmt = null;

ResultSetrs = null;

Flightflight = null;

List<Flight>flights = new ArrayList<Flight>();

try{

conn= ConnectionUtils.openConnection();

pStmt= conn.prepareStatement(sql);

pStmt.setInt(1,from);

pStmt.setInt(2,rowsPerPage);

rs= pStmt.executeQuery();

while(rs.next()) {

Stringid = rs.getString(1);

Stringnum = rs.getString(2);

flight= new Flight(id, num);

flights.add(flight);

}

}catch (SQLException e) {

e.printStackTrace();

}finally {

ConnectionUtils.closeResultSet(rs);

ConnectionUtils.closeStatement(pStmt);

ConnectionUtils.closeConnection(conn);

}

returnflights;

}

publicstatic void main(String[] args) throws Exception {

List<Flight>ff = new FlightDaoImplForMySQL().

listPagesNewsDB(2,3,

ConnectionUtils.openConnection());

for(Flightf:ff){

System.out.println(“==”+f.getId()+”=”+f.getNum()+”==”);

}

}

}

——————————————————————————-

17、JDBC，Hibernate分页怎样实现？

答：方法分别为：

1)Hibernate 的分页：

Queryquery = session.createQuery(“from Student”);

query.setFirstResult(firstResult);//设置每页开始的记录号

query.setMaxResults(resultNumber);//设置每页显示的记录数

Collectionstudents = query.list();

2)JDBC 的分页：根据不同的数据库采用不同的sql 分页语句

例如: Oracle 中的sql 语句为:“SELECT * FROM (SELECT a.*, rownum r FROM

TB_STUDENT)WHERE r between 2 and 10″ 查询从记录号2 到记录号10 之间的所有记录

42、用你熟悉的语言写一个连接ORACLE数据库的程序,能够完成修改和查询工作。 答：JDBC示例程序

如下： public void testJdbc(){

Connectioncon = null;

PreparedStatementps = null;

ResultSetrs = null;

try{

//step1：注册驱动；

Class.forName(“oracle.jdbc.driver.OracleDriver”);

//step2：获取数据库连接；

con=DriverManager.getConnection(

“jdbc:oracle:thin:@192.168.0.23:1521:tarena”,“openlab”,”open123″);

/************************查 询************************/

//step3：创建Statement；

Stringsql = “SELECT id, fname, lname, age, FROM Person_Tbl”; ps =con.prepareStatement(sql);

//step4 ：执行查询语句，获取结果集；

rs= ps.executeQuery();

//step5：处理结果集—输出结果集中保存的查询结果；

while(rs.next()){

System.out.print(“id= ” + rs.getLong(“id”));

System.out.print(”, fname = ” + rs.getString(“fname”));

System.out.print(”, lname = ” + rs.getString(“lname”));

System.out.print(”, age = ” + rs.getInt(“age”)); }

/************************JDBC修 改*********************/

sql= “UPDATE Person_Tbl SET age=23 WHERE id = ?”; ps = con.prepareStatement(sql);

ps.setLong(1,88);

introws = ps.executeUpdate();

System.out.println(rows+ ” rows affected.”);

}catch (Exception e){

e.printStackTrace();

}finally{

try{

//关闭数据库连接，以释放资源。

con.close();

}catch (Exception e1) {

E1.printStackTrace();

}} }

31、Statement,PreparedStatement,CallableStatment的区别

答： 区别有以下几点： 1） Statement是PreparedStatement和CallableStatement的父类； 2）Statement是直接发送Sql语句到数据库，事先没有进行预编译。

PreparedStatement会将sql进行预编译，当sql语句要重复执行时，数据库会调用以前预编译好的sql语句，所以PreparedStatement在性能方面会更好；

3）PreparedStatement在执行sql时，对传入的参数可以进行强制的类型转换。以保证数据格式与底层的数据库格式一致。

4）CallableStatement 适用与存储过程的查询表达语句

aop称为是面向切面编程，那么对它最好的解释就是拦截器了，而他的aop原理呢就是：在执行某些代码之前执行另外的代码，是程序变的灵活，扩展性更灵活，可以随意的删除和添加某些功能！你可以参照filter过滤器，其实filter就是一个很好的对aop的解释

AOP是OOP的延续，是（AspectOriented Programming）的缩写，意思是面向切面编程。

主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。

主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。

可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务 （transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级 关注点，例如日志或事务支持。可以更好的将本来不应该粘合在一起的功能分离开。

1.定义切入点：spring根据需要织入通知的类和方法来定义切入点

通知是根据他们的特性织入目标类和方法的，如类名和方法名

2.静态切入点：spring为创建静态切入点提供了方便的父类–StaticMethodMatcherPointcut。

1）要创建自制的静态切入点，只需要继承这个类，实现isMatch()方法

2）当被调用方法的名字与给出的映射名字匹配时，切入点才匹配

3）使用明确的方法名，也可以在名字的起始和结束处使用通配符*。

84、在web应用开发过程中经常遇到输出某种编码的字符，如从GBK到iso8859-1等，如何输出一个某种编码的字符串？

答：public static String translate(String str) {

StringtempStr = “”;

try{

tempStr= new String(str.getBytes(“GBK”), “ISO-8859-1″);

tempStr= tempStr.trim();

}catch (Exception e) {

System.err.println(e.getMessage());}

returntempStr; }

作用域 当前类 同包 子类 其它

public√ √ √ √

protected√ √ √ ×

private√ × × ×

计算日期

DateFormatdf =new SimpleDateFormat( “yyyy-MM-dd “);

String d =“2005-11-26 “;

Calendarc = Calendar.getInstance();

c.setTime(df.parse(d));

//System.out.println(c.get(Calendar.WEEK_OF_MONTH));

System.out.println(c.get(Calendar.DAY_OF_WEEK));

sturts与jsp结合

struts2中的Action接收表单传递过来的参数有3种方法：

如，登陆表单login.jsp：

<formaction=”login” method=”post” name=”form1″>

用户名：<s:textfield name=”username”/><br/>

密 码：<s:password name=”password”/><br/>

<s:submitvalue=”提交”/>

</form>

1.在Action类中定义表单属性，两者属性名称必须一致。提供setter，getter方法。即可接收到表单传过来的参数.

这种接收参数的方法，方便简单，但是结构性不是很好，且当表单传递来的参数很多的时候，整个Action类中充斥着setter，getter方法，程序结构不是很美观。

2.把表单传递过来的参数封装成一个类，然后调用其中的属性.

如，把login.jsp页面要传来的参数进行封装

privateString username;

privateString password;

publicString getUsername() {

returnusername;

}

publicvoid setUsername(String username) {

this.username= username;

}

publicString getPassword() {

returnpassword;

}

publicvoid setPassword(String password) {

this.password= password;

}

然后再Action方法中，定义该类的对象就可以了，如

publicclass loginAction extends ActionSupport{

privateUsers users;

publicUsers getUsers(){

returnusers;

}

publicvoid setUsers(Users users){

this.users=users;

}

/*

传递过来的参数都封装在users中了，用getter方法取值就可以了

*/

}

通过这种方法传值，还必须在jsp页面做一下处理，login.jsp中from1的属性名应该改成这样：

登陆表单login.jsp：

<formaction=”login” method=”post” name=”form1″>

用户名：<s:textfield name=”users.username”/><br/>

密 码：<s:password name=”users.password”/><br/>

<s:submitvalue=”提交”/>

</form>

这种方法，在struts开发中是很常用的一种方法！

3.通过实现ModelDriven接口接收表单数据

首先Action类必须实现ModelDriven接口，同样把表单传来的数据封装起来，Action类中必须实例化该对象，并且要重写getModel()方法

publicclass loginAction extends ActionSupport implements ModelDriven<Users>{

privateUsers users =new Users();

publicUsers getModel(){

returnusers;

}

/*

表单传来的参数封装在users对象中

表单属性名不需要加上引用users对象，直接传参数名

*/

}

hibernate与jdbc优缺点

1.hibernate和jdbc主要区别就是，hibernate先检索缓存中的映射对象( 即hibernate操作的是对象)，而jdbc则是直接操作数据库.

2.Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架，和App Server，和EJB没有什么必然的联系。Hibernate可以用在任何JDBC可以使用的场合

3.Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系，但是和使用它的Java程序，和App Server没有任何关系，也不存在兼容性问题。

还有一点,正确的使用JDBC技术,它的效率一定比hibernate要好,因为hibernate是基于jdbc的技术.

hibernate是jdbc的轻量级封装，包括jdbc的与数据库的连接（用hibernate.property的配置文件实现当然本质是封装了jdbc的forname），和查询，删除等代码，都用面向对象的思想用代码联系起来，hibernate通过hbm 配置文件把po类的字段和数据库的字段关联起来比如数据库的id,在po类中就是praviteLong id;

publicLong getId()

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

数据库优化

设计数据库的优化措施。这要看你对预期的数据量的一个估计，不同的数据量有不同的策略。100万数据的表和1亿的数据表的策略肯定是不一样的。同样的设计，查询语句不一样，效果可能也不一样。

比较常用的数据库设计方面的处理措施是，

1、索引的建立，一张表，如果有一些经常查询的字段上，要建立索引。比如库存表，你会经常按厂家查询，那么在厂家这个字段上就要建立索引。如楼上所说，在某些时刻，要采取违反第3范式的一些数据库设计手段。

2、分库，分表技术。可以按业务层次，或者日期、厂家、地区等字段，对表进行横向或纵向的分割。把事务表和数据仓库表分开等。

3、事实上，对于系统的优化，从数据库本身的优化，数据库表的设计，以及应用程序的设计上，关联是很密切的。比如在数据库，可以把临时表，或者一些日志类的表放在内存盘中。在程序设计上，采用缓存机制，分布式数据库机制等等，都是提高系统响应能力的方法。

数据库的优化和你的业务、流量、硬件是分不开的

业务：主要指查询的方式，读写权重，表大小

流量：主要考虑并发请求数

硬件：主要是内存、磁盘、CPU的环境

从业务角度讲：

简单查询只需要对查询条件的列建立索引

需要排序的查询就应该使用符合索引，使排序从文件系统转移到内存中

读写要考虑效率和锁的问题，如果两方面都比较突出，可以考虑建立主从，主服务器做写操作，从服务器做读，读的压力大，可以建立多个从

表的大小直接影响查询效率，单个表的数据量有几十万效率就很低了，可以考虑hash分表，利用表中的某个比较符合业务的字段做分表

如业务需要处理订单之类，需要完整的处理过程，应该选择带有事务处理的存储引擎，如mysql 的 innodb

从流量角度讲：

最主要的是选择适合的存储引擎，mysql的myisam的表级锁会对引擎适合并发较低的环境，但查询速度较快，随着并发的增加，效率支线下降，innodb的行级锁查询速度没有myisam快，但是极大的减少了锁，是并发的效率大大增加，对高并发的环境是不二选择

从硬件角度讲：

内存要合理分配，尤其是事务型的存储引擎，建议内存从小到大的逐渐调整，过大的使用内存会导致使用swap

磁盘的io通常是数据库的主要瓶颈，在你表设计已经比较合理的情况下，io效率依然低下，可以考虑分磁盘存储数据，最好可以使用raid负载磁盘阵列，用多个磁盘分担io的压力

这个年代没有人用单核的处理器，所以多核处理器是最佳选择

总的来说数据库的优化由sql、内存、磁盘IO、表结构、存储引擎等几个主要方面，优化是个过程，没有标准，具体问题具体分析

很多核心Java面试题来源于多线程(Multi-Threading)和集合框架(Collections Framework)，理解核心线程概念时，娴熟的实际经验是必需的。这篇文章收集了 Java 线程方面一些典型的问题，这些问题经常被高级工程师所问到。
0.Java 中多线程同步是什么？
在多线程程序下，同步能控制对共享资源的访问。如果没有同步，当一个 Java 线程在修改一个共享变量时，另外一个线程正在使用或者更新同一个变量，这样容易导致程序出现错误的结果。
1.解释实现多线程的几种方法?
一 Java 线程可以实现 Runnable 接口或者继承 Thread 类来实现，当你打算多重继承时，优先选择实现 Runnable。
2.Thread.start ()与 Thread.run ()有什么区别？
Thread.start ()方法(native)启动线程，使之进入就绪状态，当 cpu 分配时间该线程时，由 JVM 调度执行 run ()方法。3.为什么需要run ()和start ()方法，我们可以只用 run ()方法来完成任务吗？
我们需要 run ()&start ()这两个方法是因为JVM 创建一个单独的线程不同于普通方法的调用，所以这项工作由线程的 start 方法来完成，start 由本地方法实现，需要显示地被调用，使用这俩个方法的另外一个好处是任何一个对象都可以作为线程运行，只要实现了 Runnable 接口，这就避免因继承了 Thread 类而造成的 Java 的多继承问题。
4.什么是 ThreadLocal 类，怎么使用它？
ThreadLocal 是一个线程级别的局部变量，并非“本地线程”。ThreadLocal 为每个使用该变量的线程提供了一个独立的变量副本，每个线程修改副本时不影响其它线程对象的副本(译者注)。
下面是线程局部变量(ThreadLocal variables)的关键点：
一个线程局部变量(ThreadLocal variables)为每个线程方便地提供了一个单独的变量。
ThreadLocal 实例通常作为静态的私有的(private static)字段出现在一个类中，这个类用来关联一个线程。
当多个线程访问 ThreadLocal 实例时，每个线程维护ThreadLocal提供的独立的变量副本。
常用的使用可在 DAO 模式中见到，当 DAO 类作为一个单例类时，数据库链接(connection)被每一个线程独立的维护，互不影响。(基于线程的单例)
ThreadLocal 难于理解，下面这些引用连接有助于你更好的理解它。
《Good article on ThreadLocal on IBM DeveloperWorks 》、《理解 ThreadLocal》、《Managing data: Good example》、《Refer Java API Docs》
5.什么时候抛出 InvalidMonitorStateException 异常，为什么？
调 用 wait ()/notify ()/notifyAll ()中的任何一个方法时，如果当前线程没有获得该对象的锁，那么就会抛出 IllegalMonitorStateException 的异常(也就是说程序在没有执行对象的任何同步块或者同步方法时，仍然尝试调用 wait ()/notify ()/notifyAll ()时)。由于该异常是 RuntimeExcpetion 的子类，所以该异常不一定要捕获(尽管你可以捕获只要你愿意).作为 RuntimeException，此类异常不会在 wait (),notify (),notifyAll ()的方法签名提及。
6.Sleep ()、suspend ()和 wait ()之间有什么区别？
Thread.sleep ()使当前线程在指定的时间处于“非运行”（Not Runnable）状态。线程一直持有对象的监视器。比如一个线程当前在一个同步块或同步方法中，其它线程不能进入该块或方法中。如果另一线程调用了 interrupt ()方法，它将唤醒那个“睡眠的”线程。
注意：sleep ()是一个静态方法。这意味着只对当前线程有效，一个常见的错误是调用t.sleep ()，（这里的t是一个不同于当前线程的线程）。即便是执行t.sleep ()，也是当前线程进入睡眠，而不是t线程。t.suspend ()是过时的方法，使用 suspend ()导致线程进入停滞状态，该线程会一直持有对象的监视器，suspend ()容易引起死锁问题。
object.wait ()使当前线程出于“不可运行”状态，和 sleep ()不同的是wait 是object 的方法而不是 thread。调用object.wait ()时，线程先要获取这个对象的对象锁，当前线程必须在锁对象保持同步，把当前线程添加到等待队列中，随后另一线程可以同步同一个对象锁来调用 object.notify ()，这样将唤醒原来等待中的线程，然后释放该锁。基本上wait()/notify ()与 sleep ()/interrupt ()类似，只是前者需要获取对象锁。
7.在静态方法上使用同步时会发生什么事？
同步静态方法时会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。
8.当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？
可 以，一个非同步方法总是可以被调用而不会有任何问题。实际上，Java 没有为非同步方法做任何检查，锁对象仅仅在同步方法或者同步代码块中检查。如果一个方法没有声明为同步，即使你在使用共享数据 Java 照样会调用，而不会做检查是否安全，所以在这种情况下要特别小心。一个方法是否声明为同步取决于临界区访问(critial section access)，如果方法不访问临界区(共享资源或者数据结构)就没必要声明为同步的。