Java面试题集（一）答案汇总（1-22）

java基础篇：

1.1、Java基础

（1）面向对象的特性：继承、封装和多态

以下都是查阅大神的博客后，摘录的内容：来源http://www.cnblogs.com/chenssy
　　1.继承
　　继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，
　　但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码，能够大大的提高开发
　　继承定义了类如何相互关联，共享特性。对于若干个相同或者相识的类，我们可以抽象出他们共有的行为或者属相并将其定
　　义成一个父类或者超类，然后用这些类继承该父类，他们不仅可以拥有父类的属性、方法还可以定义自己独有的属性或者方法。
　　同时在使用继承时需要记住三句话：
　　　　1、子类拥有父类非private的属性和方法。
　　　　2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
　　　　3、子类可以用自己的方式实现父类的方法。

　　此外 我们需要明确，继承存在如下缺陷：
　　　　1、父类变，子类就必须变。
　　　　2、继承破坏了封装，对于父类而言，它的实现细节对与子类来说都是透明的。
　　　　3、继承是一种强耦合关系。

　　2.封装

　　封装从字面上来理解就是包装的意思，专业点就是信息隐藏，是指利用抽象数据类型将数据和基于数据的操作封装在一起，使
　　其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外
　　部发生联系。系统的其他对象只能通过包裹在数据外面的已经授权的操作来与这个封装的对象进行交流和交互。也就是说用户是
　　无需知道对象内部的细节（当然也无从知道），但可以通过该对象对外的提供的接口来访问该对象。
　　对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。
　　使用封装有三大好处：
　　　　1、良好的封装能够减少耦合。
　　　　2、类内部的结构可以自由修改。
　　　　3、可以对成员进行更精确的控制。
　　　　4、隐藏信息，实现细节。

　　3.多态
　　多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运
　　行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在
　　由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同
　　的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可
　　以选择多个运行状态，这就是多态性。

（2）final、finally、finalize 的区别

final：修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。
　　　　因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保
　　　　证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。
　　　　被声明为final的方法也同样只能使用，不能重载。 
finally：再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 
　　　　子句就会执行，然后控制就会进入 finally 块（如果有的话）。 
finalize：方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要
　　　　的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object
　　　　 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理
　　　　工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

（3）Exception、Error、运行时异常与一般异常有何异同

资料来源：http://blog.sina.com.cn/s/blog_6aefe425010187xq.html

Throwable是所有Java程序中错误处理的父类，有两种资类：Error和Exception。

Error：表示由JVM所侦测到的无法预期的错误，由于这是属于JVM层次的严重错误，导致JVM无法继续执行，因此，这是不可捕捉到的，无法采取任何恢复的操作，顶多只能显示错误信息。Error类体系描述了Java运行系统中的内部错误以及资源耗尽的情形.应用程序不应该抛出这种类型的对象(一般是由虚拟机抛出).假如出现这种错误,除了尽力使程序安全退出外,在其他方面是无能为力的.

Exception：表示可恢复的例外，这是可捕捉到的。

Java提供了两类主要的异常:runtime exception和checked exception。checked 异常也就是我们经常遇到的IO异常，以及SQL异常都是这种异常。对于这种异常，JAVA编译器强制要求我们必需对出现的这些异常进行catch。所以，面对这种异常不管我们是否愿意，只能自己去写一大堆catch块去处理可能的异常。这类异常一般是外部错误,例如试图从文件尾后读取数据等,这并不是程序本身的错误,而是在应用环境中出现的外部错误.

但是另外一种异常：runtime exception，也称运行时异常，我们可以不处理。当出现这样的异常时，总是由虚拟机接管。比如：我们从来没有人去处理过NullPointerException异常，它就是运行时异常，并且这种异常还是最常见的异常之一。RuntimeException体系包括错误的类型转换、数组越界访问和试图访问空指针等等.处理RuntimeException的原则是:假如出现RuntimeException,那么一定是程序员的错误.例如,可以通过检查数组下标和数组边界来避免数组越界访问异常.

出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，那么这整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被Catch块处理的。只不过往往我们不对他处理罢了。也就是说，你如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

