java面试问题汇总

java面试问题汇总（共9篇）

篇1：java面试问题汇总

什么是类与对象？

所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。

类是具备某些共同特征的实体的集合，它是一种抽象的概念，用程序设计的语言来说，类是一种抽象的数据类型，它是对所具有相同特征实体的抽象。

属性与方法？

不同对象具有相同特点，就可能抽象为一定的类，那么这些特点基本上可以分为两类，一类是描述对象静态状态的，就是对象的属性，在程序设计中，可以称之为变量；另一类是描述对象的动作，就是对象的方法，在程序设计中我们称之为函数。属性和方法是一个对象所具备的两大基本要素，也是我们后面编程工作的核心。

什么是封装？

只要有足够的方法，就没必要直接去操作对象属性，只要调用这些方法就可以实现要完成的任务，这种现象称为封装，它通过对象方法对其属性的操作把对象属性封装在一个对象内部，对象与外界打交道全部通过其自身的方法来实现，有效的把对象属性隐藏在对象内部。

编写 java文件的注意事项？

在记事本中编写java文件，在保存时一定要把文件名和扩展名用双引号括起来，否则将默认保存为文本文件，如果要保存的java 文件名为Program1.java,则在保存时在文件名文本框中一定要输入”Program1.java”。

如何编译java程序？

单击开始|运行命令，在命令行上输入cmd，按回车键（在 window98中输入command，按回车键），即可打开一个命令窗口，将目录转换到编写java源程序所在的目录，输入javac filename.java

如何执行java程序？

同样在命令窗口中输入java filename，基本数据类型？

Java的数据类型可以划分为4大类：整数，浮点数，字符型，布尔型。其中整数可以划分为：byte,short,int,long.浮点数可以划分为float,double.

篇2：java面试问题汇总

简单的说一下笔试，笔试这个环节是很容易通过的，无非就是几张试卷，一共也就十几道题。一般由5至10个选择题+2至5个论述题+1至2个编程题 组成。

接过笔试题之后，第一步要平静心态，第二步要浏览所有题目，第三步自然就是答题了~ 答题的时候，要先把自己会的快速的答上来，选择题自然不多说了，论述题根据自己的理解大致说明一下，多少会给你自己加分的。

编程题其实也不难，出现几率最大的是写一个关于某某设计模式的例子，而设计模式的编码例子，出现最多的是单例模式、工厂模式和代理模式。

有时候也会有一些算法的编码，一般是排序算法的编码实现。

还有的笔试题，会有一些程序题，就是看程序，然后自己写出运行结果，这样的问题考察的是对java基础知识的掌握，所以，有坚固的基础是很重要滴！

OK，笔试结束之后，下一个环节就是面试了，java程序员的一些面试问题主要有哪些呢？ 我个人认为主要有三方面： 1.关于java有关的技术问题 2.关于项目经验的问题

3.关于个人对团队的看法以及个人的职业规划

咱们就一条一条来看，大家看完之后找相关资料然后一条一条的应对

一、技术问题

Struts1原理和Struts2原理以及区别和联系，在什么项目中用过，有什么体会。

spring的原理 aop和ioc机制，如何使用，在哪个项目用到过？有什么体会。

简要说明一下StrutsMVC和SpringMVC。servlet的原理，生命周期。socket 原理以及使用方式 Linux常用命令，shell编程介绍 java常用算法

多线程、线程池、线程锁等等 二叉树、java数据结构

数据库mysql、Oracle的优缺点以及使用方法和sql语句，问的多的是如果模拟分页查询和多表查询

Java垃圾回收机制

敏捷开发的简要说明，是否了解 OOA/OOD/OOP 的含义 java加密与解密

java网络通信、http协议要素

是否熟悉设计模式？简要说一下自己所了解或者使用过的开发模式有哪些，在哪些场景中使用。

二、关于项目经验的问题

简要说一下你自己做过的自认为很不错的项目 你在项目中的职责，是否能够胜任之前的任务安排

在项目中遇到的问题，你是怎么解决的（一般这样的问题，可以说是自己解决，但是要讲明解决过程，一定要突出解决思路的灵活。也可以回答与同事讨论解决，这样可

以让面试官觉察到自己善于利用团队资源，会给自己的团队意识加分）

三、关于个人对团队的看法以及个人的职业规划 你怎么看待个人与团队，个人能力与团队协作的联系。在团队合作中，最重要的是什么？

如果团队成员对于某个问题出现意见分歧，应该如何解决？ 当对于上级有不满的时候，应该怎么解决？

团队的发展如何与个人的规划出现分歧，如何应对？ 如何快速融入新的团队，结交新的同事？

个人的职业规划和职业目标，例如近两年的目标，近五年的规划。如何看待企业文化，如何理解。

