助你快速踏入高薪职场——2017面试集锦之java基础（二）

       这套面试题主要目的是帮助那些还没有 java 软件开发实际工作经验，而正在努力寻找 java软件开发工作的朋友在笔试时更好地赢得笔试和面试。 由于这套面试题涉及的范围很泛， 很广， 很杂， 大家不可能一天两天就看完和学完这套面试宝典， 即使你已经学过了有关的技术，那么至少也需要一个月的时间才能消化和掌握这套面试宝典，所以，大家应该早作准备，从拿到这套面试宝典之日起，就要坚持在每天闲暇之余学习其中几道题目，日积月累，等到出去面试时，一切都水到渠成，面试时就自然会游刃有余了。答题时，先答是什么，再答有什么作用和要注意什么（这部分最重要，展现自己的心得）答案的段落分别，层次分明，条理清晰都非常重要，从这些表面的东西也可以看出一个人的习惯、办事风格、条理等。要讲你做出答案的思路过程，或者说你记住答案的思想都写下来。把答题想着是辩论赛。答题就是给别人讲道理、摆事实。答题不局限于什么格式和形式，就是要将自己的学识展现出来！别因为人家题目本来就模棱两可，你就心里胆怯和没底气了，不敢回答了。你要大胆地指出对方题目很模糊和你的观点， 不要把面试官想得有多高， 其实他和你就是差不多的， 你想想，如果他把你招进去了，你们以后就是同事了，可不是差不多的吗？关于就业薪水，如果你是应届生，那不能要高工资，好比大饼的故事，没有文凭还想拿高工资，就去中关村缺什么补什么吧！少数人基础确实很好，在校期间确实又做过一些项目，那仍然是可以要到相对高的工资的。