如果不想终止，则必须扑捉所有的运行时异常，决不让这个处理线程退出。队列里面出现异常数据了，正常的处理应该是把异常数据舍弃，然后记录日志。不应该由于异常数据而影响下面对正常数据的处理。在这个场景这样处理可能是一个比较好的应用，但并不代表在所有的场景你都应该如此。如果在其它场景，遇到了一些错误，如果退出程序比较好，这时你就可以不太理会运行时异常，或者是通过对异常的处理显式的控制程序退出。异常处理的目标之一就是为了把程序从异常中恢复出来。

（4）请写出5种常用的runtime exception

RuntimeException是java中所有运行时异常的父类，实际运行时出现的都是它的子类，看看RuntimeException的Java doc就可以随便列出几个：
1，Object x = new Integer(0);
     System.out.println((String)x);
当试图将对象强制转换为不是实例的子类时，抛出该异常（ClassCastException)
2，int a=5/0;
一个整数“除以零”时，抛出ArithmeticException异常。
3, String s=null;
int size=s.size();
当应用程序试图在需要对象的地方使用 null 时，抛出NullPointerException异常
4, "hello".indexOf(-1);
指示索引或者为负，或者超出字符串的大小，抛出StringIndexOutOfBoundsException异常
5，String[] ss=new String[-1];
如果应用程序试图创建大小为负的数组，则抛出NegativeArraySizeException异常

（5）int 和 Integer 有什么区别、Integer的值缓存范围

转载链接：http://blog.csdn.net/chenliguan/article/details/53888018

1 int与integer的基本使用对比

（1）Integer是int的包装类；int是基本数据类型； 
（2）Integer变量必须实例化后才能使用；int变量不需要； 
（3）Integer实际是对象的引用，指向此new的Integer对象；int是直接存储数据值 ； 
（4）Integer的默认值是null；int的默认值是0。

2 int与Integer的深入对比

（1）由于Integer变量实际上是对一个Integer对象的引用，所以两个通过new生成的Integer变量永远是不相等的（因为new生成的是两个对象，其内存地址不同）。

Integer i = new Integer(100);

Integer j = new Integer(100);


System.out.print(i == j); //false

（2）Integer变量和int变量比较时，只要两个变量的值是向等的，则结果为true

（因为包装类Integer和基本数据类型int比较时，java会自动拆包装为int，然后进行比较，实际上就变为两个int变量的比较）

Integer i = new Integer(100);

int j = 100；

System.out.print(i == j); //true

（3）非new生成的Integer变量和new Integer()生成的变量比较时，结果为false。

（因为非new生成的Integer变量指向的是java常量池中的对象，而new Integer()生成的变量指向堆中新建的对象，两者在内存中的地址不同）

Integer i = new Integer(100);


Integer j = 100;


System.out.print(i == j); //false

（4）对于两个非new生成的Integer对象，进行比较时，如果两个变量的值在区间-128到127之间，

则比较结果为true，如果两个变量的值不在此区间，则比较结果为false

Integer i = 100;

Integer j = 100;

System.out.print(i == j);

//true

Integer i = 128;
Integer j = 128;
System.out.print(i == j); //false

　　对于第4条的原因： java在编译Integer i = 100 ;时，会翻译成为Integer i = Integer.valueOf(100)。

而java API中对Integer类型的valueOf的定义如下，对于-128到127之间的数，会进行缓存，

Integer i = 127时，会将127进行缓存，下次再写Integer j = 127时，

就会直接从缓存中取，就不会new了。

public static Integer valueOf(int i){


　　assert IntegerCache.high >= 127;


　　　　if (i >= IntegerCache.low && i <= IntegerCache.high){


　　　　　　return IntegerCache.cache[i + (-IntegerCache.low)];

　　　　}


　　 return new Integer(i);


}

（6）包装类、装箱、拆箱

包装类：原始类型对应的类

原始数据类型，分为boolean,byte,in,char,long,short,double,float 
引用数据类型，分为数组,类,接口

装箱：是指基本类型变为相应包装类的过程，如Integer a=Integer.valueOf(100);

　　或者int a=100;Integer b=new Integer(a);

　　这里的Integer.valueOf(100)和new Integer(a)就是装箱，

　　由基本数据类型构造出一个包装类的对象。

拆箱：就是装箱的逆过程。如Integer a=new Integer(100);

　　int b=a.intValue();

　　这里的a.intValue()就是拆箱的过程，

　　由一个包装类对象转换到相应的基本数据类型。

包装类的自动装箱和拆箱规则如下：

