Java面试题

一、 基础题

1. 面向对象的特征有哪些方面? 

答：面向对象的特征主要有下面几个方面：

1) 抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。

抽象并不打算了解所有问题，而仅仅是选择当中的一部分，临时不用部分细节。抽象包含两个方面。一是过程抽象,二是数据抽象。

2) 继承：继承是一种联结类的层次模型，而且同意和鼓舞类的重用。它提供了一种明白表述共性的方法。对象的一个新类能够从现有的类中派生。这个过程称为类继承。

新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类能够从它的基类那里继承方法和实例变量。而且类能够改动或添加新的方法使之更适合特殊的须要。

3) 封装：封装是把过程和数据包围起来，对数据的訪问仅仅能通过已定义的界面。面向对象计算始于这个基本概念。即现实世界能够被描绘成一系列全然自治、封装的对象,这些对象通过一个受保护的接口訪问其它对象。

4) 多态性：多态性是指同意不同类的对象对同一消息作出响应。

多态性包括參数化多态性和包括多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，非常好的攻克了应用程序函数同名问题。

2. abstract class和interface有什么差别?

 

答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类。并为该类声明方法，但不能在该类中实现该类的情况。

不能创建abstract 类的实例。然而能够创建一个变量，其类型是一个抽象类，并让它指向详细子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的全部抽象方法提供实现，否则它们也是抽象类为。取而代之。在子类中实现该方法。知道其行为的其他类能够在类中实现这些方法。接口（interface）是抽象类的变体。

新型多继承性可通过实现这种接口而获得。接口中的全部方法都是抽象的，全部成员变量都是public static final的。一个类能够实现多个接口，当类实现特殊接口时，它定义（即将程序体给予）全部这种接口的方法。然后，它能够在实现了该接口的类的不论什么对象上调用接口的方法。

因为有抽象类，它同意使用接口名作为引用变量的类型。通常的动态联编将生效。引用能够转换到接口类型或从接口类型转换。instanceof 运算符能够用来决定某对象的类是否实现了接口。

 

3. String,  StringBuffer  StringBuilder的差别。

答： String的长度是不可变的；

StringBuffer的长度是可变的。假设你对字符串中的内容常常进行操作，特别是内容要改动时。那么使用StringBuffer。假设最后须要String，那么使用StringBuffer的toString()方法；线程安全。

StringBuilder是从 JDK 5 開始，为StringBuffer该类补充了一个单个线程使用的等价类。通常应该优先使用 StringBuilder 类，由于它支持全部同样的操作，但由于它不运行同步，所以速度更快。

4. List、Map、Set三个接口，存取元素时。各有什么特点？

答：List 以特定次序来持有元素，可有反复元素。Set 无法拥有反复元素,内部排序。Map 保存key-value值，value可多值。

5. Hibernate的查询方式 

Sql、Criteria,object comptosition 

Hql： 

1、 属性查询 

2、 參数查询、命名參数查询 

3、 关联查询 

4、 分页查询 

5、 统计函数 

6. sleep() 和 wait() 有什么差别? 

答：sleep是线程类（Thread）的方法。导致此线程暂停运行指定时间。给运行机会给其它线程。可是监控状态依旧保持。到时后会自己主动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，仅仅有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

7. Hibernate中如何实现类之间的关系?(如：一对多、多对多的关系) 

类与类之间的关系主要体如今表与表之间的关系进行操作，它们都市对对象进行操作。我们程序中把全部的表与类都映射在一起。它们通过配置文件里的many-to-one、one-to-many、many-to-many、 

8. 启动一个线程是用run()还是start()?

答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可执行状态，这意味着它能够由JVM调度并执行。

这并不意味着线程就会马上执行。run()方法能够产生必须退出的标志来停止一个线程。

9. 多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?

 

答：多线程有两种实现方法，各自是继承Thread类与实现Runnable接口 ,同步的实现方面有两种，各自是synchronized,wait与notify。

10. 什么是java序列化。怎样实现java序列化？

答：序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。

能够对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。

序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将须要被序列化的类实现Serializable接口。该接口没有需实现的方法。implements Serializable仅仅是为了标注该对象是可被序列化的，然后使用一个输出流(如FileOutputStream)来构造一个ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的writeObject(Object obj)方法就能够将參数为obj的对象写出(即保存其状态)。要恢复的话则用输入流。

11. java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们各自是哪些类？

答：字节流，字符流。字节流继承于InputStream、OutputStream。字符流继承于Reader、Writer。在java.io包中还有更多的流。主要是为了提高性能和使用方便。