1、一个".java"源文件中是否可以包括多个类（不是内部类）？有什么限制？
2、Java 有没有 goto? 
3、说说&和&&的区别。
4、在 JAVA 中如何跳出当前的多重嵌套循环？
5、switch 语句能否作用在 byte 上，能否作用在 long 上，能否作用在 String 上? 
6、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?
7、char 型变量中能不能存贮一个中文汉字?为什么? 
8、用最有效率的方法算出 2 乘以 8 等于几? 
9、请设计一个一百亿的计算器
10、使用 final 关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？ 
11、"=="和 equals 方法究竟有什么区别？
12、静态变量和实例变量的区别？
13、是否可以从一个 static 方法内部发出对非 static 方法的调用？ 
14、Integer 与 int 的区别
15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
16、下面的代码有什么不妥之处?
17、请说出作用域 public，private，protected，以及不写时的区别 
18、Overload 和 Override 的区别。Overloaded 的方法是否可以改变返回值的类型?
19、构造器 Constructor 是否可被 override? 
20、 接口是否可继承接口?抽象类是否可实现(implements)接口?抽象类是否可继承具体类(concrete class)?抽象类中是否可以有静态的 main 方法？
21、写 clone()方法时，通常都有一行代码，是什么？
22、面向对象的特征有哪些方面
23、java 中实现多态的机制是什么？
24、abstract class 和 interface 有什么区别?
25、abstract 的 method 是否可同时是 static,是否可同时是 native，是否可同时是synchronized? 
26、什么是内部类？Static Nested Class 和 Inner Class 的不同。 
27、内部类可以引用它的包含类的成员吗？有没有什么限制？(27以上请看上一篇) 
28、Anonymous Inner Class (匿名内部类)是否可以 extends(继承)其它类，是否可以implements(实现)interface(接口)?
29、super.getClass()方法调用
30、String 是最基本的数据类型吗?
31、String s = "Hello";s = s + " world!";这两行代码执行后，原始的 String 对象中的内容到底变了没有？
32、是否可以继承 String 类?
33、String s = new String("xyz");创建了几个 String Object?二者之间有什么区别？
34、String 和 StringBuffer 的区别
35、如何把一段逗号分割的字符串转换成一个数组? 
36、数组有没有 length()这个方法? String 有没有 length()这个方法？
37、下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";
38、try {}里有一个 return 语句，那么紧跟在这个 try 后的 finally {}里的 code 会不会被执行，什么时候被执行，在 return 前还是后? 
39、下面的程序代码输出的结果是多少？
40、final, finally, finalize 的区别。 
41、运行时异常与一般异常有何异同？
42、error 和 exception 有什么区别?
43、Java 中的异常处理机制的简单原理和应用。
44、请写出你最常见到的 5 个 runtime exception。
45、JAVA 语言如何进行异常处理，关键字：throws,throw,try,catch,finally 分别代表什么意义？在 try 块中可以抛出异常吗？
46、java 中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和
suspend()方法为何不推荐使用？
47、sleep()和 wait()有什么区别? 
48、同步和异步有何异同，在什么情况下分别使用他们？举例说明。 
49. 下面两个方法同步吗？（自己发明）
50、多线程有几种实现方法?同步有几种实现方法? 
51、启动一个线程是用 run()还是 start()?
52、当一个线程进入一个对象的一个 synchronized 方法后，其它线程是否可进入此对象的其它方法?（52之后请看下一篇）
53、线程的基本概念、线程的基本状态以及状态之间的关系 
54、简述 synchronized 和 java.util.concurrent.locks.Lock 的异同？
55、设计 4 个线程，其中两个线程每次对 j 增加 1，另外两个线程对 j 每次减少 1。写出程序。
56、子线程循环 10 次，接着主线程循环 100，接着又回到子线程循环 10 次，接着再回到主线程又循环 100，如此循环 50 次，请写出程序。
57、介绍 Collection 框架的结构 
58、Collection 框架中实现比较要实现什么接口 
59、ArrayList 和 Vector 的区别 
60、HashMap 和 Hashtable 的区别 
61、List 和 Map 区别? 
62、List, Set, Map 是否继承自 Collection 接口?
63、List、Map、Set 三个接口，存取元素时，各有什么特点？
64、说出 ArrayList,Vector, LinkedList 的存储性能和特性 
65、去掉一个 Vector 集合中重复的元素
66、Collection 和 Collections 的区别。 
67、Set 里的元素是不能重复的，那么用什么方法来区分重复与否呢?是用==还是
equals()?它们有何区别? 
68、你所知道的集合类都有哪些？主要方法？
69、两个对象值相同(x.equals(y) == true)，但却可有不同的 hash code，这句话对不对? 
70、TreeSet 里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的 compareTo 方法，还是使用的子类的 compareTo 方法，还是抛异常！ 
71、说出一些常用的类，包，接口，请各举 5 个
72、java 中有几种类型的流？JDK 为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？
73、字节流与字符流的区别
74、什么是 java 序列化，如何实现 java 序列化？或者请解释 Serializable 接口的作用。
75、描述一下 JVM 加载 class 文件的原理机制? 
76、heap 和 stack 有什么区别。
77、GC 是什么?为什么要有 GC? 
78、垃圾回收的优点和原理。并考虑 2 种回收机制。
79、 垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？
80、什么时候用 assert。
81、java 中会存在内存泄漏吗，请简单描述。
82、能不能自己写个类，也叫 java.lang.String？ 
83. Java 代码查错 

基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法， 异常的语法，线程的语法，集合的语法，io 的语法，虚拟机方面的语法。

27、内 、内部类可以引用它的包含类的成员吗？有没有什么限制？ 部类可以引用它的包含类的成员吗？有没有什么限制？
       完全可以。如果不是静态内部类，那没有什么限制！如果你把静态嵌套类当作内部类的一种特例， 那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如，下面的代码：
class Outer
{
static int x;
static class Inner
{
void test()
{
syso(x);
}
}
}
       答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让人家满意，然后再说特殊情况，让人家吃惊。

