面试常见难点概念总结

1. 面向对象和面向过程的区别

面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术[1]发展到一定阶段后的产物。面向对象是以功能来划分问题，而不是步骤。

面向过程是一种以过程为中心的编程思想。“面向过程”也可称之为“面向记录”编程思想，他们不支持丰富的“面向对象”特性（比如继承、多态），并且它们不允许混合持久化状态和域逻辑。就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

例子：围棋

面向对象：1.黑白双方，这两个的行为是一模一样的2.棋盘系统，负责绘制画面3.规则系统，负责判断输赢

面向过程：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。

1. mysql和oracle的区别

mysql主要应用到中小型系统中，oracle一般应用在大型系统

增长类型的区别：mysql有increment自增长方式，而oracle利用sequence实现增长

分页处理的区别：mysql可以使用limit限制分页处理 eg：select * from table_name limit 10;

ORACLE处理翻页的SQL语句就比较繁琐了。每个结果集只有一个rownum字段标明它的位置，并且只能用rownum<100，不能用rownum>80。以下是经过分析后较好的两种ORACLE翻页SQL语句(ID是唯一关键字的字段名)：

Select id from table_name where id in (select id from (select rownum as numrow,id from table_name where 条件1 order by 条件2) where numrow >80 and numrow <100) order by 条件3；

数据类型的区别：比如oracle的varchar2，而mysql没有，mysql有int而oracle没有

1. Struts 2 和Servlet和JSP
   1. Struts2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。它以webwork为核心采用拦截器机制对用户请求进行处理，也是一个按照MVC设计模式设计的一个web层框架，也是一个很大的Servlet。他也可以有多个配置文件，各自的模块执行各自的功能
   2. Struts2处理过程：请求交给action之前会将请求数据封装成一个formbeaan对象，然后对formbena调用validate方法进行校验，通过校验的然后交给action的execute方法去处理返回一个响应的结果，没有通过校验的则返回一个错误页面，一般使用input指定。
   3. Servlet是一种java服务器端的应用程序具有独立于平台和协议的特性，可以生成动态的Web页面。 它担当客户请求（Web浏览器或其他HTTP客户程序）与服务器响应（HTTP服务器上的数据库或应用程序）的中间层。 Servlet是位于Web 服务器内部的服务器端的Java应用程序，与传统的从命令行启动的Java应用程序不同，Servlet由Web服务器进行加载，该Web服务器必须包含支持Servlet的Java虚拟机。
   4. Servlet生命周期：加载、实例化(一般是servlet容器来完成)、初始化(执行init方法)、运行service方法(根据请求方式的不同分为doGet和doPost)处理请求、服务终止执行destroy销毁。
   5. Servlet执行过程：当用户发送一个请求到某个Servlet的时候，Servlet容器会创建一个ServletRequst和ServletResponse对象。在ServletRequst对象中封装了用户的请求信息，然后Servlet容器把ServletRequst和ServletResponse对象，传给用户所请求的Servlet，Servlet把处理好的结果写在ServletResponse中，然后Servlet容器把响应结果传给用户。
   6. Servlet与JSP有什么区别？JSP是一种java动态页面技术，由html和java代码和tag组成。而jsp编译以后实际上也是一个servlet，JSP擅长页面表现，而Servlet擅长处理逻辑用来控制业务流程，在struts2的MVC设计模式中中servlet充当控制层而JSP充当表现层。‘
2. Hibernate和JDBC
   1. 概念比较 : Hibernate是对JDBC的轻量级封装，是将对象持久化的框架，Hibernate可以用在任何JDBC可以使用的场合，Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系。而JDBC是一个可以执行SQL语句的JAVA程序。由一组java类和接口组成。
   2. 性能比较：

1、内存消耗：采用JDBC的架构无疑是最省内存的，Hibernate的架构次之