以上的全部内容，覆盖了有关java程序员面试中的90%的问题，希望大家可以根据这些问题，审视自己的不足之处，临阵磨枪！

篇3：学习Java应该注意的问题

Java自问世以来,以其得天独厚的优势,在IT业界掀起了研究、开发它的浪潮,显示了鹏程万里的美好前景。Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台(即JavaSE,JavaEE,JavaME)的总称。Java技术具有卓越的通用性、高效性、平台移植性和安全性,广泛应用于个人PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网,同时拥有全球最大的开发者专业社群。“连Internet,用Java编程”成为程序设计者的时尚。

2 Java及相关组件的学习顺序和方法

2.1 Java的学习顺序

在美国,80%以上的大学都在教授Java课程,在中国,许多高校都开设了Java课程,许多计算机培训机构都将Java作为主要编程语言来讲授。由于各种原因,很多人反映Java难学,在此根据自己学习的情况谈一下自己的看法。

2.1.1 循序渐进

学习Java应该循序渐进,不要妄想一下子就学会。最好开始找一本篇幅较短的入门书从学习那些最简单、最基本的东西开始。

2.1.2 课堂和视频结合

对于Java技术类的学习,课堂学习更应注意自身独立思考的过程,上课的时候,老师讲课的速度很快为了不遗漏要点,通常要仔细听,认真记,并要及时对技术知识点进行思考。课下要能对所学知识进行简单的理解,做到不会就问。如果选择视频学习的方式,相对来说可以减少记忆压力,其优点在于,通过视频学习应学会慢慢培养自己独立思考的能力,要有时间想,同时对特定的知识点可以重点重复看,重复做思考,这种学习方式类似于跟人做技术沟通。但缺点在于缺少老师指点,对于不会的和重要的知识点无法有更深的体会和把握。因此,最好能将课堂和视频双方面结合起来,进行学习。

2.1.3 了解底层机制

在学习的过程中,最好能够了解Java的底层机制,而不是仅仅停留在表层,不是抄书上的例子运行出结果就可以。要注意,即便对一个简单的例子也要有耐心去琢磨、调试、改动。此外,在学习的过程中一定要动手做、写代码,最好能参与一些实际的项目。

3 学习Java

3.1 分类

学习Java没有捷径可循,“唯手熟尔”,要想学好Java,首先要知道Java的大致分类。自从Sun推出Java以来,就力图使之无所不包,所以Java发展到现在,按应用来分主要分为3大块:J2SE,J2ME和J2EE,这也就是Sun ONE(Open Net Environment)体系。J2SE就是Java2的标准版,主要用于桌面应用软件的编程;J2ME主要应用于嵌入式系统开发,如手机和PDA的编程;J2EE是Java2的企业版,主要用于分布式的网络程序的开发,如电子商务网站ERP系统。J2SE开发桌面应用软件比起VC,VB,DEPHI这些传统开发语言来说,优势好象并不明显。J2ME对于初学者来说,又有点深奥,而且一般开发者很难有开发环境。所以现在应用最广泛又最好学的就是J2EE。J2EE又包括许多组件,如Jsp,Servlet,JavaBean,EJB,JDBC,JavaMail等。

3.2 学习J2EE

第一,建议从最基本的面向对象的语法开始,明白面向对象的概念和特征,然后熟悉Java常见的类库,其中包括I/O包,Util包,Lang包,Math包等等,这些都是学习Java最基本的内容,一定要熟悉并掌握。此外Java介入的领域很广泛,不同的领域有不同的API(Application ProgrammingInterface,应用程序设计接口),没有人熟悉所有的API,对一般人而言只是熟悉工作中要用到的API。如果做界面开发,那么需要学习Swing/AWT/SWT等API;如果进行网络游戏开发,需要深入了解网络API/多媒体API/2D3D等;如果做Web开发,就需要熟悉Servlet等API。总之,需要根据工作的需要或兴趣发展方向去选择学习特定的API。

第二,学JSP。JSP就是在HTML中嵌入Java代码,它提供了一种简单快速地建立动态网页的技术。所以学习JSP必须要有HTML的基础。其实JSP中的Java语法也不多,它更象一个脚本语言,有点象ASP。

第三,该学一学Servlet了。Servlet就是服务器端小程序,它负责生成发送给客户端的HTML文件。JSP在执行时,也是先转换成Servlet再运行的。虽说JSP理论上可以完全取代Servlet,这也是SUN推出JSP的本意,可是Servlet用来控制流程跳转还是挺方便的,也令程序更清晰。

3.3 Javabean

