Java面试题

爱被打了一巴掌 2022-03-26 10:35 842阅读 0赞

# [Java深入面试常见：http://blog.csdn.net/xxssyyyyssxx/article/details/50423694][Java_http_blog.csdn.net_xxssyyyyssxx_article_details_50423694] #

http://blog.csdn.net/u011240877/article/details/47259503

#  1、Java中所有类的父类是什么？它都有什么方法，请列举。 #

Object类是所有类、数组、枚举类的父类。它提供了如下几个常用方法：   
1）equals()：判断指定对象与该对象是否相等。   
2）finalize()：当系统中没有引用变量引用到该对象时，垃圾回收器调用此方法来清理该对象的资源。   
3）getClass()：返回该对象的运行时类。   
4）Hashcode()：返回该对象的hashcode值。   
5）toString()：返回该对象的字符串表示，当程序使用System.out.println()方法输出一个对象，或者把某个对象和字符串进行连接运算时，系统会自动调用该对象的toString()方法返回该对象的字符串表示。   
6）Wait()、notify()、notifyAll()：控制线程的停止和运行。

#  2、Java中IO包下面的inputstream运用了什么设计模式？请简述你知道的设计者模式？ #

主要用到了两个模式：适配器模式和装饰者模式。   
适配器模式：   
在由InputStream，OutputStream，Reader和Writer代表的等级结构内部，有一些流处理器是对其它类型的流源的适配。这就是适配器模式的应用。如InputStreamReader和OutputStreamWriter做了InputStream/OutputStream字节流类到Reader/Writer之间的转换。

装饰者模式：   
在由 InputStream，OutputStream，Reader和Writer代表的等级结构内部，有一些流处理器可以对另一些流处理器起到装饰作用，形成新的，具有改善了的功能的流处理器。装饰者模式是Java I/O库的整体设计模式。这样的一个原则是符合装饰者模式的。   
如 BufferedInputStream bis = new BufferedInputStream（new FileInputStream()）;

下面讲一下我熟悉的适配器模式：   
这里涉及三个类：目标接口、适配器类、需要适配的类。   
1、类适配器：用适配器类继承需要适配的类同时实现目标接口，在适配器类中重写目标接口的方法并在该方法中用super调用需要适配的类的方法。   
以代码助理解：   
// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类   
class Adaptee \{   
public void specificRequest() \{   
System.out.println(“被适配类具有 特殊功能…”);   
\}   
\}   
// 目标接口，或称为标准接口   
interface Target \{   
public void request();   
\}   
// 适配器类，继承了被适配类，同时实现标准接口   
class Adapter extends Adaptee implements Target\{   
public void request() \{   
super.specificRequest();   
\}   
\}   
// 测试类   
public class Client \{   
public static void main(String\[\] args) \{   
// 使用特殊功能类，即适配类   
Target adapter = new Adapter();   
adapter.request();   
\}   
\}   
2、对象适配器：适配器类实现目标接口，在适配器类中包含一个被适配类的对象，在适配器类的构造函数中初始化该对象，同时在其中调用被适配器类对象的具体方法（委托方式）。   
// 适配器类，直接关联被适配类，同时实现标准接口   
class Adapter implements Target\{   
// 直接关联被适配类   
private Adaptee adaptee;   
// 可以通过构造函数传入具体需要适配的被适配类对象   
public Adapter (Adaptee adaptee) \{   
this.adaptee = adaptee;   
\}   
public void request() \{   
// 这里是使用委托的方式完成特殊功能   
this.adaptee.specificRequest();   
\}   
\}   
// 测试类   
public class Client \{   
public static void main(String\[\] args) \{   
// 使用特殊功能类，即适配类，   
// 需要先创建一个被适配类的对象作为参数   
Target adapter = new Adapter(new Adaptee());   
adapter.request();   
\}   
\}

#  3、如何在hibernate中查看原始的sql语句？ #

对原生SQL查询执行的控制是通过SQLQuery接口进行的，通过执行Session.createSQLQuery()获取这个接口。该接口是Query接口的子接口。   
执行SQL查询步骤如下：   
1）获取Hibernate Session对象   
2）编写SQL语句   
3）通过Session的createSQLQuery方法创建查询对象   
4）调用SQLQuery对象的addScalar()或addEntity()方法将选出的结果与标量值或实体进行关联，分别用于进行标量查询或实体查询   
5）如果SQL语句包含参数，调用Query的setXxxx方法为参数赋值   
6）调用Query的list方法返回查询的结果集

#  4、简述AOP和IOC的作用 #

AOP ：面向切面编程 ，它主要关注的是程序的执行过程。AOP主要实现的目的是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。

具体解析：在java方法调用时，AOP机制能自动进行方法拦截，允许在方法调用之前，调用后，以及执行异常时添加特定的代码来完成需要的功能。   
作用：1）消除编码模块之间的耦合性。 2）可以在任意阶段，向已有功能模块中填加新功能，且不侵入原有功能，是低侵入式设计。3）各步骤之间的良好隔离性 , 源代码的无关性。

IOC：控制反转，是一种设计模式。一层含义是控制权的转移：由传统的在程序中控制依赖转移到由容器来控制；第二层是依赖注入：将相互依赖的对象分离，在spring配置文件中描述他们的依赖关系。他们的依赖关系只在使用的时候才建立。简单来说就是不需要NEW一个对象了。

Spring 的AOP和IOC都是为了解决系统代码耦合度过高的问题。使代码重用度高、易于维护。

#  5、struts2的流程是怎样的？ #

一个请求在Struts2框架中的处理大概分为以下几个步骤：

![structs2流程图][structs2]

![流程描述][20160326132924899]

1、客户端初始化一个指向Servlet容器（例如Tomcat）的请求；   
2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）；   
3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action；  
4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy；   
5、ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类；   
6、ActionProxy创建一个ActionInvocation的实例。   
7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。   
8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2框架中继承的标签。在这个过程中需要涉及到ActionMapper。