2、运行效率：如果JDBC的代码写的非常优化，那么JDBC架构运行效率最高，但是实际项目中，这一点几乎做不到，这需要程序员非常精通JDBC，运用Batch语句，调整PreapredStatement的Batch Size和Fetch Size等参数，以及在必要的情况下采用结果集cache等等。而一般情况下程序员是做不到这一点的。因此Hibernate架构表现出最快的运行效率。

3、开发效率：小项目中JDBC相率较高，Hibernate次之。但在一般的大型项目中Hibernate的效率大的惊人。

1. 1. 相同点：

◆两者都是JAVA的数据库操作中间件。

◆两者对于数据库进行直接操作的对象都不是线程安全的，都需要及时关闭。

◆两者都可以对数据库的更新操作进行显式的事务处理。

1. 1. 不同点：

◆JDBC使用标准SQL语言，而Hibernate使用HQL面向对象查询语言

◆JDBC操作的是数据，是将SQL语句传送到DB中执行，而Hibernate操作的是持久化对象，由底层持久化对象的数据更新到数据库中。

◆数据状态不同：JDBC操作的数据是“瞬时”的，变量的值无法与数据库中的值随时保持一致，而Hibernate操作的数据是可持久的，即持久化对象的数据属性的值是可以跟数据库中的值保持一致的。

JDBC仍然是最快的访问方式，不论是Create还是Read操作，都是JDBC快。

1. jQuery其实是一个轻量级的JavaScript库或者说是框架,jQuery简化了的JavaScript编程，使用更少的代码执行更多的功能。
2. Cookie和Session
   1. 定义：

Cookie：是浏览器访问某个服务器时，服务器会创建一部分数据（以消息头set-cookie的方式)发送给浏览器，浏览器会将这部分数据保存下来。当浏览器再次访问该服务器时，会将这部分数据发送给服务器。也是在客户端（浏览器）维护用户状态的一种状态管理技术。

Session：在服务器端维护用户状态的一种状态管理技术。当浏览器访问服务器时，服务器会创建一个对象(session对象),同时，还会生成一个标识该对象的唯一的字符串(sessionId),服务器在默认情况下，使用cookie机制将sessionId发送给浏览器。浏览器下次访问服务器时，会将sessionId携带给服务器，服务器会使用sessionId查找对应的session对象。通过这种方式，来维护用户的状态。

(2) cookie 和session 的区别：

① cookie数据存放在客户的浏览器上，session数据放在服务器上。

② cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗考虑到安全应当使用session。

③ session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，如果考虑到减轻服务器性能方面，应当使用COOKIE。

④ 单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。

1. Spring的理解
   1. 概念

Spring是一个轻型容器(light-weight container)，其核心是Bean工厂(Bean Factory)，用以构造我们所需要的M(Model)。Spring也是一个开源的轻量级Java SE（Java 标准版本）/Java EE（Java 企业版本）开发应用框架，其目的是用于简化企业级应用程序开发。

1. 1. 特点：

① Spring实现了工厂模式的工厂类（在这里有必要解释清楚什么是工厂模式），这个类名为BeanFactory（实际上是一个接口），Spring相当于一个大的工厂类，在其配置文件中通过<bean>元素配置用于创建实例对象的类名和实例对象的属性。

② Spring提供了对IOC良好支持，IOC是一种编程思想，是一种架构艺术，利用这种思想可以很好地实现模块之间的解耦。Ioc又称为依赖注入DI。

③ Spring提供了对AOP技术的良好封装， AOP称为面向切面编程，就是系统中有很多各不相干的类的方法，在这些众多方法中要加入某种系统功能的代码，例如，加入日志，加入权限判断，加入异常处理，这种应用称为AOP。

1. 工厂模式的理解：

实例化对象，用工厂方法代替new操作返回一个类对象。工厂类是指包含了一个专门用来创建其他对象的方法的类。工厂类在多态性编程实践中是至关重要的。它允许动态地替换类，修改配置，并且通常会使应用程序更加灵活。熟练掌握工厂模式对高级PHP开发人员来说是很重要的。  工厂模式通常用来返回符合类似接口的不同的类。工厂的一种常见用法就是创建多态的提供者，从而允许我们基于应用程序逻辑或者配置设置来决定应该实例化哪一个类。