以往JSP在html中嵌套Java代码的方式较为混乱,而与ASP的主要区别在于SUN提供了Javabean可以把JSP中的Java代码封装起来,便于调用也便于重用。接着就是EJB了,EJB就是Enterprise JavaBean,看名字好象它是Javabean,可是它和Javabean还是有区别的。它是一个体系结构,使用它可以搭建更安全、更稳定的企业应用。它的大量代码已由中间件(也就是Weblogic,Websphere这些J2EE服务器)完成了,所以使用时要做的程序代码量很少,大部分工作都在设计和配置中间件上。

3.4 JDBC

JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。JD-BC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序,有了JDBC,向各种关系数据发送SQL语句就是一件很容易的事。换言之,有了JDBC API,就不必为访问Sybase数据库专门写一个程序,为访问Oracle数据库又专门写一个程序,或为访问Informix数据库又编写另一个程序等等,程序员只需用JDBC API写一个程序就够了,它可向相应数据库发送SQL调用。

4 编程实践

对Java和J2EE有了一些基本概念之后,就应该练习开发一些程序。

4.1 阅读有实例且带光盘的书籍

最好找一些有实例且带光盘的书来看,这样看到好的程序就可以直接Ctrl+C再Ctrl+V复制粘贴下来,然后保存起来以备后用。还有就是要经常上一些好的Java论坛,遇到不会不懂的问题随时向别人提问,这样可以大大减少闭门造车浪费的时间。

4.2 读开放源码的程序

大家知道开放源码大都出自高手,这些源码设计合理,考虑周到,再加上有广大程序员的参与,所以读源码可以很好地提高编程水平。学Java必读的两个开源程序就是Jive和Pet Store.。Jive是国外一个非常著名的BBS程序,完全开放源码。论坛的设计采用了很多先进的技术,如Cache、用户认证、Filter、XML等,而且论坛完全屏蔽了对数据库的访问,可以很轻易地在不同数据库中移植。Pet Store(宠物店)是SUN公司为了演示其J2EE编程规范而推出的开放源码的程序,很具有权威性。

5 结语

虽然理论学习和程序训练双管齐下,但是距离学会Java还只是万里长征走完了第一步。具体一个项目需要进行组织设计和开发,靠一些散乱的代码是不可能做出来的,要学会Java最关键的是实际的工作经验,而不是书本上那些凭空想出来的程序。

只有参加Java实际项目的开发,熟悉和掌握开发的思路和过程,并且能够熟练运用Java开发项目的时候,才算是初步学会了Java,剩下的就是在实践中继续提高自己。

参考文献

篇4：生物高考DNA计算问题汇总

高考是对学生综合能力的考查，在高三复习中总结、归纳、提炼是提高学科能力的重要方法。DNA计算问题是高中生物的难点和重点，在老师的指导下，我将DNA计算问题总结汇编，与同学分享。

一、关于DNA分子结构的特点的计算

DNA分子是由4种脱氧核苷酸连接而成的两条脱氧核苷酸长链构成的，两条长链按照反向平行的方式盘旋成双螺旋结构。磷酸和脱氧核糖交替连接排列在外侧，构成了DNA分子的基本骨架；含氮碱基排列在内侧，两条单链上相对的碱基以氢键连接，碱基的配对是有规律的，即A一定与T配对（形成两个氢键），G一定与C配对（形成三个氢键）。

例1：下图为某同学在学习DNA结构后，画的含有两个碱基对的DNA片断（其中○表示磷酸）。下列几位同学对此图的评价，正确的是（）

A甲说：该图没有什么物质和结构上的错误

B乙说：该图有一处错误，就是U应改为T

C两说：三处错误，其中核糖应为脱氧核糖

D丁說：如图说画的是RNA双链，则正确

解析：选C。图中有三处错误，一、组成DNA的五碳糖应该是脱氧核糖，因此图中的核糖应改为脱氧核糖；错误二：碱基为A、T、G、C四种，其中图中的U应改为T；错误三，单链中脱氧核苷酸之间的连接方式不应该在磷酸和磷酸之间，而是在磷酸与脱氧核糖之间连接而成的。

二、碱基互补配对原则方面的计算

例2：某双链DNA分子中，A与T之和占整个DNA碱基总数的54%，其中一条链上G占该链碱基总数的22%，求别一条链上G占其所在链碱基总数的百分含量。

归纳一：在DNA分子的两条链中

1.互补配对的碱基两两相等，A=T，C=G，那么A+G=C+T，即嘌呤碱基总数等于嘧啶碱基总数。

2.两个不互补的碱基和的比值相等，即（A+G）/（C+T）=（A+C）/（G+T）=1。由此可鉴定DNA分子是单链还是双链。若在一个DNA分子中，（A+G）/（C+T）≠1，且A≠T、C≠G，说明此DNA分子为单链。若在一个DNA分子中，（A+G）/（C+T）=1，且A=T、C=G，说明此DNA分子为双链。