28 、Anonymous Inner Class ( 匿名内部类) 是否可以 extends( 继承)其它类， 其它类，是否可以 是否可以implements( 实现)interface( 接口)?
       可以继承其他类或实现其他接口。不仅是可以，而是必须!

29 、super.getClass() 方法调用
      下面程序的输出结果是多少？
importjava.util.Date;
public class Test extends Date{
public static void main(String[] args) {
new Test().test();
}
public void test(){
System.out.println(super.getClass().getName());
}
}
       很奇怪，结果是 Test
       这属于脑筋急转弯的题目，在一个 qq 群有个网友正好问过这个问题，我觉得挺有趣，就研究了一下，没想到今天还被你面到了，哈哈。在 test 方法中，直接调用 getClass().getName()方法，返回的是 Test 类名由于 getClass()在 Object 类中定义成了 final，子类不能覆盖该方法，所以，在test 方法中调用 getClass().getName()方法， 其实就是在调用从父类继承的 getClass()方法，等效于调用 super.getClass().getName()方法，所以super.getClass().getName()方法返回的也应该是 Test。如果想得到父类的名称，应该用如下代码：getClass().getSuperClass().getName();

30 、String  是最基本的数据类型吗?
       基本数据类型包括 byte、int、char、long、float、double、boolean 和 short。java.lang.String 类是 final 类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用 StringBuffer 类。

31 、String s = "Hello";s = s + " world!"; 这两行代码执行后，原始的 String对象中的内容到底变了没有？ 
        没有。因为 String 被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s 原先指向一个 String 对象，内容是 "Hello"，然后我们对 s 进行了+操作，那么 s 所指向的那个对象是否发生了改变呢？答案是没有。这时，s 不指向原来那个对象了，而指向了另一个 String 对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是 s 这个引用变量不再指向它了。通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用 String 来代表字符串的话会引起很大的内存开销。因为
String 对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个 String 对象来表示。这时，应该考虑使用 StringBuffer 类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都 new 一个 String。例如我们要在构造器中对一个名叫 s 的 String 引用变量进行初始化，把它设置为初始值，应当这样做：
public class Demo {
private String s;
...
public Demo {
s = "Initial Value";
}
...
}
       而非
s = new String("Initial Value");
       后者每次都会调用构造器， 生成新对象， 性能低下且内存开销大， 并且没有意义， 因为 String对象不可改变，所以对于内容相同的字符串，只要一个 String 对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的 String 类型属性 s 都指向同一个对象。上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java 认为它们代表同一个 String 对象。而用关键字 new 调用构造器，总是会创建一个新的对象，无论内容是否
相同。至于为什么要把 String 类设计成不可变类， 是它的用途决定的。 其实不只 String， 很多 Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以 Java 标准类库还提供了一个可
变版本，即 StringBuffer。

32 、是否可以继承 String  类?
       String 类是 final 类故不可以继承。

33 、String s = new String("xyz"); 创建了几个 String Object?二者之间有什么 二者之间有什么区别？
       两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String 每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新 String 对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