1. C/S架构和B/S架构的区别
   1. C/S 架构

概念：是一种典型的两层架构，其全程是Client/Server，即客户端服务器端架构其客户端包含一个或多个在用户的电脑上运行的程序，而服务器端有两种，一种是数据库服务器端，客户端通过数据库连接访问服务器端的数据；另一种是Socket服务器端，服务器端的程序通过Socket与客户端的程序通信。

优点：

1.C/S架构的界面和操作可以很丰富。

2.安全性能可以很容易保证，实现多层认证也不难。

3.由于只有一层交互，因此响应速度较快。

缺点：

1.适用面窄，通常用于局域网中。

2.用户群固定。由于程序需要安装才可使用，因此不适合面向一些不可知的用户。

3.维护成本高，发生一次升级，则所有客户端的程序都需要改变。

1. 1. B/S架构

概念：的全称为Browser/Server，即浏览器/服务器结构。Browser指的是Web浏览器，极少数事务逻辑在前端实现，但主要事务逻辑在服务器端实现，Browser客户端，WebApp服务器端和DB端构成所谓的三层架构。B/S架构的系统无须特别安装，只有Web浏览器即可。B/S架构中，显示逻辑交给了Web浏览器，事务处理逻辑在放在了WebApp上，这样就避免了庞大的胖客户端，减少了客户端的压力。因为客户端包含的逻辑很少，因此也被成为瘦客户端。

优点：

1、客户端无需安装，有Web浏览器即可。

2、BS架构可以直接放在广域网上，通过一定的权限控制实现多客户访问的目的，交互性较强。

3、BS架构无需升级多个客户端，升级服务器即可。

 

缺点：

1、在跨浏览器上，BS架构不尽如人意。

2、在速度和安全性上需要花费巨大的设计成本，这是BS架构的最大问题。

3、客户端服务器端的交互是请求-响应模式，通常需要刷新页面，这并不是客户乐意看到的。（在Ajax风行后此问题得到了一定程度的缓解）

1. JSP 9种隐含对象与5种动作元素

1. 隐含对象

1、out 来源于java.io.Writer类，它用于发送输出流到客户端。

2、request 来源于javax.servlet.http.HttpServletRequest接口。它被关联到每一个HTTP请求。

3、response 来源于javax.servlet.http.HttpServletResponse。response对象用于把取得的数据返回到客户端。

4、pageContext 提供访问JSP页面的命名空间。pageContext对象提供了对JSP页面所有的对象及命名空间的访问

5、session 来源于javax.servlet.http.HttpSession。它用于存储客户端请求的信息，因此它是有状态交互式的。

6、application 来源于javax.servlet.ServletContext。

7、config 来源于ServletConfig，它包含了当前JSP/Servlet所在的WEB应用的配置信息。

8、page 来源于当前被访问JSP页面的实例化。它实际使用的是JSP转换成的Servlet。

9、exception 用于捕获JSP抛出的异常。它只有在JSP页面属性isErrorPage=true时才可用。

1. 动作元素

1、jsp:include：在页面被请求的时候引入一个文件。

2、jsp:useBean：寻找或者实例化一个JavaBean。

3、jsp:setProperty：设置JavaBean的属性。

4、jsp:getProperty：输出某个JavaBean的属性。

5、jsp:forward：把请求转到一个新的页面。

6、jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。

1. 在Java中Applet和Application的区别

 Applet是指采用Java创建的基于HTML的程序。浏览器将其暂时下载到用户的硬盘上，并在Web页打开时在本地运行。Applet必须运行于某个特定的“容器”，这个容器可以是浏览器本身，也可以是通过各种插件，或者包括支持Applet的移动设备在内的其他各种程序来运行。Application是一个完整的JAVA应用程序，可以单独运行，他们的运行环境不同，Application由虚拟机运行运行的类必须有main入口方法，而Applet只能借助在html网页中运行。