3.任两个不互补的碱基之和恒等，且占碱基总量的50%，即A+C=T+G=A+G=C+T=50%。

归纳二：在DNA分子的一条链中

1.一条链中的配对碱基不一定相等，即A1不一定等于T1、G1不一定等于C1、A2不一定等于T2、G2不一定等于C2（1、2代表DNA分子的两条链）。

2.若一条链中（A1+T1）/（C1+G1）=a，则另一条链中（A2+T2）/（C2+G2）=a（对等关系）；若一条链中（A1+G1）/（C1+T1）=b，则另一条链中（A2+G2）/（C2+T2）=1/b（倒数关系）。

3.在双链DNA分子中，一条链上的A与T的和占该链碱基比率等于另一条链上的A与T的和占该链碱基比率，还等于双链DNA分子中A与T的和占整个DNA分子的碱基比率。即（A1+T1）%=（A2+T2）%=（A+T）%，同理（G1+C1）%=（G2+C2）%=（G+C）%。

4.DNA分子中碱基对的排列顺序代表的是遗传信息，若某DNA分子由n个碱基对构成，则可代表的遗传信息有4n 种（其中n代表碱基对的个数）。

三、DNA分子的半保留复制方面的计算

例3：假设某大肠杆菌含14N的DNA的相对分子质量为a，若将其长期培养在含15N的培养基中便得到15N的DNA，相对分子质量为b，现将含15N的DNA大肠杆菌转移到14N的培养基中培养，子二代DNA的相对分子平均质量为：

A（a+b）/2 B（a+b）/4 C（3a+b）/4 D（a+3b）/4

解析：这题目最好从最后一句话开始。假如有一条含15N的DNA分子放到含14N的环境中培养，那么第二代，就会有4条，根据半保留复制。可以得知这4条中有两条完全由14N组成，另外两条就15N和14N各占一半。因此，含14N的DNA分子质量加起来是3a，含15N的DNA分子质量加起来是b，总共有4条DNA，所以平均起来就是（3a+b）/4

四、复制过程中所需游离脱氧核苷酸数的计算

例4：具有A个碱基对的一个DNA分子片段，含有m个腺嘌呤，则该片段第n次复制需要多少个游离的鸟嘌呤脱氧核苷酸

A（2n-1）·（A-m） B2n-1·（A-m）

C（2n-1）·（A/2-m） D2n·（A/2-m）

解析：亲代DNA分子中G=1/2×（2A-2m）=（A-m）个，该DNA分子复制n次共产生了2n个DNA分子，所以第n次复制产生了2n-1个DNA分子，所以第n次复制共需鸟嘌呤脱氧核苷酸的数目为2n-1·（A-m）个。

规律总结：1. 求复制n次总共需要游离的某脱氧核苷酸数

基于DNA的半保留复制，可以归纳出公式：X = m（2n1）。其中，X代表DNA复制过程中需要游离的某脱氧核苷酸数，m代表亲本DNA中该种脱氧核苷酸数，n表示复制次数。

2. 求复制第n次时需要游离的某脱氧核苷酸数。

篇5：java面试问题

你在这公司实习一个月学到了什么？

篇6：java面试问题及答案

如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。例如：

class t

{

transient int a; //不需要维持

int b; //需要维持

}

这里，如果t类的一个对象写入一个持久的存储区域，a的内容不被保存，但b的将被保存。

volatile修饰符告诉编译器被volatile修饰的变量可以被程序的其他部分改变。在多线程程序中，有时两个或更多的线程共享一个相同的实例变量。考虑效率问题，每个线程可以自己保存该共享变量的私有拷贝。实际的变量副本在不同的时候更新，如当进入synchronized方法时。 用strictfp修饰类或方法，可以确保浮点运算(以及所有切断)正如早期的java版本那样准确。切断只影响某些操作的指数。当一个类被strictfp修饰，所有的方法自动被strictfp修饰。

strictfp的意思是fp-strict，也就是说精确浮点的意思。在java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内java的编译器以及运行环境会完全依照浮点规范ieee-754来执行。因此如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。

你可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字，例如下面的代码：

strictfp interface a {}

public strictfp class fpdemo1 {

strictfp void f {}

}

2. 错误的使用方法

interface a {

strictfp void f();

}

public class fpdemo2 {

strictfp fpdemo2() {}

}

一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内所有浮点运算都是精确的，符合ieee-754规范

的。例如一个类被声明为strictfp，那么该类中所有的方法都是strictfp的。

2)抽象类和接口有什么区别?(瞬联)

1.abstract class 在 java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员(也就是必须是static final的，不过在 interface中一般不定义数据成员)，所有的成员方法都是abstract的。