12. UML是什么？经常使用的几种图？

答：UML是标准建模语言。经常使用图包含：用例图,静态图(包含类图、对象图和包图),行为图,交互图(顺序图,合作图),实现图。

13. try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被运行，什么时候被运行，在return前还是后?

 

答：会运行，在return前运行。

14. JAVA语言怎样进行异常处理，keyword：throws,throw,try,catch,finally分别代表什么意义？在try块中能够抛出异常吗？

答：Java通过面向对象的方法进行异常处理。把各种不同的异常进行分类，并提供了良好的接口。在Java中，每一个异常都是一个对象，它是Throwable类或其他子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包括有异常信息，调用这个对象的方法能够捕获到这个异常并进行处理。

Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。普通情况下是用try来运行一段程序。假设出现异常，系统会抛出（throws）一个异常，这时候你能够通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理；

  try用来指定一块预防全部“异常”的程序；

   catch子句紧跟在try块后面，用来指定你想要捕捉的“异常”的类型；

   throw语句用来明白地抛出一个“异常”； 

   throws用来标明一个成员函数可能抛出的各种“异常”； 

   Finally为确保一段代码无论发生什么“异常”都被运行一段代码。

能够在一个成员函数调用的外面写一个try语句，在这个成员函数内部写还有一个try语句保护其它代码。每当遇到一个try语句，“异常”的框架就放到堆栈上面，直到全部的try语句都完毕。假设下一级的try语句没有对某种“异常”进行处理，堆栈就会展开。直到遇到有处理这样的“异常”的try语句。

15. final, finally, finalize的差别? 

答：final：修饰符（keyword）。假设一个类被声明为final。意味着它不能再派生出新的子类，不能作为父类被继承，因此一个类不能既被声明为 abstract的，又被声明为final的；将变量或方法声明为final，能够保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中仅仅能读取，不可改动；被声明为final的方法也相同仅仅能使用，不能重载。 

finally：再异常处理时提供 finally 块来运行不论什么清除操作；假设抛出一个异常，那么相匹配的 catch 子句就会运行。然后控制就会进入 finally 块（假设有的话）。

finalize：方法名；Java 技术同意使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这种方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。

它是在 Object 类中定义的。因此全部的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者运行其它清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

16. 静态变量和实例变量的差别？

答：静态变量也称为类变量。归全类共同拥有，它不依赖于某个对象，可通过类名直接訪问；而实例变量必须依存于某一实例。仅仅能通过对象才干訪问到它。

17. 垃圾回收器的基本原理是什么？垃圾回收器能够立即回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

答：对于GC来说。当程序猿创建对象时，GC就開始监控这个对象的地址、大小以及使用情况。

通常。GC採用有向图的方式记录和管理堆(heap)中的全部对象。通过这样的方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时。GC就有责任回收这些内存空间。能够。程序猿能够手动运行System.gc()，通知GC运行，可是Java语言规范并不保证GC一定会运行。

18. 接口是否可继承接口?

 抽象类是否可实现(implements)接口?

 抽象类是否可继承实体类(concrete class)?

 

答：接口能够继承接口。抽象类能够实现(implements)接口，抽象类可继承实体类。但前提是实体类必须有明白的构造函数。

19. 在java中一个类被声明为final类型，表示了什么意思？

答：表示该类不能被继承。是顶级类。

二、 简答题（无标准答案，看理解的深度）

1. Java中经常使用的设计模式有哪几种，说说你使用过的设计模式和使用场景以及对其理解？（考察应聘者对设计模式的理解）

答：Java中的23种设计模式：Factory（工厂模式），Builder（建造模式）， Factory Method（工厂方法模式），Prototype（原始模型模式）。Singleton（单例模式）， Facade（门面模式），Adapter（适配器模式）， Bridge（桥梁模式）， Composite（合成模式）。Decorator（装饰模式）。 Flyweight（享元模式）， Proxy（代理模式），Command（命令模式）， Interpreter（解释器模式）， Visitor（訪问者模式），Iterator（迭代子模式）。 Mediator（调停者模式）。 Memento（备忘录模式）。Observer（观察者模式），State（状态模式），Strategy（策略模式），Template Method（模板方法模式）。 Chain Of Responsibleity（责任链模式）。

2. 你对软件开发中迭代的含义的理解；（考察应聘者对项目管理的理解）

答：软件开发中。各个开发阶段不是顺序运行的，应该是并行运行,也就是迭代的意思。这样对于开发中的需求变化，及人员变动都能得到更好的适应。

3. 说说数据库性能的理解、以及假设提高数据库的性能。