#  6、线程安全你是怎么做的？ #

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。所谓线程安全无非是要控制多个线程对某个资源的有序访问或修改。   
[http://blog.csdn.net/haolongabc/article/details/7249098][http_blog.csdn.net_haolongabc_article_details_7249098]

1）同步代码块   
synchronized(obj)\{   
….   
//此处的代码块就是同步代码块   
\}   
2）同步方法   
用synchronized修饰的实例方法（非static方法）。   
3）同步锁（Lock）   
通过显式定义同步锁对象来实现同步，同步锁由Lock充当。   
锁提供了对共享资源的独占访问，每次只能有一个线程对Lock加锁，线程开始访问共享资源之前应先获得Lock对象。   
在实现线程安全的控制中，比较常用是ReentrantLock（可重入锁）。使用该Lock对象可以显示地加锁、释放锁，通常使用ReentrantLock的代码格式如下:   
class X\{   
//定义锁对象   
private final ReentrantL1ock lock=new ReentrantLock();   
//定义需要保证线程安全的方法   
public void m()\{   
//lock.lock();

try\{   
//需要保证线程安全的代码   
//…method body   
\}   
//使用finally块来保证释放锁   
finally\{   
lock.unlock();   
\}   
\}

#  线程与进程 #

进程是可并发执行的程序在某个数据集合上的一次计算活动，也是操作系统进行资源分配和调度的基本单位。

线程是操作系统进程中能够并发执行的实体，是处理器调度和分派的基本单位。

每个进程内可包含多个可并发执行的线程。   
线程自己基本不拥有系统资源，只拥有少量必不可少的资源：程序计数器、一组寄存器、栈。   
同属一个进程的线程共享进程所拥有的主存空间和资源。   
在传统OS中，拥有资源、独立调度和分派的基本单位都是进程，在引入线程的系统中，线程是调度和分派的基本单位，而进程是拥有资源的基本单位。   
在同一个进程内线程切换不会产生进程切换，由一个进程内的线程切换到另一个进程内的线程时，将会引起进程切换。

#  线程切换 #

上下文切换的开销   
当CPU从执行一个线程切换到执行另外一个线程的时候，它需要先存储当前线程的本地的数据，程序指针等，然后载入另一个线程的本地数据，程序指针等，最后才开始执行。这种切换称为“上下文切换”(“context switch”)。CPU会在一个上下文中执行一个线程，然后切换到另外一个上下文中执行另外一个线程。

#  单线程与多线程 #

多线程可以提高程序的并行性，可以把任务分开有序执行，有效利用cpu资源，提高响应速度。但是并不代表它比单线程处理的速度快，在进行密集计算时，单线程的速度要比多线程快些。   
多线程的缺点：   
1）增加资源消耗   
线程在运行的时候需要从计算机里面得到一些资源。除了CPU，线程还需要一些内存来维持它本地的堆栈。它也需要占用操作系统中一些资源来管理线程。   
多个线程在创建和切换时，消耗的时间和资源更多   
2）多个线程共享1个cpu，需要cpu不停地切换执行线程。

#  java某些类为什么要实现Serializable接口？ #

当一个类实现了Serializable接口(该接口仅为标记接口,不包含任何方法定义),表示该类可以序列化.序列化的目的是将一个实现了Serializable接口的对象转换成一个字节序列,可以把该字节序列保存起来(例如:保存在一个文件里),以后可以随时将该字节序列恢复为原来的对象。   
序列化可以将内存中的类写入文件或数据库中。比如将某个类序列化后存为文件，下次读取时只需将文件中的数据反序列化就可以将原先的类还原到内存中。也可以将类序列化为流数据进行传输。总的来说就是将一个已经实例化的类转成文件存储，下次需要实例化的时候只要反序列化即可将类实例化到内存中并保留序列化时类中的所有变量和状态。 甚至可以将该字节序列放到其他计算机上或者通过网络传输到其他计算机上恢复，只要该计 算机平台存在相应的类就可以正常恢复为原来的对象。   
序列化的实现：将需要被序列化的类实现Serializable接口，该接口没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

#  hashmap与hashtable的区别？以及如何使用，以及他的一些方法？ #

1、HashMap不是线程安全的   
hashmap是一个接口，是map接口的子接口，是将键映射到值的对象，其中键和值都是对象，并且不能包含重复键，但可以包含重复值。HashMap允许null key和null value，而hashtable不允许。   
2、HashTable是线程安全的一个Collection。   
HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。 HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey。因为contains方法容易让人引起误解。 Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map接口的一个实现。 最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。 Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差别。   
总结：   
hashmap线程不安全 允许有null的键和值 效率高一点、 方法不是Synchronize的，要提供外同步 有containsValue和containsKey方法   
hashtable 线程安全 不允许有null的键和值 效率稍低、 方法是Synchronize的 有contains方法方法   
Hashtable 继承于Dictionary 类 Hashtable 比HashMap 要旧   
HashMap 是Java1.2 引进的Map interface 的一个实现，HashMap是Hashtable的轻量级实现。

#  利用hashmap对苹果的重量进行排序 #

一、按key值排序   
假设HashMap存储的键-值对为（String，Integer），按key排序可以调用JDK函数sort（默认的按字典升序）：   
Set keySet = map.keySet();   
Collections.sort(keySet);   
for(Iterator ite = keySet.iterator(); ite.hasNext();) \{   
String temp = ite.next();   
System.out.println(“key-value: “+temp+”,”+map.getValue(temp);   
\}   
如果想要按字典的降序排列，则需改写sort方法里面的比较器Comparator：   
Collections.sort(keySet, new Comparator() \{   
public int compare(Object o1, Object o2) \{   
if(Integer.parseInt(o1.toString())>Integer.parseInt(o2.toString())   
return 1;   
if(Integer.parseInt(o1.toString())==Integer.parseInt(o2.toString())   
return 0;   
else   
return -1;   
\}   
\});   
二、按value值排序   
1)方法一：用两个list链表实现   
List keyList = new LinkedList();   
keyList.addAll(map.keySet());   
List valueList = new LinkedList();   
valueList.addAll(map.values());   
for(int i=0; i

#  struts2拦截器 #

大部分时候，拦截器方法都是通过代理的方式来调用的。Struts 2的拦截器实现相对简单。当请求到达Struts 2的ServletDispatcher时，Struts 2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表（list），最后一个一个地调用列表中的拦截器。事实上，我们之所以能够如此灵活地使用拦截器，完全归功于“动态代理”的使用。动态代理是代理对象根据客户的需求做出不同的处理。对于客户来说，只要知道一个代理对象就行了。那Struts2中，拦截器是如何通过动态代理被调用的呢？当Action请求到来的时候，会由系统的代理生成一个Action的代理对象，由这个代理对象调用Action的execute()或指定的方法，并在struts.xml中查找与该Action对应的拦截器。如果有对应的拦截器，就在Action的方法执行前（后）调用这些拦截器；如果没有对应的拦截器则执行Action的方法。其中系统对于拦截器的调用，是通过ActionInvocation来实现的。

#  struts2接受参数的方式 #

1.用Action的属性：   
在action 里面定义要接收的参数，并提供相应的setter,getter,和提交参数的名称一致，并不用做数据类型的转换。  
相应提交方式可以用get 和post，如：testAction? name=admin   
2.使用DomainModel：   
在Action 里面不用很多的属性，而是用Model 层用到的模型，保存它的一个对象。相应提交方式可以用get 和post，   
如：testAction? resBananRc.name=admin   
3.使用DTO–数据传输对象   
它的作用是接收参数，传递参数，并不是项目中的实体类。如用户注册时，会用到确认密码，所以要先把参数接收过   
来，做处理后，再传递给相应方法去创建User 对象。提交参数的方式的Domain Model 方式的相同。   
4.使用ModelDriven：   
在创建Action 的时候，Action 实现了ModelDriven 接口，去调用接口的getModel()方法，取到了相关对象。   
相应提交方式可以用get 和post，如：testAction? name=admin   
5.使用request对象：   
此方法与与传统的JSP 等传接参数一样，即使用request. getParameter(“”)方法

#  Java异常，error和exception #

![异常分类图][20160326170707714]

1.Error:所有都继承自Error，表示致命的错误，比如内存不够，字节码不合法等。   
Error是程序无法处理的错误，比如OutOfMemoryError、ThreadDeath等。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。   
2.Exception:这个属于应用程序级别的异常，这类异常必须捕捉。   
Exception是程序本身可以处理的异常，这种异常分两大类运行时异常和非运时异常。

#  MYSQL查看运行状态 #

1、用命令行的show语句   
直接在命令行下登录Mysql，运行show status。   
2、用Mysql自带的mysqladmin工具查看status，使用以下命令：mysqladmin -uroot -p密码 status

#  关于Collection的方法 #

![collection接口方法图][collection]

#  Servlet的doPost、doGet方法以及一些内置对象 #

Serlvet接口只定义了一个服务方法就是service，而HttpServlet类实现了该方法并且要求调用下列的方法之一：   
doGet：处理GET请求   
doPost：处理POST请求   
当发出客户端请求的时候，调用service 方法并传递一个请求和响应对象。Servlet首先判断该请求是GET 操作还是POST 操作。然后它调用下面的一个方法：doGet 或 doPost。如果请求是GET就调用doGet方法，如果请求是POST就调用doPost方法。doGet和doPost都接受请求(HttpServletRequest)和响应(HttpServletResponse)。   
doGet 是接收网页用get方法时调用的   
doPost 是用来接收post方法的   
get方法就像你在网页的地址栏里看到的一堆乱码,也就是url后面有参数   
post就是用表单传过去的,就好象把数据都打成包发过去一样   
1.request对象:   
客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例。   
2.response对象:   
response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。它是HttpServletResponse类的实例。   
3.session对象:   
session对象指的是客户端与服务器的一次会话，从客户端连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.   
4.out对象:   
out对象是JspWriter类的实例,是向客户端输出内容常用的对象   
5.page对象:   
page对象就是指向当前JSP页面本身，有点像类中的this指针，它是java.lang.Object类的实例   
6.application对象:   
application对象实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭，在此期间，此对象将一直存在；这样在用户的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作；在任何地方对此对象属性的操作，都将影响到其他用户对此的访问。服务器的启动和关闭决定了application对象的生命。它是ServletContext类的实例。   
7.exception对象:   
exception对象是一个例外对象，当一个页面在运行过程中发生了例外，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象   
8.pageContext对象:   
pageContext对象提供了对JSP页面内所有的对象及名字空间的访问，也就是说他可以访问到本页所在的session，也可以取本页面所在的application的某一属性值，他相当于页面中所有功能的集大成者，它的本类名也叫pageContext。   
9.config对象:   
config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）

#  java的三大特性 #

封装、继承、多态

#  抽象类和接口的区别 #

Java抽象类：   
使用关键字abstract修饰的类叫做抽象类。   
用abstract来修饰的方法叫做抽象方法。   
特点：   
1含有抽象方法的类必须被声明为抽象类（不管是否还包含其他一般方法）（否则编译通不过）；   
2抽象类可以没有抽象方法，可以有普通方法。   
3抽象类必须被继承，抽象方法必须被重写：   
若子类还是一个抽象类，不需要重写；否则必须要重写（override）。   
抽象类不能被实例化（不能直接构造一个该类的对象）；

抽象方法：   
在类中没有方法体（抽象方法只需声明，而不需实现某些功能）；   
抽象类中的抽象方法必须被实现；   
如果一个子类没有实现父类中的抽象方法，则子类也变成了一个抽象类；

虚方法：   
虚函数的存在是为了多态。   
Java中没有虚函数的概念。它的普通函数就相当于c++的虚函数，动态绑定是java的默认行为。如果java中不希望某个函数具有虚函数特性，可以加上final关键字变为非虚函数。

Java接口：   
是一系列方法的声明。   
1只有声明没有实现；   
2在不同的类中有不同的方法实现；

##  共同点 ##

1、接口和抽象类都不能被实例化，他们都位于继承树的顶端，用于被其他类实现和继承。   
2、接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些方法。

##  不同点 ##

1、接口里只能包含抽象方法和默认方法，不能为普通方法提供方法实现；抽象类则完全可以包含普通方法。   
2、接口里不能定义静态方法，抽象类里可以定义静态方法。   
3、接口里只能定义静态常量，不能定义普通成员变量；抽象类里则既可以定义普通成员变量，也可以定义静态常量。   
4、接口里不包含构造器，抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。   
5、接口里不能包含初始化块，但抽象类则完全可以包含初始化块。   
6、一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足。

#  栈内存和堆内存，引用和值传递 #

##  栈内存、堆内存 ##

在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。   
堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因。

##  引用、值传递 ##

值传递：方法调用时，实际参数把它的值传递给对应的形式参数，方法执行中形式参数值的改变不影响实际参数的值。

引用传递：也称为传地址。方法调用时，实际参数的引用(地址，而不是参数的值)被传递给方法中相对应的形式参数，在方法执行中，对形式参数的操作实际上就是对实际参数的操作，方法执行中形式参数值的改变将会影响实际参数的值。

#  单例模式及好处 #

构造函数私有化，用一个静态方法来获取对象实例。

特点：   
1）单例类只能有一个实例。   
2）单例类必须自己创建自己的唯一实例。   
3）单例类必须给所有其他对象提供这一实例。   
主要优点：   
1）提供了对唯一实例的受控访问。   
2）由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。   
3）允许可变数目的实例。

主要缺点：   
1）由于单利模式中没有抽象层，因此单例类的扩展有很大的困难。   
2）单例类的职责过重，在一定程度上违背了“单一职责原则”。   
3）滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

#  重载和重写 #

重载：Overloading   
（1） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。   
（2） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回类型作为重载函数的区分标准。

重写：Overriding   
注意：当要重写父类方法时，要使用@Override标签提醒编译器检查代码是否是重写，而不是重载了原来的方法。   
（1） 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。   
（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。   
（3）子类函数的访问修饰权限不能少于父类的。

#  子类、父类间的转换和构造顺序 #

子类、父类间的转换：   
子类能够自动转换成父类类型。   
当创建子类对象的时候：   
①先调用了子类的构造函数   
②调用了父类的构造函数   
③执行了父类的构造函数   
④执行了子类的构造函数

#  Final、finally、finalize #

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。   
finally是异常处理语句结构的一部分，表示总是执行。   
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等

#  Synchronized和volatile的区别 #

volatile只作用于在多个线程之间能够被共享的变量。如果一个字段被声明成volatile，java线程内存模型确保所有线程看到这个变量的值是一致的。Volatile变量修饰符如果使用恰当的话，它比synchronized的使用和执行成本会更低，因为它不会引起线程上下文的切换和调度。   
synchronized获得并释放监视器——如果两个线程使用了同一个对象锁，监视器能强制保证代码块同时只被一个线程所执行——这是众所周知的事实。但是，synchronized也同步内存：事实上，synchronized在“ 主”内存区域同步整个线程的内存。   
因此volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。

1）volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取，没有互斥锁；synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。   
2）volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的   
3）volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值；显然synchronized要比volatile消耗更多资源。   
4）volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。   
5）volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化 。

#  集合 #

Collection：代表一组对象，每一个对象都是它的子元素。   
Set：不包含重复元素的Collection。   
List：有顺序的Collection，并且可以包含重复元素。   
Map：可以把键（key）映射到值（value）的对象，键不能重复。

#  集合类没有实现Cloneable和Serializable接口的原因 #

Collection接口指定一组对象，对象即为它的元素。如何维护这些元素由Collection的具体实现决定。例如，一些如List的Collection实现允许重复的元素，而其它的如Set就不允许。很多Collection实现有一个公有的clone方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为Collection是一个抽象表现。重要的是实现。   
当与具体实现打交道的时候，克隆或序列化的语义和含义才发挥作用。所以，具体实现应该决定如何对它进行克隆或序列化，或它是否可以被克隆或序列化。   
在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制。特定的实现应该决定它是否可以被克隆和序列化。

#  hashCode()和equals()方法的重要性体现在什么地方？ #

HashMap使用Key对象的hashCode()和equals()方法去决定key-value对的索引。当我们试着从HashMap中获取值的时候，这些方法也会被用到。如果这些方法没有被正确地实现，在这种情况下，两个不同Key也许会产生相同的hashCode()和equals()输出，HashMap将会认为它们是相同的，然后覆盖它们，而非把它们存储到不同的地方。同样的，所有不允许存储重复数据的集合类都使用hashCode()和equals()去查找重复，所以正确实现它们非常重要。   
equals()和hashCode()的实现应该遵循以下规则：   
（1）如果o1.equals(o2)，那么o1.hashCode() == o2.hashCode()总是为true的。   
（2）如果o1.hashCode() == o2.hashCode()，并不意味着o1.equals(o2)会为true。   
Java中的HashMap使用hashCode()和equals()方法来确定键值对的索引，当根据键获取值的时候也会用到这两个方法。如果没有正确的实现这两个方法，两个不同的键可能会有相同的hash值，因此，可能会被集合认为是相等的。而且，这两个方法也用来发现重复元素。所以这两个方法的实现对HashMap的精确性和正确性是至关重要的。

存储的时候先hashCode-----再equals

#  HashMap和HashTabel的区别 #

HashMap和Hashtable都实现了Map接口，因此很多特性非常相似。但是，他们有以下不同点：   
1）HashMap允许键和值是null，而Hashtable不允许键或者值是null。   
2）Hashtable是同步的，而HashMap不是。因此，HashMap更适合于单线程环境，而Hashtable适合于多线程环境。   
3）HashMap提供了可供应用迭代的键的集合，因此，HashMap是快速失败的。另一方面，Hashtable提供了对键的列举(Enumeration)。   
一般认为Hashtable是一个遗留的类。

#  Comparable和Comparator接口 #

Comparable和Comparator都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现的排序，Comparator是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义Comparator接口的方法compare()或在集合内实现Comparable接口的方法compareTo()。   
comparable是支持自比较，而后者是支持外部比较；   
Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String、Integer自己就可以完成比较大小操作）   
而Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。   
也就是说当你需要对一个自定义的类的一个数组或者集合进行比较的时候可以实现Comparable接口，当你需要对一个已有的类的数组或者集合进行比较的时候就一定要实现Comparator接口。另外，这两个接口是支持泛型的，所以我们应该在实现接口的同时定义比较类型。

#  Java中HashMap的工作原理是？ #

Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(load factor)和扩容极限(threshold resizing)。   
1)HashMap有一个叫做Entry的内部类，它用来存储key-value对。   
2)上面的Entry对象是存储在一个叫做table的Entry数组中。   
3)table的索引在逻辑上叫做“桶”(bucket)，它存储了链表的第一个元素。   
4)key的hashcode()方法用来找到Entry对象所在的桶。   
5)如果两个key有相同的hash值，他们会被放在table数组的同一个桶里面。   
6)**key的equals()方法用来确保key的唯一性。 **  
7)**value对象的equals()和hashcode()方法根本一点用也没有。 **  
重点内容   
Put：根据key的hashcode()方法计算出来的hash值来决定key在Entry数组的索引。   
Get：通过hashcode找到数组中的某一个元素Entry