3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是“is-a”关系，interface表示的是“like-a”关系。

4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。

6.抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

7.接口中的方法默认都是 public,abstract 类型的。

3)能说一下java的反射(reflection)机制吗?(瞬联)

开放性和原因连接(causally-connected)是反射系统的两大基本要素

4)在java中怎样实现多线程?(瞬联)

extends thread

implement runnable

方法一：继承 thread 类，覆盖方法 run()，我们在创建的 thread 类的子类中重写 run() ,加入线程所要执行的代码即可。下面是一个例子：

public class mythread extends thread

{

int count= 1, number;

public mythread(int num)

{

number = num;

system.out.println

(“创建线程 ” + number);

}

public void run() {

while(true) {

system.out.println

(“线程 ” + number + “:计数 ” + count);

if(++count== 6) return;

}

}

public static void main(string args[])

{

for(int i = 0;i 〈 5; i++) new mythread(i+1).start();

}

}

这种方法简单明了，符合大家的习惯，但是，它也有一个很大的缺点，那就是如果我们的类已经从一个类继承(如小程序必须继承自 applet 类)，则无法再继承 thread 类，这时如果我们又不想建立一个新的类，应该怎么办呢?

我们不妨来探索一种新的方法：我们不创建thread类的子类，而是直接使用它，那么我们只能将我们的方法作为参数传递给 thread 类的实例，有点类似回调函数。但是 java 没有指针，我们只能传递一个包含这个方法的类的实例。

那么如何限制这个类必须包含这一方法呢?当然是使用接口!(虽然抽象类也可满足，但是需要继承，而我们之所以要采用这种新方法，不就是为了避免继承带来的限制吗?)

java 提供了接口 java.lang.runnable 来支持这种方法。

方法二：实现 runnable 接口

runnable接口只有一个方法run()，我们声明自己的类实现runnable接口并提供这一方法，将我们的线程代码写入其中，就完成了这一部分的任务。但是runnable接口并没有任何对线程的支持，我们还必须创建thread类的实例，这一点通过thread类的构造函数 public thread(runnable target);来实现。下面是一个例子：

public class mythread implements runnable

{

int count= 1, number;

public mythread(int num)

{

number = num;

system.out.println(“创建线程 ” + number);

}

public void run()

{

while(true)

{

system.out.println

(“线程 ” + number + “:计数 ” + count);

if(++count== 6) return;

}

}

public static void main(string args[])

{

for(int i = 0; i 〈 5;i++) new thread(new mythread(i+1)).start();

}

}

严格地说，创建thread子类的实例也是可行的，但是必须注意的是，该子类必须没有覆盖 thread 类的 run 方法，否则该线程执行的将是子类的 run 方法，而不是我们用以实现runnable 接口的类的 run 方法，对此大家不妨试验一下。

使用 runnable 接口来实现多线程使得我们能够在一个类中包容所有的代码，有利于封装，它的缺点在于，我们只能使用一套代码，若想创建多个线程并使各个线程执行不同的代码，则仍必须额外创建类，如果这样的话，在大多数情况下也许还不如直接用多个类分别继承 thread 来得紧凑。

综上所述，两种方法各有千秋，大家可以灵活运用。

下面让我们一起来研究一下多线程使用中的一些问题。

三、线程的四种状态

1. 新状态：线程已被创建但尚未执行(start() 尚未被调用)。

2. 可执行状态：线程可以执行，虽然不一定正在执行。cpu 时间随时可能被分配给该线程，从而使得它执行。

3. 死亡状态：正常情况下 run() 返回使得线程死亡。调用 stop()或 destroy() 亦有同样效果，但是不被推荐，前者会产生异常，后者是强制终止，不会释放锁。

4. 阻塞状态：线程不会被分配 cpu 时间，无法执行。

四、线程的优先级

线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 cpu 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 cpu 时间，优先级高的线程有更大的机会获得 cpu 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。

你可以调用 thread 类的方法 getpriority() 和 setpriority()来存取线程的优先级，线程的优先级界于1(min_priority)和10(max_priority)之间，缺省是5(norm_priority)。

5)你用过哪种设计模式?(瞬联，ibm，aspentech)

设计:design

模式:pattern

框架:framework

创建模式，结构模式和行为模式

gof设计模式

a.创建模式

设计模式之factory(工厂模式)

使用工厂模式就象使用new一样频繁./10/9更新

设计模式之prototype(原型模式)

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

设计模式之builder

汽车由车轮 方向盘 发动机很多部件组成，同时，将这些部件组装成汽车也是一件复杂的工作，builder模式就是将这两种情况分开进行。

设计模式之singleton(单态模式)