4. 谈谈自己使用过的开源框架，以及熟悉程度。

经常使用的开源框架有Spring, Struts, Ibatis, Hibernate

5. Hibernate工作原理及为什么要用？

原理：  1.读取并解析配置文件 

2.读取并解析映射信息，创建SessionFactory 

3.打开Sesssion 

4.创建事务Transation 

5.持久化操作 

6.提交事务 

7.关闭Session 

8.关闭SesstionFactory 

为什么要用： 

1. 对JDBC訪问数据库的代码做了封装。大大简化了数据訪问层繁琐的反复性代码。

 

2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他非常大程度的简化DAO层的编码工作 

3. hibernate使用Java反射机制。而不是字节码增强程序来实现透明性。 

4. hibernate的性能非常好。由于它是个轻量级框架。映射的灵活性非常出色。

它支持各种关系数据库。从一对一到多对多的各种复杂关系。 

6. Hibernate是怎样延迟载入? 

1. Hibernate2延迟载入实现：a)实体对象 b)集合（Collection） 

2. Hibernate3 提供了属性的延迟载入功能 

当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟载入，他节省了server的内存开销，从而提高了server的性能。 

7. 说下Hibernate的缓存机制 

1. 内部缓存存在Hibernate中又叫一级缓存。属于应用事物级缓存 

2. 二级缓存： 

a) 应用及缓存 

b) 分布式缓存 

条件：数据不会被第三方改动、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 重要数据 

c) 第三方缓存的实现 

8. 怎样优化Hibernate？ 

1.使用双向一对多关联，不使用单向一对多 

2.灵活使用单向一对多关联 

3.不用一对一，用多对一代替 

4.配置对象缓存，不使用集合缓存 

5.一对多集合使用Bag,多对多集合使用Set 

6. 继承类使用显式多态 

7. 表字段要少。表关联不要怕多。有二级缓存撑腰 

9. Struts工作机制？为什么要使用Struts？ 

工作机制： 

Struts的工作流程: 

在web应用启动时就会载入初始化ActionServlet,ActionServlet从 

struts-config.xml文件里读取配置信息,把它们存放到各种配置对象 

当ActionServlet接收到一个客户请求时,将运行例如以下流程. 

-(1)检索和用户请求匹配的ActionMapping实例,假设不存在,就返回请求路径无效信息; 

-(2)假设ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中; 

-(3)依据配置信息决定是否须要表单验证.假设须要验证,就调用ActionForm的validate()方法; 

-(4)假设ActionForm的validate()方法返回null或返回一个不包括ActionMessage的ActuibErrors对象, 就表示表单验证成功; 

-(5)ActionServlet依据ActionMapping所包括的映射信息决定将请求转发给哪个Action,假设对应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法; 

-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件; 

-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户; 

 

为什么要用： 

JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统很的繁乱。所以在此之上，我们须要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。

 

 

基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件 

 

8． Struts的validate框架是怎样验证的？ 

在struts配置文件里配置详细的错误提示。再在FormBean中的validate()方法详细调用。 

 

9． 说下Struts的设计模式 

MVC模式: web应用程序启动时就会载入并初始化ActionServler。

用户提交表单时，一个配置好的ActionForm对象被创建。并被填入表单对应的数 据。ActionServler依据Struts-config.xml文件配置好的设置决定是否须要表单验证，假设须要就调用ActionForm的 Validate（）验证后选择将请求发送到哪个Action，假设Action不存在，ActionServlet会先创建这个对象，然后调用 Action的execute（）方法。Execute（）从ActionForm对象中获取数据。完毕业务逻辑，返回一个ActionForward对 象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动 态的网页，返回给客户。 

 

10． spring工作机制及为什么要用? 

1.spring mvc请全部的请求都提交给DispatcherServlet,它会托付应用系统的其它模块负责负责对请求进行真正的处理工作。

 

2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller. 

3.DispatcherServlet请请求提交到目标Controller 

4.Controller进行业务逻辑处理后，会返回一个ModelAndView 

5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象 

6.视图对象负责渲染返回给client。 

 

为什么用： 

{AOP 让开发者能够创建非行为性的关注点。称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后。公共服务 （比 如日志、持久性、事务等）就能够分解成方面并应用到域对象上。同一时候不会添加域对象的对象模型的复杂性。

 

IOC 同意创建一个能够构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。

 

Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，仅仅要用 JavaBean 属性和配置文件增加依赖性（协作对象）。然后能够非常easy地在须要时替换具有类似接口的协作对象。} 

 

 

 

 

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所看到的。 

 