1. 线程wait()和sleep()的区别

都是使线程暂时停止执行的方法，但它们有很大的不同，sleep是线程类Thread 的方法，它是使当前线程暂时睡眠，可以放在任何位置。而wait是Object类的方法，它是使当前线程暂时放弃对象的使用权进行等待，必须放在同步方法或同步块里。Sleep使用的时候，线程并不会放弃对象的使用权，即不会释放对象锁，所以在同步方法或同步块中使用sleep，一个线程访问时，其他的线程也是无法访问的。而wait是会释放对象锁的，就是当前线程放弃对象的使用权，让其他的线程可以访问。线程执行wait方法时，需要另一个线程调用notify进行唤醒。而sleep只是暂时休眠一定时间，时间到了之后，自动恢复运行，不需另外的线程唤醒。

1. 分层设计的好处：

把各个功能按调用流程进行了模块化，模块化带来的好处就是可以随意组合，分层就是要把界面部分、业务逻辑部分、数据库访问部分的代码放在各自独立的方法或类中编写。分层的好处：1，实现了软件之间的解耦；2.便于进行分工3.便于维护4，提高软件组件的重用

1. 面向对象的特点

封装：封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，把对一系类有关系的数据和操作放到一起，一接口的形式向外提供服务。

抽象：抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面

继承：继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

多态：在面向对象语言中，接口的多种不同的实现方式即为多态。

1. Abstract和interface区别

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然

eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

1. 内部类：

成员内部类：在class类的内部编写，使用外层类调用时必须先实例化外部类对象

静态内部类：在类中使用static修饰，可以使用外层类名调用改内部类

如：Outer.Inner n = new Outer.Inner();

方法内部类：定义在方法中的内部类，作用域和方法大小一样