保证一个类只有一个实例,并提供一个访问它的全局访问点 /10/9更新

b.结构模式

设计模式之facade

可扩展的使用jdbc针对不同的数据库编程,facade提供了一种灵活的实现.

设计模式之proxy

以jive为例,剖析代理模式在用户级别授权机制上的应用

设计模式之adapter

使用类再生的两个方式:组合(new)和继承(extends),这个已经在“thinking in java”中提到过.

设计模式之composite

就是将类用树形结构组合成一个单位.你向别人介绍你是某单位，你是单位中的一个元素，别人和你做买卖，相当于和单位做买卖。文章中还对jive再进行了剖析。

设计模式之decorator

decorator是个油漆工,给你的东东的外表刷上美丽的颜色.

设计模式之bridge

将“牛郎织女”分开(本应在一起,分开他们,形成两个接口),在他们之间搭建一个桥(动态的结合)

设计模式之flyweight

提供java运行性能,降低小而大量重复的类的开销.

c.行为模式

设计模式之template

实际上向你介绍了为什么要使用java 抽象类,该模式原理简单,使用很普遍.

设计模式之memento

很简单一个模式,就是在内存中保留原来数据的拷贝.

设计模式之observer

介绍如何使用java api提供的现成observer

设计模式之chain of responsibility

各司其职的类串成一串,好象击鼓传花,当然如果自己能完成,就不要推委给下一个.

设计模式之command

什么是将行为封装,command是最好的说明.

设计模式之state

状态是编程中经常碰到的实例,将状态对象化,设立状态变换器,便可在状态中轻松切换.

设计模式之strategy

不同算法各自封装,用户端可随意挑选需要的算法.

设计模式之mediator

mediator很象十字路口的红绿灯,每个车辆只需和红绿灯交互就可以.

设计模式之interpreter

主要用来对语言的分析,应用机会不多.

设计模式之visitor

访问者在进行访问时,完成一系列实质性操作,而且还可以扩展.

设计模式之iterator

篇7：面试时遇到的部分JAVA问题

29.简述java编程中事件处理模式。

30.你编写过applet吗？applet的安全权限如何？试列举java application或者applet中与servlet/jsp通信可以采用的方式。

31.简述逻辑操作(如&,|)与条件操作(如&&,||)的区别。

32.简述 Java Server Page 和 Servlet 的联系和区别。

33.简述synchronized和java.util.concurrent.locks.Lock的异同 ？

篇8：java面试问题汇总

问题：进程和线程的区别

解答：一个进程对应一个程序的执行，而一个线程则是进程执行过程中的一个单独的执行序列，一个进程可以包含多个线程，线程有时候也被称为轻量级进程.

一个Java虚拟机的实例运行在一个单独的进程中，不同的线程共享Java虚拟机进程所属的堆内存。这也是为什么不同的线程可以访问同一个对象。线 程彼此共享堆内存并保有他们自己独自的栈空间。这也是为什么当一个线程调用一个方法时，他的.局部变量可以保证线程安全。但堆内存并不是线程安全的，必须通 过显示的声明同步来确保线程安全。

问题:列举几种不同的创建线程的方法.

解答:可以通过如下几种方式：

•  继承Thread 类

•  实现Runnable 接口

•  使用Executor framework (这会创建一个线程池)