• 遇到赋值运算符“=”（包括传参数，参数传递属于隐式赋值）时，会将包装类拆箱或装箱为相应类型
• 遇到算术运算符、位运算符和位移运算符“+, ++, --, -, *, /, %, &, |, ^, ~, <<, >>, >>>”时，对包装类进行拆箱
• 遇到关系运算符">, <, >=, <="（不包括“==”和“!=”哦）时，对包装类进行拆箱
• 对关系运算符"==, !="而言，遇到数字常量或算术表达式时，才对包装类进行拆箱

（7）String、StringBuilder、StringBuffer

String：字符串常量

StringBuffer ：字符串变量（线程安全）

StringBuilder：字符串变量（非线程安全）

性能上：StringBuilder > StringBuffer > String

String是不可变对象，每次对String类型进行改变的时候都等同于生成一个新的String的对象，然后将指针指向新的String对象，

所以性能最差，对于经常改变内容的字符串不用String。

StringBuffer 是字符串变量，对它操作时，并不会生成新的对象，而是直接对该对象进行修改，所以性能好。

StringBuilder和StringBuffer 一样，是字符串变量，但是他不能带有synchronized 关键字，不保证线程安全，所以性能最好，

在单线程的情况下，建议使用StringBuilder。

（8）重载和重写的区别

　　　override（重写）：

　　　　1.方法名、参数、返回值不同。

　　　　2.子类方法不能缩小父类方法的访问权限。

　　　　3.子类方法不能抛出比父类方法更多的异常（但子类方法可以不抛异常）

　　　　4.存在于父类和子类之间。

　　　　5.方法被定义为final时不能被重写。

　　　overload（重载）：

　　　　1.参数类型、个数、顺序至少一种不相同。

　　　　2.不能重载只有返回值不同的方法名。

　　　　3.存在于父类和子类、同类中。

　　Java 中的覆盖@Override注解 写与不写的一点点理解

　　一般来说，写与不写没什么区别，JVM可以自识别

　　写的情况下：即说明子类要覆盖基类的方法，基类必须存在方法

　　（控制类型public,protected，返回值，参数列表类型）与子类方法完成一致的方法，否则会报错（找不到被Override的方法）。

　　在不写@Override注解的情况下，当基类存在与子类各种条件都符合的方法是即实现覆盖；

　　如果条件不符合时，则是当成新定义的方法使用。

　　所以如果想覆盖基类方法时，最好还是写上@Override注解，这样有利于编译器帮助检查错误

（9）抽象类和接口的区别

　　1.抽象类和接口都不能直接实例化，如果实例化，抽象类变量必须指向实现所有抽象方法的子类对象，

接口变量必须指向实现所有接口方法的类对象

　　2.抽象类要被子类继承使用，接口要被类实现

　　3.接口只能做方法声明，抽象类中可以做方法声明，也可以做方法实现

　　4.接口里定义的变量只能是公共的静态的常量，抽象类中的变量可以是普通变量

　　5.抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。

同样，一个类实现接口时候，如果不能全部实现接口，那么该类也只能是抽象类。

　　6.抽象方法只能申明，不能实现。例如： abstract void tes(); 而不是 abstract void tes(){ }

　　7.抽象类可以没有抽象方法

（10）说说反射的用途和实现

Java反射机制主要提供了以下功能：在运行时构造一个类的对象；判断一个类所具有的成员变量和方法；调用一个对象的方法；生成动态代理。反射最大的应用就是框架

Java.lang.Class和Java.lang.reflect包下的API，用于表示或者处理当前JVM中的类，接口和对象。

Java反射的主要功能：

确定一个对象的类
    取出类的modifiers,数据成员,方法,构造器,和超类.
    找出某个接口里定义的常量和方法说明.
    创建一个类实例,这个实例在运行时刻才有名字(运行时间才生成的对象).
    取得和设定对象数据成员的值,如果数据成员名是运行时刻确定的也能做到.
    在运行时刻调用动态对象的方法.
    创建数组,数组大小和类型在运行时刻才确定,也能更改数组成员的值.

Class类是Java反射的基础，Class类表示正在运行的java应用程序中的类和接口。Class只有私有的构造函数。Class类在加载类时由Java虚拟机以及调用类加载器中的 defineClass方法自动创建的。只在内存中存在一份加载类的Class类。