匿名内部类：没有名字的内部类，一般为Class a = new Class() {//…}

内部类可以隐藏你不想让别人知道的操作，也即封装性，如通过内部类实现某个接口实现系列操作，然后通过该类的方法执行内部类实现接口的操作，但在外部是看不到起对接口的操作的。已个内部类对象也可以访问创建它的外部类对象的私有内容。静态内部类调用私有属性时，只能引用静态成员。

1. 字符串问题

1. String使用final是不能修改的，对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。
2. String s = new String("xyz");创建了几个String Object? 二者之间有什么区别？

两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。

1. String str = “a”+ ”b”+ “c”+ “d”;共创建了一个对象

String s2 = s1 + "b";  String s3 = "a" + "b";

System.out.println(s2 == "ab"); à false

System.out.println(s3 == "ab"); à true

1. Collection集合

 

 

 

 

 

 

 

 

 

 

HashMap的key可以为null，而HashTable不允许，编译不保存，运行报空指针异常

1. heap和stack有什么区别

栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。

堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用new创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使用final修饰后，放在堆中，而不是栈中。

1. Servlet中的forward( )和redirect( )有什么区别

前者是服务器直接访问URL地址，处理后将响应发送给浏览器，浏览器只能得到响应，而根本不知道地址，所以地址栏地址不变，而后者即为服务器发给浏览器URL地址，然后浏览器直接访问改地址得到响应。

1. 数据库三大范式是什么？

第一范式：数据表字段保持原子性，不可再分

第二范式（2NF）要求实体的属性完全依赖于主关键字

第三范式（3NF）要求一个数据库表中不包含已在其它表中已包含的非主关键字信息（一般使用id关联）。从而减少数据库的冗余。

1. J2ee软件设计模式

三大类：创建型，结构型，行为型

创建型（工厂、工厂方法、抽象工厂、单例）

结构型（包装、适配器，组合，代理）

行为（观察者，模版，策略）

1. J2EE是技术还是平台还是框架？ 什么是J2EE

   J2EE本身是一个标准，一个为企业分布式应用的开发提供的标准平台。

   J2EE也是一个框架，包括JDBC、JNDI、RMI、JMS、EJB、JTA等技术。

1. 会话作用域ServletsJSP 页面描述

1、page否是代表与一个页面相关的对象和属性。一个页面由一个编译好的 Java servlet 类（可以带有任何的 include 指令，但是没有 include 动作）表示。这既包括 servlet 又包括被编译成 servlet 的 JSP 页面

2、request是代表与 Web 客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个 Web 组件（由于 forward 指令和 include 动作的关系）

3、session是是代表与用于某个 Web 客户机的一个用户体验相关的对象和属性。一个 Web 会话可以也经常会跨越多个客户机请求

4、application是是代表与整个 Web 应用程序相关的对象和属性。这实质上是跨越整个 Web 应用程序，包括多个页面、请求和会话的一个全局作用域

1. 包的四个修饰符 以及权限

           类       同一包下     子类   包外

public     √          √         √     √

default    √          √         √

protected  √          √

private    √

 

1.  throw 和throws的区别

throw在在方法体内部，意味抛出一个异常

throws在方法的声明一个异常，意思为可能会出现该异常

throw可以抛出一个异常，throws可以是多个异常

1. 重载和重写的区别

重载是方法名相同，方法的返回值类型或者参数列表不同的相同方法名字的两个方法之间的关系

重写就是覆盖，若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。

重写规则：

1方法名，参数列表，返回值类型相同

2子类方法的修饰符不能低于父类

3子类抛出的异常不能比父类的异常多

 

1. 什么是唯一索引 怎么创建索引

CREATE unique INDEX 索引名 ON 表名 (列名)

 

1. oracle 去掉重复记录的关键字distinct

 

1. 修改表的字段（给一个表增加一个字段的命令）

alert table tablename add（name，varchar2(50)）

 

1.   jsp include关键字 一个是@include 一个：include  都是什么意思

<jsp:include/>为动态包含，会动态显示页面发生的动态变化

<%include file=“xx.jsp”%>为静态包含，不会显示包含的页面发生的变化

1.  一个登陆页面 把三大框架串一下

 1. jquary 怎么获得文本框的内容

var txt = $('#id').val();

 2. Linux 怎么压缩文件（我的简历上说我了解Linux） 其他人没问这个

tar –cvf dd.rar dd

1. 你想了解公司的什么

内部文化，员工培养，工资薪水

1. Hibernate的5个核心接口

1．Configuration：负责配置Hibernate，创建SessionFactory对象

2．SessionFactory：初始化Hibernate相当于连接池，创建session对象，线程安全，重量级，为二级缓存。

3．Session：负责保存，更新，删除，查询持久化对象，线程不安全，多个线程不能同时访问一个session对象，为轻量级，一级缓存。

4．Transaction：提供事务管理

5．Query，Cirteria:执行数据库的查询操作

Hibernate实例

Configuration cfg = new Configuration().configur();

SessionFactory factory = cfg.buildSessionFactory();

Session session = factory.openSession();

Transarion txt = session.beginTransation();

1. Linux写出至少十条命令

cd pwd cat tar ls clear chmod telent touch mkdir rm rmdir echo cp mv

1. 算法的稳定性

不稳定：选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法

稳定：冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。

数据库知识：

1事务：事务是用于保持数据的一致性，是作为单个逻辑工作单元执行的一系列操作，这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行。

1. 事务的特性：

（1）原子性（Atomicity）：事务是一个完整的操作。事务的各步操作是不可分的（原子的）；

（2）一致性（Consistency）：当事务完成时，数据必须处于一致状态

（3）隔离性（Isolation）：对数据进行修改的所有并发事务是彼此隔离的，这表明事务必须是独立的，它不应以任何方式依赖于或影响其他事务

（4）永久性（Durability）：事务完成后，它对数据库的修改被永久保持，事务日志能够保持事务的永久性.

1. 什么是ORM？

ORM是对象关系映射，主要将数据库中的关系映射到程序的对象中。

1. 5种常用的jar包及其作用

dom4j.jar 用来解析xml文件

commons-dbcp.jar 提供dbcp连接池

hibernate3.jar hibernate3.0的核心jar包

log4j.jar 用来记录用户日志的jar包

tools.jar是关于一些工具的类库

1. request session的常用方法

request.getParameter(“”)

request.getCharacterEncoding();

request.getAttribute(“”);

request.setAttribute(“”);

1. 什么是接口：接口就是一些方法特征的集合------接口是对抽象的抽象。
2. 什么是抽象类，抽象类和接口的区别

一个抽象类必须用关键字abstract明确地声明。注意声明一个抽象类非常简单，它甚至不需要任何抽象方法。通过abstract的声明就等于告诉子类它在功能上是不完整的，所以不能创建它的实例。

区别：抽象类可以有构造函数，可以有普通成员属性，可以有main方法，可以继承普通类，可以实现接口

接口，不可以有构造函数，属性全部为常量，方法全部为抽象的，默认为public abstract修饰，不可以有main方法和普通成员方法，不可以new，但是可以实现接口之间的“多继承”，不可以继承普通类，不可以实现接口。

1. Java基本数据类型与字节数（四类八种）

整型：

byte       1

short      2

int        4

long       8

浮点型

float      4

double     8

字符型

char       2

布尔型

boolean    1

1. 数据库中“索引”的优点与缺点

创建索引可以大大提高系统的性能:
第一，通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。
第二，可以大大加快数据的检索速度，这也是创建索引的最主要的原因。
第三，可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。
第四，在使用分组和排序 子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。
第五，通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。

增加索引也有许多不利的方面:
第一，创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。
第二，索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。
第三，当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

1. Javascript中常用的三种消息弹出函数

prompt() 信息输入
alert() 警告
confirm() 确认

 

1. 线程同步线程异步的区别

举个例子，上公交车的时候同步就是排队一个一个上，而异步就是没有次序的一窝蜂冲上去。

1. 线程中sleep（）方法和Object类中的wait（）方法的区别

这两者的施加者是有本质区别的.
sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.
而wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",也是 thisOBJ.wait(),这里的暂停是阻塞,还是"点火->烧水->煮饭",thisOBJ就好比一个监督我的人站在我旁边,本来该线 程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但正个流程并没有结束,我一直想去煮饭,但还没被允许, 直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处 继续执行.
其实两者都可以让线程暂停一段时间,但是本质的区别是一个线程的运行状态控制,一个是线程之间的通讯的问题
在java.lang.Thread类中，提供了sleep()，
而java.lang.Object类中提供了wait()， notify()和notifyAll()方法来操作线程
sleep()可以将一个线程睡眠，参数可以指定一个时间。
而wait()可以将一个线程挂起，直到超时或者该线程被唤醒。
wait有两种形式wait()和wait(milliseconds).
sleep和wait的区别有：
1，这两个方法来自不同的类分别是Thread和Object
2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
任何地方使用
synchronized(x){
x.notify()
//或者wait()
}
4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

1. IO中的分类，InputStream能不能new？

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

1. 线程实现同步后，两个对象访问权限问题

两个对象不能同时访问一个被同步的方法。

1. 常见的单例模式，其中同步的方法为哪种方式？

饿汉单例模式

class S1 { 

private S1() { }     

private static S1 instance = new S1();    

public static S1 getInstance() {  

    return instance; 

} 

}     

优点：   

1.线程安全的 

2.在类加载的同时已经创建好一个静态对象,调用时反应速度快。  

缺点： 资源利用效率不高，可能getInstance永远不会执行到，但是执行了该类的其他静态方法或者加载了该类（Class.forName），那么这个实例仍然初始化了 

  

懒汉单例模式

class S2 {   

private S2() {  }    

private static S2 instance = null;      

public static synchronized S2 getInstance() {           if (instance == null) {                         instance = new S2(); 

  } else {  

      return instance;  

  }

 }   

}    

优点： 资源利用率高,不执行getInstance就不会被实例，可以执行该类其他静态方法。 

缺点： 第一次加载时发应不快 ，多线程使用不必要的同步开销大