123456789101112131415classCounter extendsThread {     //method where the thread execution will start     publicvoidrun(){        //logic to execute in a thread        }     //let’s see how to start the threads    publicstaticvoidmain(String[] args){       Thread t1 = newCounter();       Thread t2 = newCounter();       t1.start();  //start the first thread. This calls the run() method.       t2.start(); //this starts the 2nd thread. This calls the run() method.      }}123456789101112131415classCounter extendsBase implementsRunnable{     //method where the thread execution will start     publicvoidrun(){        //logic to execute in a thread        }     //let us see how to start the threads    publicstaticvoidmain(String[] args){         Thread t1 = newThread(newCounter());         Thread t2 = newThread(newCounter());         t1.start();  //start the first thread. This calls the run() method.         t2.start();  //this starts the 2nd thread. This calls the run() method.      }}

通过线程池来创建更有效率，

问题：推荐通过哪种方式创建线程，为什么?

解答：最好使用Runnable接口，这样你的类就不必继承Thread类，不然当你需要多重继承的时候，你将 一筹莫展（我们都知道Java中的类只能继承自一个类，但可以同时实现多个接口）。在上面的例子中，因为我们要继承Base类，所以实现Runnable 接口成了显而易见的选择。同时你也要注意到在不同的例子中，线程是如何启动的。按照面向对象的方法论，你应该只在希望改变父类的行为的时候才去继承他。通 过实现Runnable接口来代替继承Thread类可以告诉使用者Counter是Base类型的一个对象，并会作为线程执行。

问题：简要的说明一下高级线程状态.

解答：下图说明了线程的各种状态.

篇9：java面试问题汇总

摘要：很多核心Java面试题来源于多线程(Multi-Threading)和集合框架(Collections Framework)，理解核心线程概念时，娴熟的实际经验是必需的。这篇文章收集了 Java 线程方面一些典型的问题，这些问题经常被高级工程师所问到。

很多核心Java面试题来源于多线程(Multi-Threading)和集合框架(Collections Framework)，理解核心线程概念时，娴熟的实际经验是必需的。这篇文章收集了 Java 线程方面一些典型的问题，这些问题经常被高级工程师所问到。

0.Java 中多线程同步是什么？

在多线程程序下，同步能控制对共享资源的访问。如果没有同步，当一个 Java 线程在修改一个共享变量时，另外一个线程正在使用或者更新同一个变量，这样容易导致程序出现错误的结果。

1.解释实现多线程的几种方法?

一 Java 线程可以实现 Runnable 接口或者继承 Thread 类来实现，当你打算多重继承时，优先选择实现 Runnable。

2.Thread.start()与 Thread.run()有什么区别？

Thread.start()方法(native)启动线程，使之进入就绪状态，当 cpu 分配时间该线程时，由 JVM 调度执行 run()方法。

3.为什么需要 run()和 start()方法，我们可以只用 run()方法来完成任务吗？

我们需要 run()&start()这两个方法是因为 JVM 创建一个单独的线程不同于普通方法的调用，所以这项工作由线程的 start 方法来完成，start 由本地方法实现，需要显示地被调用，使用这俩个方法的另外一个好处是任何一个对象都可以作为线程运行，只要实现了 Runnable 接口，这就避免因继承了 Thread 类而造成的 Java 的多继承问题。

4.什么是 ThreadLocal 类，怎么使用它？

ThreadLocal 是一个线程级别的局部变量，并非“本地线程”。ThreadLocal 为每个使用该变量的线程提供了一个独立的变量副本，每个线程修改副本时不影响其它线程对象的副本(译者注)。

下面是线程局部变量(ThreadLocal variables)的关键点：

一个线程局部变量(ThreadLocal variables)为每个线程方便地提供了一个单独的变量。

ThreadLocal 实例通常作为静态的私有的(private static)字段出现在一个类中，这个类用来关联一个线程。

当多个线程访问 ThreadLocal 实例时，每个线程维护 ThreadLocal 提供的独立的变量副本。

常用的使用可在 DAO 模式中见到，当 DAO 类作为一个单例类时，数据库链接(connection)被每一个线程独立的维护，互不影响。(基于线程的单例)

ThreadLocal 难于理解，下面这些引用连接有助于你更好的理解它。

《Good article on ThreadLocal on IBM DeveloperWorks 》、《理解 ThreadLocal》、《Managing data : Good example》、《Refer Java API Docs》

5.什么时候抛出 InvalidMonitorStateException 异常，为什么？

调用 wait()/notify()/notifyAll()中的任何一个方法时，如果当前线程没有获得该对象的锁，那么就会抛出 IllegalMonitorStateException 的异常(也就是说程序在没有执行对象的任何同步块或者同步方法时，仍然尝试调用 wait()/notify()/notifyAll()时)。由于该异常是 RuntimeExcpetion 的子类，所以该异常不一定要捕获(尽管你可以捕获只要你愿意).作为 RuntimeException，此类异常不会在 wait(),notify(),notifyAll()的方法签名提及。

6.Sleep()、suspend()和 wait()之间有什么区别？

Thread.sleep()使当前线程在指定的时间处于“非运行”（Not Runnable）状态。线程一直持有对象的监视器。比如一个线程当前在一个同步块或同步方法中，其它线程不能进入该块或方法中。如果另一线程调用了 interrupt()方法，它将唤醒那个“睡眠的”线程。

注意：sleep()是一个静态方法。这意味着只对当前线程有效，一个常见的错误是调用t.sleep

()，（这里的t是一个不同于当前线程的线程）。即便是执行t.sleep()，也是当前线程进入睡眠，而不是t线程。t.suspend()是过时的方法，使用 suspend()导致线程进入停滞状态，该线程会一直持有对象的监视器，suspend()容易引起死锁问题。

object.wait()使当前线程出于“不可运行”状态，和 sleep()不同的是 wait 是 object 的方法而不是 thread。调用 object.wait()时，线程先要获取这个对象的对象锁，当前线程必须在锁对象保持同步，把当前线程添加到等待队列中，随后另一线程可以同步同一个对象锁来调用 object.notify()，这样将唤醒原来等待中的线程，然后释放该锁。基本上 wait()/notify()与 sleep()/interrupt()类似，只是前者需要获取对象锁。

7.在静态方法上使用同步时会发生什么事？

同步静态方法时会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。

8.当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？

可以，一个非同步方法总是可以被调用而不会有任何问题。实际上，Java 没有为非同步方法做任何检查，锁对象仅仅在同步方法或者同步代码块中检查。如果一个方法没有声明为同步，即使你在使用共享数据 Java 照样会调用，而不会做检查是否安全，所以在这种情况下要特别小心。一个方法是否声明为同步取决于临界区访问(critial section access)，如果方法不访问临界区(共享资源或者数据结构)就没必要声明为同步的。

下面有一个示例说明：Common 类有两个方法 synchronizedMethod1()和 method1()，MyThread 类在独立的线程中调用这两个方法。

public class Common {

public synchronized void synchronizedMethod1(){

System.out.println(“synchronizedMethod1 called”);

try {

Thread.sleep(1000);

} catch(InterruptedException e){

e.printStackTrace();

}

System.out.println(“synchronizedMethod1 done”);

}

public void method1(){

System.out.println(“Method 1 called”);

try {

Thread.sleep(1000);

} catch(InterruptedException e){

e.printStackTrace();

}

System.out.println(“Method 1 done”);

}

}

public class MyThread extends Thread {

private int id = 0;

private Common common;

public MyThread(String name, int no, Common object){

super(name);

common = object;

id = no;

}

public void run(){

System.out.println(“Running Thread” + this.getName());

if(id == 0){

common.synchronizedMethod1();

} else {

common.method1();

}

} catch(Exception e){

e.printStackTrace();

}

}

public static void main(String[] args){

Common c = new Common();

MyThread t1 = new MyThread(“MyThread-1”, 0, c);

MyThread t2 = new MyThread(“MyThread-2”, 1, c);

t1.start();

t2.start();

}

}