反射的应用很多，很多框架都有用到

　　spring 的 ioc/di 也是反射
　　javaBean和jsp之间调用也是反射
　　struts的 FormBean 和页面之间...也是通过反射调用
　　JDBC 的 classForName()也是反射
　　hibernate的 find(Class clazz) 也是反射

获取一个对象对应的反射类，在Java中有三种方法可以获取一个对象的反射类，

• 通过getClass()方法
• 通过Class.forName()方法；
• 使用类.class
• 通过类加载器实现，getClassLoader()

（11）说说自定义注解的场景及实现

跟踪代码的依赖性，实现代替配置文件的功能。比较常见的是Spring等框架中的基于注解配置。

还可以生成文档常见的@See@param@return等。如@override放在方法签名，如果这个方法 并不是覆盖了超类方法，则编译时就能检查出。

使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节，在定义注解时，不能继承其他注解或接口。

（12）HTTP请求的GET和POST方式的区别

在客户机和服务器之间进行请求-响应时，两种最常被用到的方法是：GET 和 POST。

• GET - 从指定的资源请求数据。
• POST - 向指定的资源提交要被处理的数据

GET方法

请注意，查询字符串（名称/值对）是在 GET 请求的 URL 中发送的：

/test/demo_form.asp?name1=value1&name2=value2

• 请求可被缓存
• 请求保留在浏览器历史记录中
• 请求可被收藏为书签
• 请求不应在处理敏感数据时使用
• 请求有长度限制
• 请求只应当用于取回数据

POST方法

请注意，查询字符串（名称/值对）是在 POST 请求的 HTTP 消息主体中发送的：

POST /test/demo_form.asp HTTP/1.1
Host: w3schools.com
name1=value1&name2=value2

比较 GET 与 POST

方法	GET	POST
缓存	能被缓存	不能缓存
编码类型	application/x-www-form-urlencoded	application/x-www-form-urlencoded 或 multipart/form-data。为二进制数据使用多重编码。
对数据长度的限制	是的。当发送数据时，GET 方法向 URL 添加数据；URL 的长度是受限制的（URL 的最大长度是 2048 个字符）	无限制。
对数据类型的限制	只允许 ASCII 字符	没有限制。也允许二进制数据。
安全性	与 POST 相比，GET 的安全性较差，因为所发送的数据是 URL 的一部分。在发送密码或其他敏感信息时绝不要使用 GET	POST 比 GET 更安全，因为参数不会被保存在浏览器历史或 web 服务器日志中。
可见性	数据在 URL 中对所有人都是可见的。	数据不会显示在 URL 中。

其他 HTTP 请求方法

• HEAD 与 GET 相同，但只返回 HTTP 报头，不返回文档主体。
• PUT 上传指定的 URI 表示。
• DELETE 删除指定资源。
• OPTIONS 返回服务器支持的 HTTP 方法
• CONNECT 把请求连接转换到透明的 TCP/IP 通道。

（13）Session与Cookice区别

1. cookie数据存放在客户的浏览器上，session数据放在服务器上。
2. cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗考虑到安全应当使用session。
3. session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能考虑到减轻服务器性能方面，应当使用COOKIE。
4. 单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。
5. 所以个人建议：
   将登陆信息等重要信息存放为SESSION
   其他信息如果需要保留，可以放在COOKIE中

（14）SpringMVC的工作流程

（1）用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获；DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回；

（2）DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）

（3）提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。 在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：

　　　　HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息

　　　　数据转换：对请求消息进行数据转换。如String转换成Integer、Double等

　　　　数据根式化：对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等

　　　　数据验证： 验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中

（4）Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；

（5）根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet ；

（6）ViewResolver 结合Model和View，来渲染视图

（7）将渲染结果返回给客户端。

（15）MVC设计思想

　　MVC是Model-View-Controller，模型-视图-控制器，是一种设计模式。

　　视图：视图是用户看到并与之交互的界面，视图向用户显示相关的数据，并接受用户的输入，视图不进行任何的业务逻辑处理。

　　模型：模型表示业务数据和业务处理，相当于JavaBean。一个模型能为多个视图提供数据，提高应用程序的重用性。

　　控制器：当用户单击Web页面中的提交按钮时，控制器接收请求并调用相应的模型处理，并返回数据给控制器。控制器调用相应

　　　　　　的视图来显示处理的结果，并通过视图呈现给用户。