#  Hashcode的实现 #

hashCode 的常规协定是：   
在 Java 应用程序执行期间，在同一对象上多次调用 hashCode 方法时，必须一致地返回相同的整数，前提是对象上 equals 比较中所用的信息没有被修改。从某一应用程序的一次执行到同一应用程序的另一次执行，该整数无需保持一致。   
如果根据 equals(Object) 方法，两个对象是相等的，那么在两个对象中的每个对象上调用 hashCode 方法都必须生成相同的整数结果。   
当equals方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

#  String、StringBffer、StringBuilder的区别 #

1）可变与不可变   
String类中使用字符数组保存字符串，如下就是，因为有“final”修饰符，所以可以知道string对象是不可变的。   
　　　　private final char value\[\];   
StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。   
　　　　char\[\] value;   
2）是否多线程安全   
String中的对象是不可变的，也就可以理解为常量，显然线程安全。   
AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。   
　　StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的

#  HashMap、HashSet、HashTable的区别 #

HashSet和HashMap的区别   
1)HashSet是set的一个实现类,hashMap是Map的一个实现类,同时hashMap是hashTable的替代品.   
2)HashSet以对象作为元素,而HashMap以(key-value)的一组对象作为元素,且HashSet拒绝接受重复的对象.HashMap可以看作三个视图：key的Set，value的Collection，Entry的Set。HashSet其实就是HashMap的一个视图。

