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

java基础篇：

1.一、Java基础

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

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

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

　　2.封装

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

　　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的

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

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

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

四、将对象放入到集合中时，首先判断要放入对象的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()方法后，本线程才进入对象锁定池准备获取对象锁进行　　　运行状态。