（16）equals与==的区别

　　“==” ：比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。

　　equals ：用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。

（17）hashCode与equals方法的区别与联系

HashMap中，必须覆盖equals和hashCode，不然是不能put的

1、equals方法用于比较对象的内容是否相等（覆盖以后）

2、hashcode方法只有在集合中用到

3、当覆盖了equals方法时，比较对象是否相等将通过覆盖后的equals方法进行比较（判断对象的内容是否相等）。

4、将对象放入到集合中时，首先判断要放入对象的hashcode值与集合中的任意一个元素的hashcode值是否相等，如果不相等直接将该对象放入集合中。如果hashcode值相等，然后再通过equals方法判断要放入对象与集合中的任意一个对象是否相等，如果equals判断不相等，直接将该元素放入到集合中，否则不放入。

（18）什么是Java序列化和反序列化，如何实现Java序列化？或者请解释Serializable接口的作用

首先要明确序列化的目的：

1.无论何种类型的数据，都是以二进制的形式在网络上传送，为了由一个进程把Java对象发送给另一个进程，需要把其转换为字节序列才能在网络上传送，把JAVA对象转换为字节序列的过程就称为对象的序列化，将字节序列恢复成Java对象的过程称为对象的反序列化，（然后java.io.ObjectOutPutStream的writeObject(Object obj)的方法就可以 将参数指定的对象进行序列化 并且把得到的字节流写到一个目标输出流上去）

2.只有实现了 serializable和Externalizable接口的类的对象才能被序列化  后者是前者的子类   实现这个借口的类完全由自身来控制序列化的行为，而仅仅实现前者的类可以采用默认的序列化方式。实现这两个接口 标志着对象可以被序列化了。。。

（19）Object类中常用的方法，为什么wait notify会放在 Object 里面？

Java的每个对象中都有一个锁(monitor，也可以成为监视器)并且wait()，notify()等方法用于等待对象的锁或者通知其他线程对象的监视器可用。
在Java的线程中并没有可供任何对象使用的锁和同步器。这就是为什么这些方法是Object类的一部分，这样Java的每一个类都有用于线程间通信的基本方法。

（20）Java的平台无关性如何体现出来的？

Java提供了JDK，供开发人员进行java开发，开发出的Java文件本身并不具备平台无关的特性。Java文件编译后，生成的class二进制文件。SUN提供了各个平台下的JRE：Windows下的，Linux下的，UNIX下的。编译后的class文件，就在各个平台下的jre上运行了。简单的说，就是因为jre的存在。

（21）JDK和JRE的区别

JDK是Java的开发工具包，主要包含了各种类库和工具，当然也包含了另外一个JRE，那么为什么要包含另外一个JRE呢？而且<JDK安装目录>/JRE/bin目录下，包含有server一个文件夹~包含一个jvm.dll，这说明JDK提供了一个虚拟机。另外，JDK的bin目录下有各种Java程序需要用到的命令，与JRE的bin目录最明显的区别就是JDK文件下才有javac，这一点很好理解，因为JRE只是一个运行环境而已，与开发无关。正因为如此，具备开发功能的JDK所包含的JRE下才会同时有server的JVM，而仅仅作为运行环境的JRE下，只需要server的jvm.dll就够了。

JRE是Java Runtime Environment的缩写，是Java程序的运行环境。既然是运行，当然要包含JVM，也就是所谓的Java虚拟机，还有所以的Java类库的class文件，都在lib目录下，并且都打包成了jar。

JDK是Java的开发工具，它不仅提供了Java程序运行所需的JRE，还提供了一系列的编译，运行等工具，如javac，java，javaw等。

JRE只是Java程序的运行环境，它最核心的内容就是JVM（Java虚拟机）及核心类库。

（22）wait和sleep 的 区别

　　1.sleep()方法是属于Thread类中的，而wait()方法 ,则是属于Object类中的。
　　2.sleep()方法导致了程序暂停执行指定时间，让出CPU给其他线程，但是他的
　　　监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。所以在调用
　　    sleep()方法的过程中，线程不会释放对象锁。
　　3.调用wait()方法是，线程会放弃对象锁，进入等待此对象的等待锁定池，只有
　　　针对此对象调用notify()方法后，本线程才进入对象锁定池准备获取对象锁进行
　　　运行状态。