HashSet内部就是使用Hashmap实现的，和Hashmap不同的是它不需要Key和Value两个值。   
往hashset中插入对象其实只不过是内部做了   
public boolean add(Object o) \{   
return map.put(o, PRESENT)==null;   
\}

hastTable和hashMap的区别:   
1)Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。   
2)这个不同即是最重要的一点:Hashtable中的方法是同步的，而HashMap方法(在缺省情况下)是非同步的。即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；而对于HashMap，则需要额外的同步机制。   
3)只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。这就是说，如果在表中没有发现搜索键，或者如果发现了搜索键，但它是一个空的值，那么get()将返回null。如果有必要，用containKey()方法来区别这两种情况。

线程安全的HashMap —— java.util.concurrent.ConcurrentHashMap   
ConcurrentHashMap 增加了Segment 层，每个Segment 原理上等同于一个 Hashtable， ConcurrentHashMap 为 Segment 的数组。   
向 ConcurrentHashMap 中插入数据或者读取数据，首先都要讲相应的 Key 映射到对应的 Segment，因此不用锁定整个类， 只要对单个的 Segment 操作进行上锁操作就可以了。理论上如果有 n 个 Segment，那么最多可以同时支持 n 个线程的并发访问，从而大大提高了并发访问的效率。另外 rehash() 操作也是对单个的 Segment 进行的，所以由 Map 中的数据量增加导致的 rehash 的成本也是比较低的。