这里是程序的输出：

Running ThreadMyThread-1

synchronizedMethod1 called

Running ThreadMyThread-2

Method 1 called

synchronizedMethod1 done

Method 1 done

结果表明即使 synchronizedMethod1()方法执行了，method1()也会被调用。

9.在一个对象上两个线程可以调用两个不同的同步实例方法吗？

不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。所以只有执行完该方法释放对象锁后才能执行其它同步方法。看下面代码示例非常清晰：Common 类有 synchronizedMethod1()和 synchronizedMethod2()方法，MyThread 调用这两个方法。

public class Common {

public synchronized void synchronizedMethod1(){

System.out.println(“synchronizedMethod1 called”);

try {

Thread.sleep(1000);

} catch(InterruptedException e){

e.printStackTrace();

System.out.println(“synchronizedMethod1 done”);

}

public synchronized void synchronizedMethod2(){

System.out.println(“synchronizedMethod2 called”);

try {

Thread.sleep(1000);

} catch(InterruptedException e){

e.printStackTrace();

}

System.out.println(“synchronizedMethod2 done”);

}

}

public class MyThread extends Thread {

private int id = 0;

private Common common;

public MyThread(String name, int no, Common object){

super(name);

common = object;

id = no;

}

public void run(){

System.out.println(“Running Thread” + this.getName());

try {

if(id == 0){

common.synchronizedMethod1();

} else {

common.synchronizedMethod2();

}

} catch(Exception e){

e.printStackTrace();

}

}

public static void main(String[] args){

Common c = new Common();

MyThread t1 = new MyThread(“MyThread-1”, 0, c);

MyThread t2 = new MyThread(“MyThread-2”, 1, c);

t1.start();

t2.start();

}

10.什么是死锁

死锁就是两个或两个以上的线程被无限的阻塞，线程之间相互等待所需资源。这种情况可能发生在当两个线程尝试获取其它资源的锁，而每个线程又陷入无限等待其它资源锁的释放，除非一个用户进程被终止。就 JavaAPI 而言，线程死锁可能发生在一下情况。

当两个线程相互调用 Thread.join()

当两个线程使用嵌套的同步块，一个线程占用了另外一个线程必需的锁，互相等待时被阻塞就有可能出现死锁。

11.什么是线程饿死，什么是活锁？

线程饿死和活锁虽然不想是死锁一样的常见问题，但是对于并发编程的设计者来说就像一次邂逅一样。

当所有线程阻塞，或者由于需要的资源无效而不能处理，不存在非阻塞线程使资源可用。JavaAPI 中线程活锁可能发生在以下情形：

当所有线程在程序中执行 Object.wait(0)，参数为 0 的 wait 方法。程序将发生活锁直到在相应的对象上有线程调用 Object.notify()或者 Object.notifyAll()。

当所有线程卡在无限循环中。