组成 Spring 框架的每一个模块（或组件）都能够单独存在。或者与其它一个或多个模块联合实现。

每一个模块的功能例如以下： 

 

☆ 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory。它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。 

 

☆ Spring 上下文：Spring 上下文是一个配置文件。向 Spring 框架提供上下文信息。Spring 上下文包含企业服务。比如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

 

 

☆ Spring AOP：通过配置管理特性。Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，能够非常easy地使 Spring 框架管理的不论什么对象支持 AOP。

Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件。就能够将声明性事务管理集成到应用程序中。 

 

☆ Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。

异常层次结构简化了错误处理，而且极大地减少了须要编写 的异常代码数量（比如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。 

 

☆ Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，当中包含 JDO、Hibernate 和 iBatis SQL Map。

全部这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

 

 

☆ Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上。为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求參数绑定到域对象的工作。 

 

☆ Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的。MVC 容纳了大量视图技术，当中包含 JSP、Velocity、Tiles、iText 和 POI。 

 

Spring 框架的功能能够用在不论什么 J2EE server中，大多数功能也适用于不受管理的环境。

Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据訪问对象。毫无疑问，这种对象能够在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、測试环境之间重用。 

 

IOC 和 AOP 

 

控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，可是描写叙述创建它们的方式。在代码中不直接与对象和服务连接。但在配置文件里描写叙述哪一个组件须要哪一项服务。容器 （在 Spring 框架中是 IOC 容器） 负责将这些联系在一起。 

 

在典型的 IOC 场景中。容器创建了全部对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。

下表列出了 IOC 的一个实现模式。 

 

 

 

 

Spring 框架的 IOC 容器採用类型 2 和类型3 实现。 

 

 

面向方面的编程 

 

面向方面的编程，即 AOP，是一种编程技术。它同意程序猿对横切关注点或横切典型的职责分界线的行为（比如日志和事务管理）进行模块化。AOP 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中。

 

 

AOP 和 IOC 是补充性的技术，它们都运用模块化方式解决企业应用程序开发中的复杂问题。

在典型的面向对象开发方式中，可能要将日志记录语句放在全部方法和 Java 类中才干实现日志功能。在 AOP 方式中，能够反过来将日志服务模块化。并以声明的方式将它们应用到须要日志的组件上。当然，优势就是 Java 类不须要知道日志服务的存在，也不须要考虑相关的代码。所以，用 Spring AOP 编写的应用程序代码是松散耦合的。 

 

AOP 的功能全然集成到了 Spring 事务管理、日志和其它各种特性的上下文中。

 

 

IOC 容器 

 

Spring 设计的核心是 org.springframework.beans 包。它的设计目标是与 JavaBean 组件一起使用。这个包通常不是由用户直接使用，而是由server将其用作其它多数功能的底层中介。下一个最高级抽象是 BeanFactory 接口，它是工厂设计模式的实现，同意通过名称创建和检索对象。BeanFactory 也能够管理对象之间的关系。 

 

BeanFactory 支持两个对象模型。 

 

□ 单态 模型提供了具有特定名称的对象的共享实例，能够在查询时对其进行检索。Singleton 是默认的也是最经常使用的对象模型。对于无状态服务对象非常理想。 

 

□ 原型 模型确保每次检索都会创建单独的对象。在每一个用户都须要自己的对象时，原型模型最适合。 

 

bean 工厂的概念是 Spring 作为 IOC 容器的基础。

IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个演示样例中演示的那样，Spring 框架使用 JavaBean 属性和配置数据来指出必须设置的依赖关系。 

 

BeanFactory 接口 

 

由于 org.springframework.beans.factory.BeanFactory 是一个简单接口，所以能够针对各种底层存储方法实现。

最经常使用的 BeanFactory 定义是 XmlBeanFactory，它依据 XML 文件里的定义装入 bean，如清单 1 所看到的。 

 

清单 1. XmlBeanFactory 

 

BeanFactory factory = new XMLBeanFactory(new FileInputSteam("mybean.xml")); 

 

在 XML 文件里定义的 Bean 是被消极载入的。这意味在须要 bean 之前，bean 本身不会被初始化。

要从 BeanFactory 检索 bean。仅仅需调用 getBean() 方法，传入将要检索的 bean 的名称就可以，如清单 2 所看到的。 

 

清单 2. getBean() 

 

MyBean mybean = (MyBean) factory.getBean("mybean"); 

 

每一个 bean 的定义都能够是 POJO （用类名和 JavaBean 初始化属性定义） 或 FactoryBean。

FactoryBean 接口为使用 Spring 框架构建的应用程序加入了一个间接的级别。