附一篇博客：线程安全的 HashMap 实现方法及原理   
[http://liqianglv2005.iteye.com/blog/2025016][http_liqianglv2005.iteye.com_blog_2025016]

#  ArrayList和LingkedList的区别 #

1）ArrayList：底层用数组实现的List   
特点：查询效率高，增删效率低 轻量级 线程不安全   
2）LinkedList：底层用双向循环链表 实现的List   
特点：查询效率低，增删效率高

#  垃圾回收机制 #

Java的垃圾回收机制是Java虚拟机提供的能力，用于在空闲时间以不定时的方式动态回收无任何引用的对象占据的内存空间。   
需要注意的是：垃圾回收回收的是无任何引用的对象占据的内存空间而不是对象本身。   
两种常用的方法是引用计数和对象引用遍历。   
引用计数：在这种方法中，堆中每个对象（不是引用）都有一个引用计数。当一个对象被创建时，且将该对象分配给一个变量，该变量计数设置为1。当任何其它变量被赋值为这个对象的引用时，计数加1（a = b,则b引用的对象+1），但当一个对象的某个引用超过了生命周期或者被设置为一个新值时，对象的引用计数减1。任何引用计数为0的对象可以被当作垃圾收集。当一个对象被垃圾收集时，它引用的任何对象计数减1。   
对象引用遍历：从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集。

#  序列化和反序列化 #

序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。   
序列化的目的　　   
1、以某种存储形式使自定义对象持久化；　　   
2、将对象从一个地方传递到另一个地方。　　   
3、使程序更具维护性   
当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为对象。   
把对象转换为字节序列的过程称为对象的序列化。   
把字节序列恢复为对象的过程称为对象的反序列化。   
说的再直接点，序列化的目的就是为了跨进程传递格式化数据

#  Java的灵活性体现在什么机制上？ #

反射机制

#  Sleep和wait的区别 #

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

#  IO和NIO #

1、IO是面向流的，NIO是面向缓冲区的。   
Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。   
2、Java IO的各种流是阻塞的，Java NIO的非阻塞模式。   
Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。   
3、Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。而Java IO无选择器。

#  Scoket #

对于一个功能齐全的Socket，都要包含以下基本结构，其工作过程包含以下四个基本的步骤：   
　　（1） 创建Socket；   
　　（2） 打开连接到Socket的输入/出流；   
　　（3） 按照一定的协议对Socket进行读/写操作；   
　　（4） 关闭Socket.   
　　   
　　可参考博客：   
[http://www.cnblogs.com/linzheng/archive/2011/01/23/1942328.html][http_www.cnblogs.com_linzheng_archive_2011_01_23_1942328.html]

#  深克隆、浅克隆 #

浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。   
深复制把要复制的对象所引用的对象都复制了一遍。

在java中只有单继承，如果要让一个类赋予新的特性，通常是使用接口来实现。   
在c++中支持多继承，允许一个子类同时具有多个父类的接口和功能。

#  UDP和TCP #

UDP和TCP都属于传输层协议。   
TCP协议：面向连接的、可靠的、基于字节流   
UDP协议：无连接、不可靠、基于报文   
1、TCP协议中包含了专门的传递保证机制，当数据接收方收到发送方传来的信息时，会自动向发送方发出确认消息；发送方只有在接收到该确认消息之后才继续传送其它信息，否则将一直等待直到收到确认信息为止。   
与TCP不同，UDP协议并不提供数据传送的保证机制。如果在从发送方到接收方的传递过程中出现数据报的丢失，协议本身并不能做出任何检测或提示。因此，通常人们把UDP协议称为不可靠的传输协议。   
2、相对于TCP协议，UDP协议的另外一个不同之处在于如何接收突发性的多个数据报。不同于TCP，UDP并不能确保数据的发送和接收顺序。

#  红黑树 #

是一种自平衡二叉查找树，红黑树是一种很有意思的平衡检索树；每次插入的时候都要进行计算，保证二叉树的平衡；如果有2的N次方数据量级，查询的时候只需要查询N次即可。   
我们对任何有效的红黑树加以如下增补要求:   
1.节点是红色或黑色。   
2.根是黑色。   
3.所有叶子（外部节点）都是黑色。   
4.每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)   
5.从每个叶子到根的所有路径都包含相同数目的黑色节点。   
这些约束强制了红黑树的关键属性: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。

#  反射 #

反射机制指的是程序在运行时能够获取自身的信息。 将一个类的各个部分映射为不同的类----Package、Field、Method、Constractor  
用反射机制实现对数据库数据的增、查例子 。   
基本原理：保存数据时，把需要保存的对象的属性值全部取出来再拼凑sql语句；查询时，将查询到的数据全部包装成一个java对象。   
1）数据库的每一个表对应一个pojo类，表中的每一个字段对应pojo类的中的一个属性。 并且pojo类的名字和表的名字相同，属性名和字段名相同，大小写没有关系，因为数据库一般不区分大小写   
2）为pojo类中的每一个属性添加标准的set和get方法。

#  三次握手和四次挥手 #

三次握手：首先Client端发送连接请求报文，Server段接受连接后回复ACK报文，并为这次连接分配资源。Client端接收到ACK报文后也向Server段发送ACK报文，并分配资源，这样TCP连接就建立了。

四次握手：   
由于TCP连接是全双工的，因此每个方向都必须单独进行关闭。这原则是当一方完成它的数据发送任务后就能发送一个FIN来终止这个方向的连接。收到一个 FIN只意味着这一方向上没有数据流动，一个TCP连接在收到一个FIN后仍能发送数据。首先进行关闭的一方将执行主动关闭，而另一方执行被动关闭。   
（1） TCP客户端发送一个FIN，用来关闭客户到服务器的数据传送。   
（2） 服务器收到这个FIN，它发回一个ACK，确认序号为收到的序号加1。和SYN一样，一个FIN将占用一个序号。   
（3） 服务器关闭客户端的连接，发送一个FIN给客户端。   
（4） 客户端发回ACK报文确认，并将确认序号设置为收到序号加1。

#  Equals()和==　 #

1、java中equals和==的区别 值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。   
　　2、==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。   
　　3、equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。   
　　4、==比较的是2个对象的地址，而equals比较的是2个对象的内容，显然，当equals为true时，==不一定为true。

#  Java集合类 #

Java的集合类都位于java.util包中，Java集合中存放的是对象的引用，而非对象本身。

Java集合主要分为三种类型：   
1.Set（集）：集合中的对象不按特定方式排序，并且没有重复对象。它的有些实现类能对集合中的对象按特定方式排序。   
2.List（列表）：集合中的对象按索引位置排序，可以有重复对象，允许按照对象在集合中的索引位置检索对象。   
3.Map（映射）：集合中的每一个元素包含一对键对象和值对象，集合中没有重复的键对象，值对象可以重复。它的有些实现类能对集合中的键对象进行排序。   
Set、List和Map统称为Java集合。   
List和Set都继承Collection接口，而Map没有继承Collection接口。   
List的主要实现类有：ArrayList类, LinkedList类, Vector类。   
Set的主要实现类有：HashSet类，TreeSet类，LinkedHashSet类。   
Map的主要实现类有：HashMap类，HashTable类，TreeMap类，WeekHashMap类和IdentityHahMap类等。

#  set和list的区别 #

1、List,Set都是继承自Collection接口，均为接口   
2、List特点：元素有放入顺序，元素可重复   
Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）   
3、List接口有三个实现类：LinkedList，ArrayList，Vector ；   
Set接口有两个实现类：HashSet(底层由HashMap实现)， LinkedHashSet。

#  Hibernate中java的对象状态 #

在Hibernate中，对象有三种状态：临时状态、持久状态和游离状态。

临时状态：当new一个实体对象后，这个对象处于临时状态，即这个对象只是一个保存临时数据的内存区域，如果没有变量引用这个对象，则会被jre垃圾回收机制回收。这个对象所保存的数据与数据库没有任何关系，除非通过Session的save或者SaveOrUpdate把临时对象与数据库关联，并把数据插入或者更新到数据库，这个对象才转换为持久对象。

持久状态：持久化对象的实例在数据库中有对应的记录，并拥有一个持久化表示（ID）。对持久化对象进行delete操作后，数据库中对应的记录将被删除，那么持久化对象与数据库记录不再存在对应关系，持久化对象变成临时状态。持久化对象被修改变更后，不会马上同步到数据库，直到数据库事务提交。在同步之前，持久化对象是脏的（Dirty）。

游离状态：当Session进行了Close、Clear或者evict后，持久化对象虽然拥有持久化标识符和与数据库对应记录一致的值，但是因为会话已经消失，对象不在持久化管理之内，所以处于游离状态（也叫：脱管状态）。游离状态的对象与临时状态对象是十分相似的，只是它还含有持久化标识。

#  数据库事务的特性 #

数据库事务（Transaction）是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。一方面，当多个应用程序并发访问数据库时，事务可以在应用程序间提供一个隔离方法，防止互相干扰。另一方面，事务为数据库操作序列提供了一个从失败恢复正常的方法。   
事务具有四个特性：原子性（Atomicity）、一致性（Consistency）、隔离型（Isolation）、持久性（Durability），简称ACID。   
1 原子性（Atomicity）   
事务的原子性是指事务中的操作不可拆分，只允许全部执行或者全部不执行。   
2 一致性（Consistency）   
事务的一致性是指事务的执行不能破坏数据库的一致性，一致性也称为完整性。一个事务在执行后，数据库必须从一个一致性状态转变为另一个一致性状态。   
3 隔离性（Isolation）   
事务的隔离性是指并发的事务相互隔离，不能互相干扰。   
4 持久性（Durability）   
事务的持久性是指事务一旦提交，对数据的状态变更应该被永久保存。

#  数据库事务隔离级别及锁机制 #

为了平衡隔离性能，SQL92规范定义了四个事务隔离级别：读未提交（Read Uncommitted）、读已提交（Read Committed）、可重复读（Repeatable Read）、串行化（Serializable）。四个级别逐渐增强，每个级别解决上个级别的一个问题。   
1 读未提交（Read Uncommitted）   
另一个事务修改了数据，但尚未提交，而本事务中的select会读到这些未被提交的数据（也称脏读）。   
2 读已提交（Read Committed）   
本事务读取到的是最新的数据（其他事务提交后的）。问题是，在同一个事务里，前后两次相同的select会读到不同的结果（不可重复读）。   
不可重复读是指同一个事务执行过程中，另外一个事务提交了新数据，因此本事务先后两次读到的数据结果会不一致。   
3 可重复读（Repeatable Read）   
在同一个事务里，select的结果是事务开始时间点的状态，同样的select操作读到的结果会是一致的。但是，会有幻读现象。   
不可重复读保证了同一个事务里，查询的结果都是事务开始时的状态（一致性）。但是，如果另一个事务同时提交了新数据，本事务再更新时，就会发现了这些新数据，貌似之前读到的数据是幻觉，这就是幻读。   
4 串行化（Serializable）   
所有事务只能一个接一个串行执行，不能并发。

隔离级别的选择   
事务隔离级别越高，越能保证数据的一致性，但对并发性能影响越大，一致性和高性能必须有所取舍或折中。   
一般情况下，多数应用程序可以选择将数据库的隔离级别设置为读已提交，这样可以避免脏读，也可以得到不错的并发性能。尽管这个隔离级别会导致不可重复度、幻读，但这种个别场合应用程序可以通过主动加锁进行并发控制。

[http://www.songjie.info/%E3%80%90%E8%BD%AC%E8%BD%BD%E3%80%91%E6%95%B0%E6%8D%AE%E5%BA%93%E4%BA%8B%E5%8A%A1%E9%9A%94%E7%A6%BB%E7%BA%A7%E5%88%AB%E5%92%8C%E9%94%81%E5%AE%9E%E7%8E%B0%E6%9C%BA%E5%88%B6/][http_www.songjie.info_E3_80_90_E8_BD_AC_E8_BD_BD_E3_80_91_E6_95_B0_E6_8D_AE_E5_BA_93_E4_BA_8B_E5_8A_A1_E9_9A_94_E7_A6_BB_E7_BA_A7_E5_88_AB_E5_92_8C_E9_94_81_E5_AE_9E_E7_8E_B0_E6_9C_BA_E5_88_B6]

#  HTTP报文包含内容 #

![http报文内容][http]

#  TCP/IP三次握手和四次挥手 #

TCP是主机对主机层的传输控制协议，提供可靠的连接服务，采用三次握手确认建立一个连接:   
位码即tcp标志位,有6种标示:SYN(synchronous建立联机) ACK(acknowledgement 确认) PSH(push传送) FIN(finish结束) RST(reset重置) URG(urgent紧急)   
Sequence number(顺序号码) Acknowledge number(确认号码)

##  三次握手 ##

第一次握手：主机A发送位码为syn＝1,随机产生seq number=1234567的数据包到服务器，主机B由SYN=1知道，A要求建立联机；   
第二次握手：主机B收到请求后要确认联机信息，向A发送ack number=(主机A的seq+1),syn=1,ack=1,随机产生seq=7654321的包   
第三次握手：主机A收到后检查ack number是否正确，即第一次发送的seq number+1,以及位码ack是否为1，若正确，主机A会再发送ack number=(主机B的seq+1),ack=1，主机B收到后确认seq值与ack=1则连接建立成功。   
完成三次握手，主机A与主机B开始传送数据。

##  四次挥手 ##

所谓四次挥手（Four-Way Wavehand）即终止TCP连接，就是指断开一个TCP连接时，需要客户端和服务端总共发送4个包以确认连接的断开。在socket编程中，这一过程由客户端或服务端任一方执行close来触发，   
（1）第一次挥手：Client发送一个FIN，用来关闭Client到Server的数据传送，Client进入FIN\_WAIT\_1状态。   
（2）第二次挥手：Server收到FIN后，发送一个ACK给Client，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号），Server进入CLOSE\_WAIT状态。   
（3）第三次挥手：Server发送一个FIN，用来关闭Server到Client的数据传送，Server进入LAST\_ACK状态。   
（4）第四次挥手：Client收到FIN后，Client进入TIME\_WAIT状态，接着发送一个ACK给Server，确认序号为收到序号+1，Server进入CLOSED状态，完成四次挥手。

#  JVM内存 #

JVM 分配内存进入以下区域   
1： Heap   
2：Stack   
3：Code   
4：Static   
jvm有效的管理分配到这几个内存区域。   
Code section 代码区 包含这个 字节码文件 (byte code)   
Stack section (栈区域) 包含 方法（methods） ，局部变量 （Local variables） 和 引用变量（ reference variables）   
Heap section （堆区域）包含 对象 （也许会包含引用变量（下面的例子中有提到））   
Static section (静态区域) 包含 静态数据/ 方法 （Static 数据 和 方法 为 类的方法，隶属于类）   
1：当一个方法被调用时， a frame 是被创建在 栈顶。   
2：一旦方法完成执行，控制流返回正在调用的方法，stack 中 frame 被 清空（flushed）   
3：局部变量是在栈中创建。   
4：实例变量在堆中创建， 是对象的一部分，实例变量 依附于对象。   
5：引用变量是在栈中创建。   
重点内容关于jvm特推荐一篇博客如下：   
[http://blog.csdn.net/tonytfjing/article/details/44278233][http_blog.csdn.net_tonytfjing_article_details_44278233]   
再附一篇：   
[http://blog.csdn.net/u012152619/article/details/46968883][http_blog.csdn.net_u012152619_article_details_46968883]

#  JVM垃圾回收 #

1.JVM的gc概述   
　　gc即垃圾收集机制是指jvm用于释放那些不再使用的对象所占用的内存。   
　　垃圾收集的目的在于清除不再使用的对象。gc通过确定对象是否被活动对象引用来确定是否收集该对象。gc首先要判断该对象是否是时候可以收集。两种常用的方法是引用计数和对象引用遍历。   
　　1）引用计数   
　　引用计数存储对特定对象的所有引用数，也就是说，当应用程序创建引用以及引用超出范围时，jvm必须适当增减引用数。当某对象的引用数为0时，便可以进行垃圾收集。   
　 2）对象引用遍历   
　　早期的jvm使用引用计数，现在大多数jvm采用对象引用遍历。对象引用遍历从一组对象开始，沿着整个对象图上的每条链接，递归确定可到达（reachable）的对象。如果某对象不能从这些根对象的一个（至少一个）到达，则将它作为垃圾收集。在对象遍历阶段，gc必须记住哪些对象可以到达，以便删除不可到达的对象，这称为标记（marking）对象。   
　　下一步，gc要删除不可到达的对象。删除时，有些gc只是简单的扫描堆栈，删除未标记的对象，并释放它们的内存以生成新的对象，这叫做清除（sweeping）。这种方法的问题在于内存会分成好多小段，而它们不足以用于新的对象，但是组合起来却很大。因此，许多gc可以重新组织内存中的对象，并进行压缩（compact），形成可利用的空间。   
　　为此，gc需要停止其他的活动活动。这种方法意味着所有与应用程序相关的工作停止，只有gc运行。结果，在响应期间增减了许多混杂请求。另外，更复杂的 gc不断增加或同时运行以减少或者清除应用程序的中断。有的gc使用单线程完成这项工作，有的则采用多线程以增加效率。   
2.几种垃圾回收机制   
　　1）标记－清除收集器   
　　这种收集器首先遍历对象图并标记可到达的对象，然后扫描堆栈以寻找未标记对象并释放它们的内存。这种收集器一般使用单线程工作并停止其他操作。   
　　2）标记－压缩收集器   
　　有时也叫标记－清除－压缩收集器，与标记－清除收集器有相同的标记阶段。在第二阶段，则把标记对象复制到堆栈的新域中以便压缩堆栈。这种收集器也停止其他操作。   
　　3）复制收集器   
　　这种收集器将堆栈分为两个域，常称为半空间。每次仅使用一半的空间，jvm生成的新对象则放在另一半空间中。gc运行时，它把可到达对象复制到另一半空间，从而压缩了堆栈。这种方法适用于短生存期的对象，持续复制长生存期的对象则导致效率降低。   
　　4）增量收集器   
　　增量收集器把堆栈分为多个域，每次仅从一个域收集垃圾。这会造成较小的应用程序中断。   
　　5）分代收集器   
　　这种收集器把堆栈分为两个或多个域，用以存放不同寿命的对象。jvm生成的新对象一般放在其中的某个域中。过一段时间，继续存在的对象将获得使用期并转入更长寿命的域中。分代收集器对不同的域使用不同的算法以优化性能。   
　　6）并发收集器   
　　并发收集器与应用程序同时运行。这些收集器在某点上（比如压缩时）一般都不得不停止其他操作以完成特定的任务，但是因为其他应用程序可进行其他的后台操作，所以中断其他处理的实际时间大大降低。   
　　7）并行收集器   
　　并行收集器使用某种传统的算法并使用多线程并行的执行它们的工作。在多cpu机器上使用多线程技术可以显著的提高java应用程序的可扩展性。   
　　   
　　JVM垃圾回收器的工作原理   
[https://www.ibm.com/developerworks/cn/java/j-lo-JVMGarbageCollection/][https_www.ibm.com_developerworks_cn_java_j-lo-JVMGarbageCollection]

#  JVM调优 #

[http://blog.csdn.net/gzh0222/article/details/8363032?cm\_mc\_uid=52295834175414590497670&cm\_mc\_sid\_50200000=1459049767][http_blog.csdn.net_gzh0222_article_details_8363032_cm_mc_uid_52295834175414590497670_cm_mc_sid_50200000_1459049767]

#  MVC的各个部分都由那些技术来实现? #

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

AOP：设计模式   
IOC：反射机制

#  arrayList底层如何扩展的？ #

arraylist的java底层实现：

public boolean add(E e) \{   
ensureCapacityInternal(size + 1); // Increments modCount!!   
elementData\[size++\] = e;   
return true;   
\}   
arraylist的add方法底层实际就是一个数组，如果这个数组满了就将创建比旧数组大的新数组，然后复制旧数组到新数组中去 。

#  hashmap的实现 #

推荐几篇博客，它们具体阐释了hashmap：   
[http://yikun.github.io/2015/04/01/Java-HashMap%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E5%8F%8A%E5%AE%9E%E7%8E%B0/][http_yikun.github.io_2015_04_01_Java-HashMap_E5_B7_A5_E4_BD_9C_E5_8E_9F_E7_90_86_E5_8F_8A_E5_AE_9E_E7_8E_B0]

[http://my.oschina.net/hosee/blog/618953][http_my.oschina.net_hosee_blog_618953]

#  Servlet生命周期及工作原理 #

Servlet生命周期分为三个阶段：   
　　1，初始化阶段 ：调用init()方法   
　　2，响应客户请求阶段：调用service()方法   
　　3，终止阶段：调用destroy()方法   
Servlet工作原理：   
　 　Servlet接收和响应客户请求的过程：首先客户发送一个请求，Servlet是调用service()方法对请求进行响应的，通过 源代码可见，service()方法中对请求的方式进行了匹配，选择调用doGet,doPost等这些方法，然后再进入对应的方法中调用逻辑层的方法， 实现对客户的响应。

在Servlet接口和GenericServlet中是没有doGet、doPost等这些方法的，HttpServlet中定义 了这些方法，但是都是返回error信息，所以，我们每次定义一个Servlet的时候，都必须实现doGet或doPost等这些方法。   
每一个自定义的Servlet都必须实现Servlet的接口，Servlet接口中定义了五个方法，其中比较重要的三个方法涉及到Servlet的生命周期，分别是上文提到的init()、service()、destroy()方法。GenericServlet是一个通用的，不特定于任何协议的 Servlet,它实现了Servlet接口。而HttpServlet继承于GenericServlet，因此HttpServlet也实现了 Servlet接口。所以我们定义Servlet的时候只需要继承HttpServlet即可。   
Servlet接口和 GenericServlet是不特定于任何协议的，而HttpServlet是特定于HTTP协议的类，所以HttpServlet中实现了 service()方法，并将请求ServletRequest,ServletResponse强转为HttpRequest和 HttpResponse。

[Java_http_blog.csdn.net_xxssyyyyssxx_article_details_50423694]: http://blog.csdn.net/xxssyyyyssxx/article/details/50423694
[structs2]: /images/20220326/f5ebf21a8da24086b34ab708bbb66656.png
[20160326132924899]: /images/20220326/f69ef5b64ff04214aa8adabf0f3fd1e2.png
[http_blog.csdn.net_haolongabc_article_details_7249098]: http://blog.csdn.net/haolongabc/article/details/7249098
[20160326170707714]: /images/20220326/72772ff03d6a42d29e7be87843ac54c6.png
[collection]: /images/20220326/cb28ef3bfdf5432b98520cecb52a945f.png
[http_liqianglv2005.iteye.com_blog_2025016]: http://liqianglv2005.iteye.com/blog/2025016
[http_www.cnblogs.com_linzheng_archive_2011_01_23_1942328.html]: http://www.cnblogs.com/linzheng/archive/2011/01/23/1942328.html
[http_www.songjie.info_E3_80_90_E8_BD_AC_E8_BD_BD_E3_80_91_E6_95_B0_E6_8D_AE_E5_BA_93_E4_BA_8B_E5_8A_A1_E9_9A_94_E7_A6_BB_E7_BA_A7_E5_88_AB_E5_92_8C_E9_94_81_E5_AE_9E_E7_8E_B0_E6_9C_BA_E5_88_B6]: http://www.songjie.info/%E3%80%90%E8%BD%AC%E8%BD%BD%E3%80%91%E6%95%B0%E6%8D%AE%E5%BA%93%E4%BA%8B%E5%8A%A1%E9%9A%94%E7%A6%BB%E7%BA%A7%E5%88%AB%E5%92%8C%E9%94%81%E5%AE%9E%E7%8E%B0%E6%9C%BA%E5%88%B6/
[http]: /images/20220326/2566cad2386c4e619f702205fadbedc5.png
[http_blog.csdn.net_tonytfjing_article_details_44278233]: http://blog.csdn.net/tonytfjing/article/details/44278233
[http_blog.csdn.net_u012152619_article_details_46968883]: http://blog.csdn.net/u012152619/article/details/46968883
[https_www.ibm.com_developerworks_cn_java_j-lo-JVMGarbageCollection]: https://www.ibm.com/developerworks/cn/java/j-lo-JVMGarbageCollection/
[http_blog.csdn.net_gzh0222_article_details_8363032_cm_mc_uid_52295834175414590497670_cm_mc_sid_50200000_1459049767]: http://blog.csdn.net/gzh0222/article/details/8363032?cm_mc_uid=52295834175414590497670&cm_mc_sid_50200000=1459049767
[http_yikun.github.io_2015_04_01_Java-HashMap_E5_B7_A5_E4_BD_9C_E5_8E_9F_E7_90_86_E5_8F_8A_E5_AE_9E_E7_8E_B0]: http://yikun.github.io/2015/04/01/Java-HashMap%E5%B7%A5%E4%BD%9C%E5%8E%9F%E7%90%86%E5%8F%8A%E5%AE%9E%E7%8E%B0/
[http_my.oschina.net_hosee_blog_618953]: http://my.oschina.net/hosee/blog/618953