34 、String 和 和 StringBuffer  的区别
      JAVA 平台提供了两个类：String 和 StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个 String 类提供了数值不可改变的字符串。而这个 StringBuffer 类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用 StringBuffer。典型地，你可以使用 StringBuffers 来动态构造字符数据。另外，String 实现了 equals 方法，new String(“abc”).equals(newString(“abc”)的结果为 true,而 StringBuffer 没有实现equals 方法，所以，new StringBuffer(“abc”).equals(newStringBuffer(“abc”)的结果为 false。接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。
StringBuffer sbf = new StringBuffer();
for(int i=0;i<100;i++)
{
sbf.append(i);
}
     上面的代码效率很高，因为只创建了一个 StringBuffer 对象，而下面的代码效率很低，因为创建了101个对象。
String str = new String();
for(int i=0;i<100;i++)
{
str = str + i;
}
       在讲两者区别时，应把循环的次数搞成10000，然后用 endTime-beginTime 来比较两者执行的时间差异，最后还要讲讲 StringBuilder 与 StringBuffer 的区别。String 覆盖了 equals 方法和 hashCode 方法，而 StringBuffer 没有覆盖 equals 方法和hashCode 方法，所以，将 StringBuffer  对象存储进 Java  集合类中时会出现问题。

35 、如何把一段逗号分割的字符串转换成一个数组?
       如果不查 jdk api，我很难写出来！我可以说说我的思路：
       1  用正则表达式，代码大概为：String [] result = orgStr.split(“,”);
        2  用 StingTokenizer ,代码为：StringTokenizer tokener =StringTokenizer(orgStr,”,”);
                                                         String [] result =new String[tokener .countTokens()];
                                                         Int i=0;
                                                          while(tokener.hasNext(){

                                                                  result[i++]=toker.nextToken();}

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

37 、下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";
       答：对于如下代码：
       String s1 = "a";
       String s2 = s1 + "b";
       String s3 = "a" + "b";
       System.out.println(s2 == "ab");
       System.out.println(s3 == "ab");
       第一条语句打印的结果为 false，第二条语句打印的结果为 true，这说明 javac 编译可以对字符串常量直接相加的表达式进行优化， 不必要等到运行期去进行加法运算处理， 而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个”abcd”的字符串，所以，上面的代码应该只创建了一个 String 对象。写如下两行代码，
      String s ="a" + "b" + "c" + "d";
      System.out.println(s== "abcd");
      最终打印的结果应该为 true。

38 、try {} 里有一个 return 语句，那么 语句，那么紧跟在这个 紧跟在这个 try  后的 finally {} 里的 code会不会被执行，什么时候被执行，在 会不会被执行，什么时候被执行，在 return  前还是后?
       也许你的答案是在 return 之前，但往更细地说，我的答案是在 return 中间执行，请看下面
       程序代码的运行结果：
public classTest {
/**
* @paramargs add by zxx ,Dec 9, 2008
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out. println (new Test().test());;
}
static int test()
{
int x = 1;
try
{
Return x;
}
finally
{
++x;
}
}
}
        ---------执行结果 ---------
        1
       运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。

39 、下面的程序代码输出的结果是多少？
public class smallT
{
public static void main(String args[])
{
smallT t = new smallT();
int b = t.get();
System.out.println(b);
}
public int get()
{
try
{
Return 1 ;
}
finally
{
Return 2 ;
}
}
}
        返回的结果是2。我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，try 中的 return 语句调用的函数先于 finally 中调用的函数执行， 也就是说 return 语句先执行，finally 语句后执行，所以，返回的结果是2。Return 并不是让函数马上返回，而是 return 语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行 finally 语句后才真正开始返回。在讲解答案时可以用下面的程序来帮助分析：
public classTest {
/**
* @paramargs add by zxx ,Dec 9, 2008
*/
public static voidmain(String[] args) {
// TODO Auto-generated method stub
System.out.println(newTest().test());;
}
int test()
{
try
{
return func1();
}
finally
{
return func2();
}
}
int func1()
{
System.out.println("func1");
return 1;
}
int func2()
{
System.out.println("func2");
return 2;
}
}
        -----------执行结果-----------------
        func1
        func2
        2
        结论：finally 中的代码比 return 和 break 语句后执行

40 、final, finally, finalize  的区别。
       final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。内部类要访问局部变量，局部变量必须定义成 final 类型，例如，一段代码……；finally 是异常处理语句结构的一部分，表示总是执行。finalize 是 Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM 不保证此方法总被调用。

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

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

43 、Java  中的异常处理机制的简单原理和应用。
       异常是指 java 程序运行时（非编译）所发生的非正常情况或错误，与现实生活中的事件很相似，现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息，可以用一个对象来表示，Java 使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。Java 对异常进行了分类，不同类型的异常分别用不同的 Java 类表示，所有异常的根类为java.lang.Throwable，Throwable 下面又派生了两个子类：Error 和 Exception，Error 表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception 表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常， 系统异常是软件本身缺陷所导致的问题， 也就是软件开发人员考虑不周所导致的问题， 软件使用者无法克服和恢复这种问题， 但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException）,空指针异常（NullPointerException）、类转换异常（ClassCastException） ；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。java 为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须 try..catch 处理或用 throws 声明继续抛给上层调用方法处理，所以普通异常也称为 checked 异常，而系统异常可以处理也可以不处理，所以，编译器不强制用 try..catch 处理或用 throws 声明，所以系统异常也称为 unchecked 异常。提示答题者：就按照三个级别去思考：虚拟机必须宕机的错误，程序可以死掉也可以不死掉的错误，程序不应该死掉的错误；

44、请写出 、请写出你最常见到的 你最常见到的 5 个 个 runtime exception 。
       这道题主要考你的代码量到底多大， 如果你长期写代码的， 应该经常都看到过一些系统方面的异常，你不一定真要回答出5个具体的系统异常，但你要能够说出什么是系统异常，以及几个系统异常就可以了， 当然， 这些异常完全用其英文名称来写是最好的， 如果实在写不出，那就用中文吧，有总比没有强！所谓系统异常，就是…..，它们都是 RuntimeException 的子类，在 jdk doc 中查RuntimeException 类，就可以看到其所有的子类列表，也就是看到了所有的系统异常。我比较有印象的系统异常有：NullPointerException、ArrayIndexOutOfBoundsException、
ClassCastException。

45 、JAVA  语言如何进行异常处理，关键字：throws,throw,try,catch,finally 分别代表什么意义？在 别代表什么意义？在 try  块中可以抛出异常吗？
       throws 捕获并向外抛出异常
       throw 抛出异常
       try catch 是内部捕获异常并做自定义处理
       finally 是无论是否有异常都会被处理的语句，除非在 finally 前存在被执行的
       System.exit(int i)时除外

46、 、 java  中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()
和 和 suspend() 方法为何不推荐使用？
       java5以前，有如下两种：
       第一种：
       new Thread(){}.start();这表示调用 Thread 子类对象的 run 方法，new Thread(){}表示一个Thread 的匿名子类的实例对象，子类加上 run 方法后的代码如下：
new Thread(){
public void run(){
}
}.start();
       第二种：
new Thread(new Runnable(){}).start();这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个 Runnable 的匿名子类的实例对象,runnable 的子类加上run 方法后的代码如下：
new Thread(new Runnable(){
public voidrun(){
}
}
).start();
      从 java5开始，还有如下一些线程池创建多线程的方式：
ExecutorService pool = Executors.newFixedThreadPool(3)
for(int i=0;i<10;i++)
{
pool.execute(newRunable(){public void run(){}});
}
Executors.newCachedThreadPool().execute(new Runable(){publicvoid run(){}});
Executors.newSingleThreadExecutor().execute(new Runable(){publicvoid run(){}});
       有两种实现方法，分别使用 new Thread()和 new Thread(runnable)形式，第一种直接调用thread 的 run 方法，所以，我们往往使用 Thread 子类，即 new SubThread()。第二种调用runnable 的 run 方法。
      有两种实现方法，分别是继承 Thread 类与实现 Runnable 接口;
      用 synchronized 关键字修饰同步方法;反对使用 stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态， 那么其他线程能在那种状态下检查和修改它们。 结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用 suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用 suspend()，而应在自己的 Thread 类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用 wait()命其进入等待状态。若标志指出线程应当恢复，则用一个 notify()重新启动线程。

47 、sleep() 和 wait() 有什么区别?
     （网上的答案：sleep 是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用 sleep 不会释放对象锁。 wait 是 Object 类的方法，对此对象调用 wait 方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出 notify 方法（或 notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。 ）
       sleep 就是正在执行的线程主动让出 cpu，cpu 去执行其他线程，在 sleep 指定的时间过后，cpu 才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep 方法并不会释放锁，即使当前线程使用 sleep 方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait 是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了 notify 方法（notify 并不释放锁，只是告诉调用过 wait 方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果 notify 方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在 notfiy 方法后增加一个等待和一些代码，看看效果） ，调用 wait方法的线程就会解除 wait 状态和程序可以再次得到锁后继续向下运行。对于 wait 的讲解一定要配合例子代码来说明，才显得自己真明白。
package com.huawei.interview;
publicclass MultiThread {
/**
* @paramargs
*/
public static voidmain(String[] args) {
// TODO Auto-generated method stub
new Thread(newThread1()).start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catchblock
e.printStackTrace();
}
new Thread(newThread2()).start();
}
private static classThread1implements Runnable
{
@Override
public void run() {
// TODO Auto-generated methodstub
//由于这里的 Thread1和下面的 Thread2内部 run 方法要用同一对象作为监视器，我们这里不能用 this，因为在 Thread2里面的 this 和这个 Thread1的 this 不是同一个对象。我们用MultiThread.class 这个字节码对象，当前虚拟机里引用这个变量时，指向的都是同一个对象。
synchronized (MultiThread.class){
System.out.println("enterthread1...");
System.out.println("thread1is waiting");
try {
//释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了 synchronized 关键字管辖的代码范围， 另一种方式就是在 synchronized 关键字管辖的代码内部调用监视器对象的 wait 方法。这里，使用 wait 方法释放锁。
MultiThread.class.wait();
} catch(InterruptedException e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
}
System.out.println("thread1is going on...");
System.out.println("thread1is being over!");
}
}
}
private static classThread2implements Runnable
{
@Override
public void run() {
// TODO Auto-generated methodstub
synchronized (MultiThread.class){
System.out.println("enterthread2...");
System.out.println("thread2notify other thread can release wait status..");
//由于 notify 方法并不释放锁， 即使 thread2调用下面的 sleep 方法休息了10毫秒， 但 thread1仍然不会执行，因为 thread2没有释放锁，所以 Thread1无法得不到锁。
MultiThread.class.notify();
System.out.println("thread2is sleeping ten millisecond...");
try {
Thread.sleep(10);
} catch (InterruptedExceptione) {
// TODO Auto-generatedcatch block
e.printStackTrace();
}
System.out.println("thread2is going on...");
System.out.println("thread2is being over!");
}
}
}
}

48 、同步和异步有何异同，在什么情况下分别使用他们？举例说明。
       如果数据将在线程间共享。 例如正在写的数据以后可能被另一个线程读到， 或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。当应用程序在对象上调用了一个需要花费很长时间来执行的方法， 并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。

49.  下面两个方法同步吗？（自己发明）
class Test
{
synchronizedstatic void say Hello3()
{
}
synchronizedvoid getX(){}
}

50 、多线程有几种实现方法? 同步有几种实现方法?
       多线程有两种实现方法，分别是继承 Thread 类与实现 Runnable 接口
       同步的实现方面有两种，分别是 synchronized,wait 与 notify
       wait():使一个线程处于等待状态，并且释放所持有的对象的 lock。
       sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉
       InterruptedException(中断异常)异常。
       notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由 JVM 确定唤醒哪个线程，而且不是按优先级。
       Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

51 、启动一个线程是用 run() 还是 start()? .
       启动一个线程是调用 start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。

52、当一个线程进入一个对象的 、当一个线程进入一个对象的一个 一个 synchronized 方法后，其它线程是否可 方法后，其它线程是否可进入此对象的其它方法 进入此对象的其它方法?
       分几种情况：
       1. 其他方法前是否加了 synchronized 关键字，如果没加，则能。
       2. 如果这个方法内部调用了 wait，则可以进入其他 synchronized 方法。
       3. 如果其他个方法都加了 synchronized 关键字，并且内部没有调用 wait，则不能。
       4. 如果其他方法是 static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是 this。