嵌入式工程师面试宝典（共6篇）
篇1：嵌入式工程师面试宝典
初入职场嵌入式工程师面试宝典
随着物联网发展的推进，嵌入式技术越来越成为一名高新技术行业，目前市场对此方面的人才需求也相对较大，各大高校也先后开设了此类课程。但是此专业的学生如何找到一份嵌入式工作？
第一：技术为王，作为技术类工作，技术肯定是至关重要的。如何在短暂的时间向面试官展示你的技术能力？
实物展示项目开发经验是最具说服力的，嵌入式技术作为软硬件相结合的技术，简历上写的天花乱坠也比不上一个实物的展示，通过自己制作一个实物，实现一定的智能控制功能，能够清晰的阐述出你设计的原理以及思路，能够分析自己的代码。不管你展示的项目难易程度高低，至少通过此方法可以让面试官明白第一你是做了精心准备的，是一个负责的人，为了自己的这份工作是用心去准备了的。态度上能给面试官一个好感。第二面试官通过你的讲解也能了解到你的大概水平，就算现在技术不到位，至少也知道你是个可造之材，或者知道如何培养你。
所以技术类工作首先得保证手头有货，而刚好相反目前大多数同学都是表现在口头有货。说到什么技术都知道，ARM11都过时了、A8才是主流，元计算、内核裁剪、系统架构等等。说起来天花乱坠，但是实际落实到真正动手能力上…
东方智达科技致力于单片机、嵌入式培训。培养模式也是项目实战为主，所以想提高项目实战的同学欢迎来东方智达学习。
第二：态度诚恳，不卑不亢。
面对面试官不需要表现的过分的谦虚谨慎，个人感觉这种人没活力，没底气，就像一个永远不会犯错的小羔羊。当然本着天下老子第一的态度更不用谈了，毕竟人家现在可以应聘你肯定比你牛X。话说回来“不气盛，那叫年轻人。”我就看好有个性的年轻人，充满着自信，这事我能搞定，这种人也许是企业更希望得到的。
第三：面试服饰礼仪。
本文主要针对嵌入式工程师面试，作为技术工种所以建议不要西装革履了，刚毕业的同学花大几千买套西装真不划算，花几百买套劣质西装倒不如好好买套休闲装，看着精神干净。服饰方面一直提出休闲简约，不要搞的花里胡哨的。自己穿着舒服，别人看着干净刚好。
第四：回答面试官问题。
有几个问题时面试官经常问到的，你未来几年的职业规划，你的理想薪资，你的自我评价。
针对这个几个问题第一你未来几年的职业规划，这个问题也许答案很范，但是个人建议在同学们踏入职场前最好真心把这个问题思考清楚，自己将何去何从，未来的方向在哪里，未来的目标在哪里，有人云：“没有方向的船、任何风都不是顺风”。如果你自己没有清晰的目标不知道自己将去哪里，在你的职业生涯中基本上就是一个工作机器，为了养家糊口的赚钱机器，因为你没有职业上的规划，你只有为了获取生理上的满足，同时面对面试官的这个问题你也应该谨慎回答，不可信口开河说的牛x哄哄，也不和含糊其辞。总之最好的回答是建立在你应聘公司发展的角度。
理想薪资：叫太高怕丢了这个offer，叫太低怕亏了自己，这个问题还是看自己的手头上的能力吧，自己几斤几两自己清楚，叫个合理的价格，是金子总会发光，进来工资低有能力涨的也快，进来工资高结果做不了事、后果可能更惨烈。
自我评价：这个建议实事求是，人无完人，优缺点说清楚，必将将来都是一起工作的人，心照不宣还是要好很多。啥优缺点也是包不住的。，综上所述，面试就要是做到技术牛逼、态度诚恳、天高地阔任我闯的坦荡。
篇2：嵌入式工程师面试宝典
1、一个“.java”源文件中是否可以包括多个类(不是内部类)?有什么限制? 7
2、Java有没有goto? 7
3、说说&和&&的区别。 8
4、在JAVA中如何跳出当前的多重嵌套循环? 8
5、switch语句能否作用在byte上，能否作用在long上，能否作用在String上? 9
6、short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错? 9
7、char型变量中能不能存贮一个中文汉字?为什么? 9
8、用最有效率的方法算出2乘以8等於几? 9
9、请设计一个一百亿的计算器 9
10、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变? 11
11、“==”和equals方法究竟有什么区别? 11
12、静态变量和实例变量的区别? 12
13、是否可以从一个static方法内部发出对非static方法的调用? 12
14、Integer与int的区别 13
15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? 13
16、下面的代码有什么不妥之处? 13
17、请说出作用域public，private，protected，以及不写时的区别 13
18、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型? 14
19、构造器Constructor是否可被override? 15
20、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 15
21、写clone方法时，通常都有一行代码，是什么? 15
22、面向对象的特征有哪些方面 15
23、java中实现多态的机制是什么? 17
24、abstract class和interface有什么区别? 17
25、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized? 18
26、什么是内部类?Static Nested Class 和 Inner Class的不同。 19
27、内部类可以引用它的包含类的成员吗?有没有什么限制? 20
28、Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)? 21
29、super.getClass()方法调用 21
30、String是最基本的数据类型吗? 22
31、String s = “Hello”;s = s + “ world!”;这两行代码执行后，原始的String对象中的内容到底变了没有? 22
32、是否可以继承String类? 23
33、String s = new String(“xyz”);创建了几个String Object? 二者之间有什么区别? 23
34、String 和StringBuffer的区别 23
35、如何把一段逗号分割的字符串转换成一个数组? 24
36、数组有没有length()这个方法? String有没有length()这个方法? 24
37、下面这条语句一共创建了多少个对象：String s=“a”+“b”+“c”+“d”; 24
38、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后? 25
39、下面的程序代码输出的结果是多少? 25
40、final, finally, finalize的区别。 27
41、运行时异常与一般异常有何异同? 27
42、error和exception有什么区别? 28
43、Java中的异常处理机制的简单原理和应用。 28
44、请写出你最常见到的5个runtime exception。 28
45、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义?在try块中可以抛出异常吗? 29
46、java中有几种方法可以实现一个线程?用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用? 29
47、sleep() 和 wait() 有什么区别? 30
48、同步和异步有何异同，在什么情况下分别使用他们?举例说明。 32
49. 下面两个方法同步吗?(自己发明) 33
50、多线程有几种实现方法?同步有几种实现方法? 33
51、启动一个线程是用run()还是start()? . 33
52、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法? 33
53、线程的基本概念、线程的基本状态以及状态之间的关系 34
54、简述synchronized和java.util.concurrent.locks.Lock的异同 ? 34
55、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。 36
56、子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。 38
57、介绍Collection框架的结构 43
58、Collection框架中实现比较要实现什么接口 43
59、ArrayList和Vector的区别 44
60、HashMap和Hashtable的区别 44
61、List 和 Map 区别? 45
62、List, Set, Map是否继承自Collection接口? 45
63、List、Map、Set三个接口，存取元素时，各有什么特点? 45
64、说出ArrayList,Vector, LinkedList的存储性能和特性 46
65、去掉一个Vector集合中重复的元素 46
66、Collection 和 Collections的区别。 47
67、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别? 47
68、你所知道的集合类都有哪些?主要方法? 47
69、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对? 48
70、TreeSet里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的compareTo方法，还是使用的子类的compareTo方法，还是抛异常! 48
71、说出一些常用的类，包，接口，请各举5个 49
72、java中有几种类型的流?JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类? 49
73、字节流与字符流的区别 50
74、什么是java序列化，如何实现java序列化?或者请解释Serializable接口的作用。 51
75、描述一下JVM加载class文件的原理机制? 52
76、heap和stack有什么区别。 52
77、GC是什么? 为什么要有GC? 52
78、垃圾回收的优点和原理。并考虑2种回收机制。 52
79、垃圾回收器的基本原理是什么?垃圾回收器可以马上回收内存吗?有什么办法主动通知虚拟机进行垃圾回收? 52
80、什么时候用assert。 53
81、java中会存在内存泄漏吗，请简单描述。 53
82、能不能自己写个类，也叫java.lang.String? 57
83. Java代码查错 57
二. 算法与编程 61
1、编写一个程序，将a.txt文件中的单词与b.txt文件中的单词交替合并到c.txt文件中，a.txt文件中的单词用回车符分隔，b.txt文件中用回车或空格进行分隔。 61
2、编写一个程序，将d:java目录下的所有.java文件复制到d:jad目录下，并将原来文件的扩展名从.java改为.jad。 62
3、编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串，但要保证汉字不被截取半个，如“我ABC”，4，应该截取“我AB”，输入“我ABC汉DEF”，6，应该输出“我ABC”，而不是“我ABC+汉的半个”。 65
4、有一个字符串，其中包含中文字符、英文字符和数字字符，请统计和打印出各个字符的个数。 65
5、说明生活中遇到的二叉树，用java实现二叉树 66
6、从类似如下的文本文件中读取出所有的姓名，并打印出重复的姓名和重复的次数，并按重复次数排序： 71
7、写一个Singleton出来。 75
8、递归算法题1 77
篇3：嵌入式工程师面试宝典
关键词：电子信息工程,嵌入式系统,教学改革
引言
电子信息工程专业是电子和信息工程方面的较宽口径专业, 其主干学科为电子科学与技术、信息与通信工程、计算机科学与技术。该专业培养学生掌握现代电子技术理论、通晓电子系统设计原理与设计方法, 具有较强的计算机、外语和相应工程技术应用能力, 面向电子技术、自动控制和智能控制、计算机与网络技术等电子、信息、通信领域培养宽口径、高素质、德智体全面发展的具有创新能力的高级工程技术开发人才。
随着微电子技术、软件技术的进步, 嵌入式系统是目前电子产品设计领域最为热门的技术之一, 已广泛地应用于军事国防、消费电子、网络通信、工业控制等各个领域。嵌入式系统是一门综合性很强的课程[1] , 是将先进的计算机技术、半导体技术和电子技术以及各个行业的具体应用相结合后的产物[2] , 这一特点决定了它必然是一个技术密集的交叉性、应用型的学科。据估计, 每年全球嵌入式系统带来的相关工业产值已超过万亿美元[3] 。随着科技的发展和社会需求的推动, 嵌入式系统技术是后PC时代计算机技术发展的一个重要方向, 嵌入式系统的市场快速增长, 嵌入式系统人才缺口正急剧增大, 在相当长的时间内, 嵌入式系统人才都将是企业争夺的目标[3] 。目前, 国内许多高校有关嵌入式教学的探讨和研究也随着嵌入式系统课程的开设而展开了探索。根据嵌入式系统的特点和电子信息工程专业教学模式和人才培养的特点, 对电子信息工程专业的嵌入式系统教学模式的改革进行初步探索, 提高嵌入式系统的教学效果。
1嵌入式系统的教学内容
嵌入式系统课程采取理论和实践相结合的方式, 以嵌入式系统的整体概念以及嵌入式实时操作系统为重点, 使学生既能对嵌入式系统有一个整体性的认识, 又能深入理解嵌入式系统的核心技术, 进而掌握基本的嵌入式系统软硬件设计与开发技能。
嵌入式系统的教学又可以分为课堂理论学习、实验教学和课程设计三个层面。在课堂理论学习的教学内容组织上, 首先讲解嵌入式系统的基础知识, 包括嵌入式系统的基本概念与平台构建、处理器与接口等硬件系统基础知识;然后围绕嵌入式实时操作系统, 详细介绍嵌入式系统的软件系统设计与开发;最后, 可通过一些简单的实例讲解来使学生了解嵌入式系统的设计, 从而掌握嵌入式系统的原理性知识。在实验教学中需要培养学生掌握嵌入式系统的主要开发流程和基本方法, 例如开发工具的使用、一些小型的应用开发等。课程设计的主要目的是通过实际的嵌入式应用系统开发实例掌握嵌入式系统设计和开发的技能及专业知识, 积累实践和工程经验。
2专业培养计划修订
按照教育部本科专业目录和专业介绍, 电子信息工程专业培养学生具备电子信息科学与技术的基本理论和基本知识, 受到严格的科学实验训练和科学研究初步训练, 能在电子信息科学与技术、计算机科学与技术及相关领域和行政部门从事科学研究、教学、科技研发、产品设计、生产技术或管理工作的电子信息科学与技术高级专门人才[4] 。其主干学科为电子科学与技术、计算机科学与技术。其主要课程为电路分析原理、电子线路、数字电路、算法与数据结构、计算机基础等。
学院电子信息工程专业的定位如下:主要培养具备电子技术和信息系统的基础知识, 从事各类电子设备和信息系统的研究、设计、制造、应用和开发的高等工程技术人才。主要开设的课程有电路分析、模拟电子技术、数字电路和逻辑设计、自动控制原理、信号与系统、电子设计自动化、C语言程序设计、传感器原理与应用、数字广播与电视等。
嵌入式系统与电子信息工程专业主干学科密切相关。根据教育部对电子信息工程专业的要求, 并结合学院电子信息工程专业的特色, 专业培养计划只需作较少的修改即可满足嵌入式系统的教学需要。具体修改如下:增设“数据结构”、“软件工程”和“操作系统”三门专业基础课, 分别于第四学期、第五学期开展教学, 第六学期开设“嵌入式系统”课程, 第七学期新增“嵌入式系统课程设计”, 重点培养学生的系统设计能力。
3嵌入式教学体系具体改革方案
根据上述专业培养计划修订的方案, 将改革方案融入专业教学工作中, 强化软件综合知识的教学, 处理好软、硬件教学的协调与配合。在软件方面, 提升“C语言程序设计”课程的重要性, 重点培养学生能够利用C语言这门编程语言对“数据结构”、“操作系统”中开设的实验进行上机操作, 为“嵌入式系统”教学打下坚实的基础。在硬件方面, 应指导学生学习好“微机原理”与“单片机原理及应用”这两门课程, 特别是在“单片机原理及应用”这门课程中, 要求学生能够掌握汇编语言和C语言对单片机进行编程的方法, 这样在“嵌入式系统”课程的学习中能够扫除学习的困难。
根据以上所述, 嵌入式系统的教学应从课堂教学、实验教学和课程设计三个层面把握教学的内容及目标。
(1) 课堂教学。
在课堂教学中, 不仅要求学生掌握嵌入式系统的理论知识, 更重要的是强调嵌入式系统的广泛应用, 把着眼点放在应用系统开发上。在教学过程中, 对一些难点采用先进的教学方法和手段进行讲授, 如采用多媒体课件、录像和图片展示、flash演示等手段和方法, 使授课内容更加生动易懂。为学生提供多种学习手段, 包括课堂讲授、课后答疑及作业练习、阶段考试和期末考试等。同时, 建立课程网站, 将相关的学习资源 (教学大纲、授课教案、课程视频录像、在线测试题、常见问题解答、实验软件平台下载、实验指导书和范例下载等) 以合理的方式和结构组织到课程网站中, 利用辅助教学软件等生动活泼的表现形式对重点、难点知识进行解析, 并对学生提交到网上的留言信息及时答复。
(2) 实验教学。
根据学生对知识的理解程度和接受能力, 针对教学内容的难点和重点, 合理地安排实验内容和顺序, 培养学生依据实验开发系统进行嵌入式系统软硬件实验, 使学生熟悉嵌入式系统的开发环境, 全面了解嵌入式系统的开发流程, 掌握课堂所学的理论知识。嵌入式系统的实验教学以学生为主体, 将嵌入式系统的实验教学融入学生的实践课程中, 以开放实验、仿真实验等形式贯穿实验课程教学的始终。
(3) 课程设计。
针对嵌入式系统设计课程体系的特点, 以实践促进理论的学习方法, 结合一些经典的工程实例, 例如嵌入式系统引导程序、功耗检测系统、数字相框等课程设计的案例, 介绍嵌入式系统当中常用的一些应用软件开发方法, 包括多线程程序设计、网络程序设计、外部通信端口控制等, 引导学生循序渐进地理解嵌入式系统的基本设计方法, 掌握一般设计流程和常用工具, 加强对学生自我学习和综合设计能力的培养。这种实践教学方法, 让学生最直接地加深对嵌入式系统概念和原理的理解, 逐步消除企业需求与学生能力之间的差距, 能够使学生真正做到毕业即就业。
结论
电子信息工程专业开展嵌入式系统教学应以培养真正适应社会的嵌入式系统人才为目标, 从课堂教学、实验教学和课程设计三个层面把握教学的内容及目标。目前学院的嵌入式系统教学才开展几年, 在教学工作中还存在着许多不足, 一些教学方法的改革效果还需要时间来验证, 同时还将有许多新的教学手段需要进一步探讨和研究。
参考文献
[1]陈虎, 吴涛, 张安定.嵌入式系统课程设计[M].北京:机械工业出版社, 2008:1-3.
[2]王田苗.嵌入式系统设计与实例开发——基于ARM微处理器与μc/OS-Ⅱ实时操作系统[M].北京:清华大学出版社, 2003:2.
[3]朱海峰.嵌入式系统教学改革研究[J].科技信息, 2009, (36) :25-27.
篇4：HR给出的“面试宝典”
1．面试前干什么
研究一下企业的性质和岗位说明书，企业的性质往往成为企业选人的重要因素，不同的企业青睐不同的人才，比如：日本公司注重服从和等级观念，如果在面试时表现得个性张扬，喜欢自由，那么你多半没戏；欧美的企业注重授权和创新，如果你表现得太过死板，唯唯诺诺，那么，估计你的机会也不大。民营企业跟着感觉走吧，谈不上什么特点。这就是我们经常说的：企业要找符合企业文化的人。了解企业文化，不是让你欺骗企业，伪装自己，但是明明知道是错的，为什么不适当地调整一下呢?你说，我就这个性，不改。那我觉得你自己去开公司、做老板吧，不要去打工了。对于岗位说明书，也要好好研究一下，因为同样的职位，每个企业之间的工作内容常常不一样，同样招聘人事经理，有的公司注重宏观的东西，有的公司注重操作层面的，如果人家叫你主要去做人力资源规划和战略，你在那儿谈保险怎么交，员工关系怎么处理等，你的胜算有几成?
2．礼仪
英国的人力资源专家曾经作过研究，三种人更容易得到工作：漂亮的、个子高的、有礼貌的。前两者是爹娘遗传的，估计你也改变不了，但是对于礼仪，却是可以注意的，去面试前，建议你好好审视一下自己的穿着，首先未必要穿名牌，但是看上去男生要给人感觉很利索、协调，女生看上去要干净、大方，不要给别人很邋遢的感觉。有的应聘者，一看西装皱巴巴的，领带打得歪里斜巴的，能有好印象吗?坐下来前就给否定了，因为中国人其实是非常注重外表的，即以貌取人。还有的女生，打扮太时尚，那么大的耳环，企业找人不是找模特或者选美，所以不合适的穿戴往往会让你在一开始就给“枪毙”了，现在很多学校的学生搞什么写真集求职，实在是“误入歧途”，碰上不怀好意的招聘者，也许会惹大麻烦，但你最后不要把责任全部推给别人。
3．面对不同的面试人员，保持良好的心态
有的面试人员风格比较强势、直率，面试时咄咄逼人，往往有一种审问犯人的感觉；有的面试人员温和、艺术。遇到这两种面试人员，自己首先要有好的心态，对于前者，往往会让人不舒服，有压力感，但是你不能因此就产生逆反心理，觉得对方素质如何如何(本人曾经在网上看到有些应聘者写的文章)，甚至由此得出该公司不怎么样的结论，这实际上要不得，应该以一种宽容、平和的心态去对待；对于后者，不要麻痹大意，因为温和面孔的背后常常是一把利剑。所以，在内心里，一定要记住：这是一场面试、是求职，不要太多地关注所谓的“自尊”。
4．学会区分不同的问题
有经验的面试官往往会用不同的面试方法和问题，所以对于各种不同的问题，不必紧张，有的问题可能是确认你的工作经验和能力，有的问题则是考验你的分析能力、思考能力、反应、思路等，比如：下水道的盖子为什么是圆的?这样的问题没有正确答案，只要能够自圆其说即可。对于没有工作经验的校园招聘，通常就会用这种方法，面试时注意区分，有的应聘者对什么问题都很紧张，结果影响了水平的发挥。
5．面试要注意“答所问”
很多人往往忽略这一点，比如现在很多企业的面试人员往往不够专业，会首先说：自我介绍一下吧。
有经验的面试官往往不问这些问题，但有的应聘者总是喜欢说着说着，就开始介绍自己了，往往引起面试人员的反感。还有的应聘者，根本没有听清楚问题，就按照自己的思路回答，结果驴头不对马嘴。听不清楚，可以确认一下嘛。所以，建议应聘者要跟紧面试人员的思路，保持高度集中，不要停留在自己的“思维圈子”里。
6．回答问题注意条理，简明，不要啰唆
麦肯锡公司有一句名言：所有的事情都可以分成三句话去讲。比如：今天上午9点吃早饭。可以说成：今天我吃饭，时间是上午9:00，吃的是早饭。因此建议大家在回答问题的时候，不妨按照这样一个套路：第一点、第二点、第三点……这样听的人很清楚，说的人也不会漏掉重点，还有一个，就是要简明，不要啰唆，你不要把别人当傻瓜，一件事情或观点关键是重点，所以这个道理其实就是言简意赅。有的应聘者自我介绍搞了10分钟，听的人早烦了，谁有这个耐心呢?
篇5：嵌入式工程师面试宝典
答题时，先答是什么，再答有什么作用和要注意什么（这部分最重要，展现自己的心得）
答案的段落分别，层次分明，条理清晰都非常重要，从这些表面的东西也可以看出一个人的习惯、办事风格、条理等。
要讲你做出答案的思路过程，或者说你记住答案的思想都写下来。把答题想着是辩论赛。答题就是给别人讲道理、摆事实。答题不局限于什么格式和形式，就是要将自己的学识展现出来！
别因为人家题目本来就模棱两可，你就心里胆怯和没底气了，不敢回答了。你要大胆地指出对方题目很模糊和你的观点，不要把面试官想得有多高，其实他和你就是差不多的，你想想，如果他把你招进去了，你们以后就是同事了，可不是差不多的吗？
关于就业薪水，如果你是应届生，那不能要高工资，好比大饼的故事，没有文凭还想拿高工资，就去中关村缺什么补什么吧！少数人基础确实很好，在校期间确实又做过一些项目，那仍然是可以要到相对高的工资的。
1.Java基础部分
基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语法，集合的语法，io 的语法，虚拟机方面的语法。
1、一个“.java”源文件中是否可以包括多个类（不是内部类）？有什么限制？
可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。
2、Java有没有goto?
java中的保留字，现在没有在java中使用。
3、说说&和&&的区别。
&和&&都可以用作逻辑与的运算符，表示逻辑与（and），当运算符两边的表达式的结果都为true时，整个运算结果才为true，否则，只要有一方为false，则结果为false。
&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式，例如，对于if(str!= null &&!str.equals(“”))表达式，当str为null时，后面的表达式不会执行，所以不会出现NullPointerException如果将&&改为&，则会抛出NullPointerException异常。If(x==33 & ++y>0)y会增长，If(x==33 && ++y>0)不会增长
&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位，例如，0x31 & 0x0f的结果为0x01。
备注：这道题先说两者的共同点，再说出&&和&的特殊之处，并列举一些经典的例子来表明自己理解透彻深入、实际经验丰富。
4、在JAVA中如何跳出当前的多重嵌套循环？
在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break 语句，即可跳出外层循环。例如，ok: for(int i=0;i<10;i++){
}
另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。
int arr[][] = {{1,2,3},{4,5,6,7},{9}};boolean found = false;for(int i=0;i
} for(int j=0;j
} System.out.println(“i=” + i + “,j=” + j);if(arr[i][j] == 5){
} found = true;break;for(int j=0;j<10;j++)
} if(j == 5)break ok;
{ System.out.println(“i=” + i + “,j=” + j);
5、switch语句能否作用在byte上，能否作用在long上，能否作用在String上?
在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。显然，long和String类型都不符合switch的语法规定，并且不能被隐式转换成int类型，所以，它们不能作用于swtich语句中。
6、short s1 = 1;s1 = s1 + 1;有什么错? short s1 = 1;s1 += 1;有什么错?
对于short s1 = 1;s1 = s1 + 1;由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误。
对于short s1 = 1;s1 += 1;由于 += 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。
7、char型变量中能不能存贮一个中文汉字?为什么?
char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，所以，char型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在unicode编码字符集中，那么，这个char型变量中就不能存储这个特殊汉字。补充说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。
备注：后面一部分回答虽然不是在正面回答题目，但是，为了展现自己的学识和表现自己对问题理解的透彻深入，可以回答一些相关的知识，做到知无不言，言无不尽。
8、用最有效率的方法算出2乘以8等於几? << 3，因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2 << 3。
9、请设计一个一百亿的计算器
首先要明白这道题目的考查点是什么，一是大家首先要对计算机原理的底层细节要清楚、要知道加减法的位运算原理和知道计算机中的算术运算会发生越界的情况，二是要具备一定的面向对象的设计思想。
首先，计算机中用固定数量的几个字节来存储的数值，所以计算机中能够表示的数值是有一定的范围的，为了便于讲解和理解，我们先以byte 类型的整数为例，它用1个字节进行存储，表示的最大数值范围为-128到+127。-1在内存中对应的二进制数据为11111111，如果两个-1相加，不考虑Java运算时的类型提升，运算后会产生进位，二进制结果为1,11111110，由于进位后超过了byte类型的存储空间，所以进位部分被舍弃，即最终的结果为11111110，也就是-2，这正好利用溢位的方式实现了负数的运算。-128在内存中对应的二进制数据为10000000，如果两个-128相加，不考虑Java运算时的类型提升，运算后会产生进位，二进制结果为1,00000000，由于进位后超过了byte类型的存储空间，所以进位部分被舍弃，即最终的结果为00000000，也就是0，这样的结果显然不是我们期望的，这说明计算机中的算术运算是会发生越界情况的，两个数值的运算结果不能超过计算机中的该类型的数值范围。由于Java中涉及表达式运算时的类型自动提升，我们无法用byte类型来做演示这种问题和现象的实验，大家可以用下面一个使用整数做实验的例子程序体验一下：
int a = Integer.MAX_VALUE;int b = Integer.MAX_VALUE;int sum = a + b;System.out.println(“a=”+a+”,b=”+b+”,sum=”+sum);先不考虑long类型，由于int的正数范围为2的31次方，表示的最大数值约等于2*1000*1000*1000，也就是20亿的大小，所以，要实现一个一百亿的计算器，我们得自己设计一个类可以用于表示很大的整数，并且提供了与另外一个整数进行加减乘除的功能，大概功能如下：
（）这个类内部有两个成员变量，一个表示符号，另一个用字节数组表示数值的二进制数（）有一个构造方法，把一个包含有多位数值的字符串转换到内部的符号和字节数组中（）提供加减乘除的功能 public class BigInteger{
} 备注：要想写出这个类的完整代码，是非常复杂的，如果有兴趣的话，可以参看jdk中自带的java.math.BigInteger类的源码。面试的人也知道谁都不可能在短时间内写出这个类的完整代码的，他要的是你是否有这方面的概念和意识，他最重要的还是考查你的能力，所以，你不要因为自己无法写出完整的最终结果就放弃答这道题，你要做的就是你比别人写得多，证明你比别人强，你有这方面的思想意识就可以了，毕竟别人可能连题目的意思都看不懂，什么都没写，你要敢于答这道题，即使只答了一部分，那也与那些什么都不懂的人区别出来，拉开了距离，算是矮子中的高个，机会当然就属于你了。另外，答案中的框架代码也很重要，体现了一些面向对象设计的功底，特别是其中的方法命名很专业，用的英文单词很精准，这也是能力、经验、专业性、英语水平等多个方面的体现，会给人留下很好的印象，在编程能力和其他方面条件差不多的情况下，英语好除了可以使你获得更多机会外，薪水可以高出一千元。
int sign;byte[] val;public Biginteger(String val){
} public BigInteger add(BigInteger other){ } public BigInteger subtract(BigInteger other){ } public BigInteger multiply(BigInteger other){ } public BigInteger divide(BigInteger other){ }
sign =;val =;
10、使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
使用final关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。例如，对于如下语句：
final StringBuffer a=new StringBuffer(“immutable”);执行如下语句将报告编译期错误：
a=new StringBuffer(“");但是，执行如下语句则可以通过编译：
a.append(” broken!“);
有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象： public void method(final StringBuffer param){ }
实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象： param.append(”a“);
11、”==“和equals方法究竟有什么区别？
（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则很难说清楚）
==操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。
如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如Objet obj = new Object();变量obj是一个内存，new Object()是另一个内存，此时，变量obj所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用==操作符进行比较。
equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
String a=new String(”foo“);String b=new String(”foo“);两条new语句创建了两个对象，然后用a,b这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即a和b中存储的数值是不相同的，所以，表达式a==b将返回false，而这两个对象中的内容是相同的，所以，表达式a.equals(b)将返回true。
在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，String input = …;input.equals(“quit”)，许多人稍不注意就使用==进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用equals方法。
如果一个类没有自己定义equals方法，那么它将继承Object类的equals方法，Object类的equals方法的实现代码如下：
boolean equals(Object o){ return this==o;} 这说明，如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果，如果比较的是两个独立的对象则总返回false。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖equals方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。
12、静态变量和实例变量的区别？
在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。
public class VariantTest{
} 备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！public static int staticVar = 0;public int instanceVar = 0;public VariantTest(){
} staticVar++;instanceVar++;System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);
13、是否可以从一个static方法内部发出对非static方法的调用？
不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中发出对非static方法的调用，那个非static方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个static方法内部发出对非static方法的调用。
14、Integer与int的区别
int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。在JSP开发中，Integer的默认为null，所以用el表达式在文本框中显示时，值为空白字符串，而int默认的默认值为0，所以用el表达式在文本框中显示时，结果为0，所以，int不适合作为web层的表单数据的类型。
在Hibernate中，如果将OID定义为Integer类型，那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的，如果将OID定义为了int类型，还需要在hbm映射文件中设置其unsaved-value属性为0。
另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。
15、Math.round(11.5)等於多少? Math.round(-11.5)等於多少? Math类中提供了三个与取整有关的方法：ceil、floor、round，这些方法的作用与它们的英文名称的含义相对应，例如，ceil的英文意义是天花板，该方法就表示向上取整，Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11；floor的英文意义是地板，该方法就表示向下取整，Math.ceil(11.6)的结果为11,Math.ceil(-11.6)的结果是-12；最难掌握的是round方法，它表示“四舍五入”，算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。
16、下面的代码有什么不妥之处? 1.if(username.equals(“zxx”){} 2.int x = 1;
return x==1?true:false;
17、请说出作用域public，private，protected，以及不写时的区别
这四个作用域的可见范围如下表所示。
说明：如果在修饰的元素上面没有写任何访问修饰符，则表示friendly。
作用域
当前类 同一package 子孙类 其他package public
√
√
√
√
protected √
√
√
×
friendly
√
√
×
×
private
√
×
×
×
备注：只要记住了有4种访问权限，4个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。
18、Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?
Overload是重载的意思，Override是覆盖的意思，也就是重写。
重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。
重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。
至于Overloaded的方法是否可以改变返回值的类型这个问题，要看你倒底想问什么呢？这个题目很模糊。如果几个Overloaded的方法的参数列表不一样，它们的返回者类型当然也可以不一样。但我估计你想问的问题是：如果两个方法的参数列表完全一样，是否可以让它们的返回值不同来实现重载Overload。这是不行的，我们可以用反证法来说明这个问题，因为我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，例如，我们调用map.remove(key)方法时，虽然remove方法有返回值，但是我们通常都不会定义接收返回结果的变量，这时候假设该类中有两个名称和参数列表完全相同的方法，仅仅是返回类型不同，java就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断。
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
19、构造器Constructor是否可被override?
构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。
20、接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？
接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承具体类。抽象类中可以有静态的main方法。
备注：只要明白了接口和抽象类的本质和作用，这些问题都很好回答，你想想，如果你是java语言的设计者，你是否会提供这样的支持，如果不提供的话，有什么理由吗？如果你没有道理不提供，那答案就是肯定的了。
只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。
21、写clone()方法时，通常都有一行代码，是什么？
clone 有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。
22、面向对象的特征有哪些方面
计算机软件系统是现实生活中的业务在计算机中的映射，而现实生活中的业务其实就是一个个对象协作的过程。面向对象编程就是按现实业务一样的方式将程序代码按一个个对象进行组织和编写，让计算机系统能够识别和理解用对象方式组织和编写的程序代码，这样就可以把现实生活中的业务对象映射到计算机系统中。
面向对象的编程语言有封装、继承、抽象、多态等4个主要的特征。1封装：
封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。通常情况下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了，就基本上算是会面向对象的编程了。把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。
例如，人要在黑板上画圆，这一共涉及三个对象：人、黑板、圆，画圆的方法要分配给哪个对象呢？由于画圆需要使用到圆心和半径，圆心和半径显然是圆的属性，如果将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，它才能访问到圆心和半径这两个属性，人以后只是调用圆的画圆方法、表示给圆发给消息而已，画圆这个方法不应该分配在人这个对象上，这就是面向对象的封装性，即将对象封装成一个高度自治和相对封闭的个体，对象状态（属性）由这个对象自己的行为（方法）来读取和改变。一个更便于理解的例子就是，司机将火车刹住了，刹车的动作是分配给司机，还是分配给火车，显然，应该分配给火车，因为司机自身是不可能有那么大的力气将一个火车给停下来的，只有火车自己才能完成这一动作，火车需要调用内部的离合器和刹车片等多个器件协作才能完成刹车这个动作，司机刹车的过程只是给火车发了一个消息，通知火车要执行刹车动作而已。
抽象：
抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那就是抽象。抽象包括行为抽象和状态抽象两个方面。例如，定义一个Person类，如下：
class Person{
} 人本来是很复杂的事物，有很多方面，但因为当前系统只需要了解人的姓名和年龄，所以上面定义的类中只包含姓名和年龄这两个属性，这就是一种抽像，使用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解就是不要用显微镜去看一个事物的所有方面，这样涉及的内容就太多了，而是要善于划分问题的边界，当前系统需要什么，就只考虑什么。
String name;int age;继承：
在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。
多态：
多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。例如，下面代码中的UserDao是一个接口，它定义引用变量userDao指向的实例对象由daofactory.getDao()在执行的时候返回，有时候指向的是UserJdbcDao这个实现，有时候指向的是UserHibernateDao这个实现，这样，不用修改源代码，就可以改变userDao指向的具体类实现，从而导致userDao.insertUser()方法调用的具体代码也随之改变，即有时候调用的是UserJdbcDao的insertUser方法，有时候调用的是UserHibernateDao的insertUser方法：
UserDao userDao = daofactory.getDao();
userDao.insertUser(user);
比喻：人吃饭，你看到的是左手，还是右手？
23、java中实现多态的机制是什么？
靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
24、abstract class和interface有什么区别?
含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。
下面比较一下两者的语法区别：
1.抽象类可以有构造方法，接口中不能有构造方法。2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4.抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5.抽象类中可以包含静态方法，接口中不能包含静态方法
6.抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。7.一个类可以实现多个接口，但只能继承一个抽象类。下面接着再说说两者在应用上的区别：
接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：
public abstract class BaseServlet extends HttpServlet{
public final void service(HttpServletRequest request, HttpServletResponse response)throws
{ 记录访问日志 进行权限判断 if(具有权限){
try{ } catch(Excetpion e)
{
记录异常信息 doService(request,response);IOExcetion,ServletException } } } protected abstract void doService(HttpServletRequest request, HttpServletResponse response)throws IOExcetion,ServletException;
//注意访问权限定义成protected，显得既专业，又严谨，因为它是专门给子类用的 }
public class MyServlet1 extends BaseServlet { protected void doService(HttpServletRequest request, HttpServletResponse response)throws IOExcetion,ServletException
} 父类方法中间的某段代码不确定，留给子类干，就用模板方法设计模式。
备注：这道题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等6个方面逐一去比较回答，接着从第三者继承的角度的回答，特别是最后用了一个典型的例子来展现自己深厚的技术功底。{ } 本Servlet只处理的具体业务逻辑代码
25、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
abstract的method 不可以是static的，因为抽象的方法是要被子类实现的，而static与子类扯不上关系！native方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与abstract混用。例如，FileOutputSteam类要硬件打交道，底层的实现用的是操作系统相关的api实现，例如，在windows用c语言实现的，所以，查看jdk 的源代码，可以发现FileOutputStream的open方法的定义如下：
private native void open(String name)throws FileNotFoundException;如果我们要用java调用别人写的c语言函数，我们是无法直接调用的，我们需要按照java的要求写一个c语言的函数，又我们的这个c语言函数去调用别人的c语言函数。由于我们的c语言函数是按java的要求来写的，我们这个c语言函数就可以与java对接上，java那边的对接方式就是定义出与我们这个c函数相对应的方法，java中对应的方法不需要写具体的代码，但需要在前面声明native。
关于synchronized与abstract合用的问题，我觉得也不行，因为在我几年的学习和开发中，从来没见到过这种情况，并且我觉得synchronized应该是作用在一个具体的方法上才有意义。而且，方法上的synchronized同步所使用的同步锁对象是this，而抽象方法上无法确定this是什么。
26、什么是内部类？Static Nested Class 和 Inner Class的不同。
内部类就是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似c语言的全局变量，而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示：
public class Outer {
} 在方法体外面定义的内部类的访问类型可以是public,protecte,默认的，private等4种类型，这就好像类中定义的成员变量有4种访问类型一样，它们决定这个内部类的定义对其他类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下：
Outer outer = new Outer();Outer.Inner1 inner1 = outer.new Innner1();
在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符。
对于这些细节，只要在eclipse写代码试试，根据开发工具提示的各类错误信息就可以马上了解到。public class Inner1
//在方法体外面定义的内部类 { } int out_x = 0;public void method(){
} Inner1 inner1 = new Inner1();public class Inner2
//在方法体内部定义的内部类 {
} Inner2 inner2 = new Inner2();public method(){ } out_x = 3;
在方法体内部还可以采用如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义名称：
public class Outer {
public void start(){ new Thread(new Runable(){ }).start();}
最后，在方法外部定义的内部类前面可以加上static关键字，从而成为Static Nested Class，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。Static Nested Class与普通类在运行时的行为和功能上没有什么区别，只是在编程引用时的语法上有一些差别，它可以定义成public、protected、默认的、private等多种类型，而普通类只能定义成public和默认的这两种类型。在外面引用Static Nested Class类的名称为“外部类名.内部类名”。在外面不需要创建外部类的实例对象，就可以直接创建Static Nested Class，例如，假设Inner是定义在Outer类中的Static Nested Class，那么可以使用如下语句创建Inner类：
Outer.Inner inner = new Outer.Inner();由于static Nested Class不依赖于外部类的实例对象，所以，static Nested Class能访问外部类的非static成员变量。当在外部类中访问Static Nested Class时，可以直接使用Static Nested Class的名字，而不需要加上外部类的名字了，在Static Nested Class中也可以直接引用外部类的static的成员变量，不需要加上外部类的名字。
在静态方法中定义的内部类也是Static Nested Class，这时候不能在类前面加static关键字，静态方法中的Static Nested Class与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的static的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加final修饰符。
备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义方式的语法区别，静态内部类，以及匿名内部类。} public void run(){};
27、内部类可以引用它的包含类的成员吗？有没有什么限制？
完全可以。如果不是静态内部类，那没有什么限制！
如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如，下面的代码：
class Outer { static int x;static class Inner {
} } void test(){ } syso(x);答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让人家满意，然后再说特殊情况，让人家吃惊。
28、Anonymous Inner Class(匿名内部类)是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?
可以继承其他类或实现其他接口。不仅是可以，而是必须!
29、super.getClass()方法调用
下面程序的输出结果是多少？
import java.util.Date;public class Test extends Date{
}
很奇怪，结果是Test 这属于脑筋急转弯的题目，在一个qq群有个网友正好问过这个问题，我觉得挺有趣，就研究了一下，没想到今天还被你面到了，哈哈。
在test方法中，直接调用getClass().getName()方法，返回的是Test类名 由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，在 test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用
super.getClass().getName()方法，所以，public static void main(String[] args){ }
public void test(){ } System.out.println(super.getClass().getName());new Test().test();super.getClass().getName()方法返回的也应该是Test。如果想得到父类的名称，应该用如下代码：
getClass().getSuperClass().getName();
30、String是最基本的数据类型吗?
基本数据类型包括byte、int、char、long、float、double、boolean和short。
java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类
31、String s = ”Hello“;s = s + ” world!“;这两行代码执行后，原始的String对象中的内容到底变了没有？
没有。因为String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。在这段代码中，s原先指向一个String对象，内容是 ”Hello“，然后我们对s进行了+操作，那么s所指向的那个对象是否发生了改变呢？答案是没有。这时，s不指向原来那个对象了，而指向了另一个 String对象，内容为”Hello world!“，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。
通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用String来代表字符串的话会引起很大的内存开销。因为 String对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个String对象来表示。这时，应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都new一个String。例如我们要在构造器中对一个名叫s的String引用变量进行初始化，把它设置为初始值，应当这样做：
public class Demo { private String s;...public Demo { s = ”Initial Value“;}...} 而非
s = new String(”Initial Value“);后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。至于为什么要把String类设计成不可变类，是它的用途决定的。其实不只String，很多Java标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以Java标准类库还提供了一个可变版本，即 StringBuffer。
32、是否可以继承String类?
String类是final类故不可以继承。
33、String s = new String(”xyz“);创建了几个String Object? 二者之间有什么区别？
两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多少遍，都是缓冲区中的那一个。New String每写一遍，就创建一个新的对象，它一句那个常量”xyz”对象的内容来创建出一个新String对象。如果以前就用过’xyz’，这句代表就不会创建”xyz”自己了，直接从缓冲区拿。
34、String 和StringBuffer的区别
JAVA平台提供了两个类：String和StringBuffer，它们可以储存和操作字符串，即包含多个字符的字符数据。这个String类提供了数值不可改变的字符串。而这个StringBuffer类提供的字符串进行修改。当你知道字符数据要改变的时候你就可以使用StringBuffer。典型地，你可以使用StringBuffers来动态构造字符数据。另外，String实现了equals方法，new String(“abc”).equals(new String(“abc”)的结果为true,而StringBuffer没有实现equals方法，所以，new StringBuffer(“abc”).equals(new StringBuffer(“abc”)的结果为false。
接着要举一个具体的例子来说明，我们要把1到100的所有数字拼起来，组成一个串。StringBuffer sbf = new StringBuffer();
for(int i=0;i<100;i++){ sbf.append(i);} 上面的代码效率很高，因为只创建了一个StringBuffer对象，而下面的代码效率很低，因为创建了101个对象。
String str = new String();
for(int i=0;i<100;i++){ str = str + i;} 在讲两者区别时，应把循环的次数搞成10000，然后用endTime-beginTime来比较两者执行的时间差异，最后还要讲讲StringBuilder与StringBuffer的区别。
String覆盖了equals方法和hashCode方法，而StringBuffer没有覆盖equals方法和hashCode方法，所以，将StringBuffer对象存储进Java集合类中时会出现问题。
35、如何把一段逗号分割的字符串转换成一个数组? 如果不查jdk api，我很难写出来！我可以说说我的思路： 1.用正则表达式，代码大概为：String [] result = orgStr.split(“,”);2.用 StingTokenizer ,代码为：StringTokenizer tokener = StringTokenizer(orgStr,”,”);String [] result = new String[tokener.countTokens()];Int i=0;while(tokener.hasNext(){result[i++]=toker.nextToken();}
36、数组有没有length()这个方法? String有没有length()这个方法？
数组没有length()这个方法，有length的属性。String有有length()这个方法。
37、下面这条语句一共创建了多少个对象：String s=”a“+”b“+”c“+”d“;答：对于如下代码： String s1 = ”a“;String s2 = s1 + ”b“;String s3 = ”a“ + ”b“;System.out.println(s2 == ”ab“);System.out.println(s3 == ”ab“);第一条语句打印的结果为false，第二条语句打印的结果为true，这说明javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。
题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个”abcd”的字符串，所以，上面的代码应该只创建了一个String对象。写如下两行代码，String s = ”a“ + ”b“ + ”c“ + ”d“;
System.out.println(s == ”abcd“);最终打印的结果应该为true。
38、try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?
也许你的答案是在return之前，但往更细地说，我的答案是在return中间执行，请看下面程序代码的运行结果：
public class Test {
static int test(){
} }
---------执行结果---------int x = 1;try { } finally { } ++x;return x;/** * @param args add by zxx ,Dec 9, 2008 */ public static void main(String[] args){
} // TODO Auto-generated method stub System.out.println(new Test().test());;1
运行结果是1，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。
39、下面的程序代码输出的结果是多少？
public class smallT {
} public static void main(String args[]){ smallT t = new smallT();int b = t.get();System.out.println(b);}
public int get(){ try {
return 1;} finally {
return 2;} } 返回的结果是2。
我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，try中的return语句调用的函数先于finally中调用的函数执行，也就是说return语句先执行，finally语句后执行，所以，返回的结果是2。Return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。
在讲解答案时可以用下面的程序来帮助分析：
public class Test {
int test(){
try { } return func1();/** * @param args add by zxx ,Dec 9, 2008 */ public static void main(String[] args){
} // TODO Auto-generated method stub System.out.println(new Test().test());;
}
} finally { } return func2();int func1(){
} int func2(){ System.out.println(”func2“);return 2;System.out.println(”func1“);return 1;}
-----------执行结果-----------------
func1 func2 2
结论：finally中的代码比return 和break语句后执行
40、final, finally, finalize的区别。
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
内部类要访问局部变量，局部变量必须定义成final类型，例如，一段代码……
finally是异常处理语句结构的一部分，表示总是执行。
finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用
41、运行时异常与一般异常有何异同？
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
42、error和exception有什么区别?
error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。
43、Java中的异常处理机制的简单原理和应用。
异常是指java程序运行时（非编译）所发生的非正常情况或错误，与现实生活中的事件很相似，现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息，可以用一个对象来表示，Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。
Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error 表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。
java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。
提示答题者：就按照三个级别去思考：虚拟机必须宕机的错误，程序可以死掉也可以不死掉的错误，程序不应该死掉的错误；
44、请写出你最常见到的5个runtime exception。
这道题主要考你的代码量到底多大，如果你长期写代码的，应该经常都看到过一些系统方面的异常，你不一定真要回答出5个具体的系统异常，但你要能够说出什么是系统异常，以及几个系统异常就可以了，当然，这些异常完全用其英文名称来写是最好的，如果实在写不出，那就用中文吧，有总比没有强！
所谓系统异常，就是…..，它们都是RuntimeException的子类，在jdk doc中查RuntimeException类，就可以看到其所有的子类列表，也就是看到了所有的系统异常。我比较有印象的系统异常有：NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException。
45、JAVA语言如何进行异常处理，关键字：throws,throw,try,catch,finally分别代表什么意义？在try块中可以抛出异常吗？
46、java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？
java5以前，有如下两种： 第一种：
new Thread(){}.start();这表示调用Thread子类对象的run方法，new Thread(){}表示一个Thread的匿名子类的实例对象，子类加上run方法后的代码如下： new Thread(){ public void run(){ } }.start();
第二种：
new Thread(new Runnable(){}).start();这表示调用Thread对象接受的Runnable对象的run方法，new Runnable(){}表示一个Runnable的匿名子类的实例对象,runnable的子类加上run方法后的代码如下： new Thread(new Runnable(){
public void run(){
}
}).start();
从java5开始，还有如下一些线程池创建多线程的方式： ExecutorService pool = Executors.newFixedThreadPool(3)for(int i=0;i<10;i++){ pool.execute(new Runable(){public void run(){}});} Executors.newCachedThreadPool().execute(new Runable(){public void run(){}});Executors.newSingleThreadExecutor().execute(new Runable(){public void run(){}});
有两种实现方法，分别使用new Thread()和new Thread(runnable)形式，第一种直接调用thread的run方法，所以，我们往往使用Thread子类，即new SubThread()。第二种调用runnable的run方法。
有两种实现方法，分别是继承Thread类与实现Runnable接口
用synchronized关键字修饰同步方法
反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被”挂起“的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。
47、sleep()和 wait()有什么区别?
（网上的答案：sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。）
sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，sleep方法并不会释放锁，即使当前线程使用sleep方法让出了cpu，但其他被同步锁挡住了的线程也无法得到执行。wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果notify方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在notfiy方法后增加一个等待和一些代码，看看效果），调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。对于wait的讲解一定要配合例子代码来说明，才显得自己真明白。
package com.huawei.interview;
public class MultiThread {
/** * @param args */ public static void main(String[] args){
// TODO Auto-generated method stub new Thread(new Thread1()).start();try {
}
} Thread.sleep(10);// TODO Auto-generated catch block e.printStackTrace();
} catch(InterruptedException e){ new Thread(new Thread2()).start();private static class Thread1 implements Runnable {
@Override public void run(){ // TODO Auto-generated method stub //由于这里的Thread1和下面的Thread2内部run方法要用同一对象作为监视器，我们这里不能用this，因为在Thread2里面的this和这个Thread1的this不是同一个对象。我们用MultiThread.class这个字节码对象，当前虚拟机里引用这个变量时，指向的都是同一个对象。
System.out.println(”enter thread1...“);
System.out.println(”thread1 is waiting“);try { synchronized(MultiThread.class){ //释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了synchronized关键字管辖的代码范围，另一种方式就是在synchronized关键字管辖的代码内部调用监视器对象的wait方法。这里，使用wait方法释放锁。
MultiThread.class.wait();
}
private static class Thread2 implements Runnable {
}
} } catch(InterruptedException e){
}
System.out.println(”thread1 is going on...“);System.out.println(”thread1 is being over!“);
// TODO Auto-generated catch block e.printStackTrace();
@Override public void run(){
// TODO Auto-generated method stub synchronized(MultiThread.class){
System.out.println(”enter thread2...“);
System.out.println(”thread2 notify other thread can release wait status..“);//由于notify方法并不释放锁，即使thread2调用下面的sleep方法休息了10毫秒，但thread1仍然不会执行，因为thread2没有释放锁，所以Thread1无法得不到锁。
}
}
} MultiThread.class.notify();
System.out.println(”thread2 is sleeping ten try {
}
System.out.println(“thread2 is going on...”);System.out.println(“thread2 is being over!”);Thread.sleep(10);// TODO Auto-generated catch block e.printStackTrace();} catch(InterruptedException e){ millisecond...“);}
48、同步和异步有何异同，在什么情况下分别使用他们？举例说明。
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
49.下面两个方法同步吗？（自己发明）
class Test { synchronized static void sayHello3()
} synchronized void getX(){} { }
50、多线程有几种实现方法?同步有几种实现方法?
多线程有两种实现方法，分别是继承Thread类与实现Runnable接口
同步的实现方面有两种，分别是synchronized,wait与notify
wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
51、启动一个线程是用run()还是start()?.启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。
52、当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?
分几种情况：
1.其他方法前是否加了synchronized关键字，如果没加，则能。
2.如果这个方法内部调用了wait，则可以进入其他synchronized方法。
3.如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。
4.如果其他方法是static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是this。
53、线程的基本概念、线程的基本状态以及状态之间的关系
一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行，每个程序至少都有一个线程，即main方法执行的那个线程。如果只是一个cpu，它怎么能够同时执行多段程序呢？这是从宏观上来看的，cpu一会执行a线索，一会执行b线索，切换时间很快，给人的感觉是a,b在同时执行，好比大家在同一个办公室上网，只有一条链接到外部网线，其实，这条网线一会为a传数据，一会为b传数据，由于切换时间很短暂，所以，大家感觉都在同时上网。
状态：就绪，运行，synchronize阻塞，wait和sleep挂起，结束。wait必须在synchronized内部调用。
调用线程的start方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到synchronized语句时，由运行状态转为阻塞，当synchronized获得锁后，由阻塞转为运行，在这种情况可以调用wait方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。
54、简述synchronized和java.util.concurrent.locks.Lock的异同 ？
主要相同点：Lock能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。
举例说明（对下面的题用lock进行了改写）：
package com.huawei.interview;
import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;
public class ThreadTest {
/** * @param args */
private int j;
private Lock lock = new ReentrantLock();public static void main(String[] args){
} private class Subtractor implements Runnable {
}
private class Adder implements Runnable {
@Override public void run(){
// TODO Auto-generated method stub while(true){ @Override public void run(){
} // TODO Auto-generated method stub while(true){
} /*synchronized(ThreadTest.this){ System.out.println(”j--=“ + j--);//这里抛异常了，锁能释放吗？ }*/ lock.lock();try { { } lock.unlock();System.out.println(”j--=“ + j--);}finally
// TODO Auto-generated method stub ThreadTest tt = new ThreadTest();for(int i=0;i<2;i++){
} new Thread(tt.new Adder()).start();new Thread(tt.new Subtractor()).start();
/*synchronized(ThreadTest.this){
System.out.println(”j++=“ + j++);
}*/
lock.lock();
try
{
System.out.println(”j++=“ + j++);
}finally
{
lock.unlock();
}
}
}
} }
55、设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。
以下程序使用内部类实现线程，对j增减的时候没有考虑顺序问题。
public class ThreadTest1 {
private int j;
public static void main(String args[]){
ThreadTest1 tt=new ThreadTest1();
Inc inc=tt.new Inc();
Dec dec=tt.new Dec();
for(int i=0;i<2;i++){
Thread t=new Thread(inc);
t.start();
t=new Thread(dec);
t.start();
}
}
private synchronized void inc(){
j++;
System.out.println(Thread.currentThread().getName()+”-inc:“+j);
}
private synchronized void dec(){
j--;
System.out.println(Thread.currentThread().getName()+”-dec:“+j);
} class Inc implements Runnable{
public void run(){
for(int i=0;i<100;i++){
inc();
}
} }
class Dec implements Runnable{
public void run(){
for(int i=0;i<100;i++){
dec();
}
} } }
----------随手再写的一个-------------class A { JManger j =new JManager();main(){ new A().call();}
void call { for(int i=0;i<2;i++){
new Thread（new Runnable(){ public void run(){while(true){j.accumulate()}}}).start();
new Thread(new Runnable(){ public void run(){while(true){j.sub()}}}).start();} } }
class JManager { private j = 0;
public synchronized void subtract(){
j--}
public synchronized void accumulate(){
j++;}
}
56、子线程循环10次，接着主线程循环100，接着又回到子线程循环10次，接着再回到主线程又循环100，如此循环50次，请写出程序。
最终的程序代码如下：
public class ThreadTest {
} public void run(){
}
for(int i=0;i<50;i++){
business.SubThread(i);
} public void init(){
final Business business = new Business();new Thread(new Runnable(){ } /** * @param args */ public static void main(String[] args){ // TODO Auto-generated method stub new ThreadTest().init();
}).start();
for(int i=0;i<50;i++){ business.MainThread(i);}
private class Business {
boolean bShouldSub = true;//这里相当于定义了控制该谁执行的一个信号灯 public synchronized void MainThread(int i){
}
public synchronized void SubThread(int i){
if(!bShouldSub)
try {
this.wait();// TODO Auto-generated catch block e.printStackTrace();} catch(InterruptedException e){ if(bShouldSub)
{ } bShouldSub = true;this.notify();System.out.println(Thread.currentThread().getName()+ try {
this.wait();// TODO Auto-generated catch block e.printStackTrace();
} catch(InterruptedException e){ }
for(int j=0;j<5;j++)”:i=“ + i +”,j=“ + j);}
for(int j=0;j<10;j++)
}
}
} { } bShouldSub = false;this.notify();
System.out.println(Thread.currentThread().getName()+ ”:i=“ + i +”,j=“ + j);备注：不可能一上来就写出上面的完整代码，最初写出来的代码如下，问题在于两个线程的代码要参照同一个变量，即这两个线程的代码要共享数据，所以，把这两个线程的执行代码搬到同一个类中去：
package com.huawei.interview.lym;
public class ThreadTest {
new Thread（new Runnable(){ public void run(){
private static boolean bShouldMain = false;
public static void main(String[] args){
// TODO Auto-generated method stub /*new Thread(){ public void run(){
}
//final String str = new String(”“);for(int i=0;i<50;i++){
for(int j=0;j<10;j++){ }
System.out.println(”i=“ + i + ”,j=“ + j);}
}.start();*/
}
}
for(int i=0;i<50;i++){
synchronized(ThreadTest.class){
if(bShouldMain){
}
for(int j=0;j<10;j++){
}
bShouldMain = true;
ThreadTest.class.notify();
System.out.println（”i=“ + i + ”,j=“ + j);
try {
}
ThreadTest.class.wait();} e.printStackTrace();
catch(InterruptedException e){ Thread.currentThread().getName()+
}
}).start();for(int i=0;i<50;i++){
synchronized(ThreadTest.class){
}
”i=“ + i + ”,j=“ + j);if(!bShouldMain){
try {
}
ThreadTest.class.wait();} e.printStackTrace();catch(InterruptedException e){ } { for(int j=0;j<5;j++)System.out.println（Thread.currentThread().getName()+
}
}
} bShouldMain = false;ThreadTest.class.notify();
}
下面使用jdk5中的并发库来实现的： import java.util.concurrent.Executors;import java.util.concurrent.ExecutorService;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;import java.util.concurrent.locks.Condition;
public class ThreadTest { private static Lock lock = new ReentrantLock();private static Condition subThreadCondition = lock.newCondition();private static boolean bBhouldSubThread = false;public static void main(String [] args){
ExecutorService threadPool = Executors.newFixedThreadPool(3);
threadPool.execute(new Runnable(){
public void run()
{
for(int i=0;i<50;i++)
{
lock.lock();
try
{
if(!bBhouldSubThread)
subThreadCondition.await();
for(int j=0;j<10;j++)
{
System.out.println(Thread.currentThread().getName()+ ”,j=“ + j);
}
bBhouldSubThread = false;
subThreadCondition.signal();
}catch(Exception e)
{
}
finally
{
}
}
lock.unlock();
}
}
}
});threadPool.shutdown();for(int i=0;i<50;i++){
lock.lock();
try
{
if(bBhouldSubThread)
subThreadCondition.await();
}
for(int j=0;j<10;j++){
System.out.println(Thread.currentThread().getName()+ ”,j=“ + j);} bBhouldSubThread = true;subThreadCondition.signal();
}catch(Exception e){
} finally { lock.unlock();}
57、介绍Collection框架的结构
答：随意发挥题，天南海北谁便谈，只要让别觉得你知识渊博，理解透彻即可。
58、Collection框架中实现比较要实现什么接口
comparable/comparator
59、ArrayList和Vector的区别
答：
这两个类都实现了List接口（List接口继承了Collection接口），他们都是有序集合，即存储在这两个集合中的元素的位置都是有顺序的，相当于一种动态的数组，我们以后可以按位置索引号取出某个元素，并且其中的数据是允许重复的，这是HashSet之类的集合的最大不同处，HashSet之类的集合不可以按索引号去检索其中的元素，也不允许有重复的元素（本来题目问的与hashset没有任何关系，但为了说清楚ArrayList与Vector的功能，我们使用对比方式，更有利于说明问题）。
接着才说ArrayList与Vector的区别，这主要包括两个方面：.（1）同步性：
Vector是线程安全的，也就是说是它的方法之间是线程同步的，而ArrayList是线程序不安全的，它的方法之间是线程不同步的。如果只有一个线程会访问到集合，那最好是使用ArrayList，因为它不考虑线程安全，效率会高些；如果有多个线程会访问到集合，那最好是使用Vector，因为不需要我们自己再去考虑和编写线程安全的代码。
备注：对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一诞生就提供了的，它们是线程安全的，ArrayList与HashMap是java2时才提供的，它们是线程不安全的。所以，我们讲课时先讲老的。（2）数据增长：
ArrayList与Vector都有一个初始的容量大小，当存储进它们里面的元素的个数超过了容量时，就需要增加ArrayList与Vector的存储空间，每次要增加存储空间时，不是只增加一个存储单元，而是增加多个存储单元，每次增加的存储单元的个数在内存空间利用与程序效率之间要取得一定的平衡。Vector默认增长为原来两倍，而ArrayList的增长策略在文档中没有明确规定（从源代码看到的是增长为原来的1.5倍）。ArrayList与Vector都可以设置初始的空间大小，Vector还可以设置增长的空间大小，而ArrayList没有提供设置增长空间的方法。
总结：即Vector增长原来的一倍，ArrayList增加原来的0.5倍。
60、HashMap和Hashtable的区别
（条理上还需要整理，也是先说相同点，再说不同点）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 interface的一个实现。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。
Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。
就HashMap与HashTable主要从三方面来说。
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，而HashMap是线程序不安全的，不是同步的
三.值：只有HashMap可以让你将空值作为一个表的条目的key或value
61、List 和 Map 区别? 一个是存储单列数据的集合，另一个是存储键和值这样的双列数据的集合，List中存储的数据是有顺序，并且允许重复；Map中存储的数据是没有顺序的，其键是不能重复的，它的值是可以有重复的。
62、List, Set, Map是否继承自Collection接口?
List，Set是，Map不是
63、List、Map、Set三个接口，存取元素时，各有什么特点？
这样的题属于随意发挥题：这样的题比较考水平，两个方面的水平：一是要真正明白这些内容，二是要有较强的总结和表述能力。如果你明白，但表述不清楚，在别人那里则等同于不明白。
首先，List与Set具有相似性，它们都是单列元素的集合，所以，它们有一个功共同的父接口，叫Collection。Set里面不允许有重复的元素，所谓重复，即不能有两个相等（注意，不是仅仅是相同）的对象，即假设Set集合中有了一个A对象，现在我要向Set集合再存入一个B对象，但B对象与A对象equals相等，则B对象存储不进去，所以，Set集合的add方法有一个boolean的返回值，当集合中没有某个元素，此时add方法可成功加入该元素时，则返回true，当集合含有与某个元素equals相等的元素时，此时add方法无法加入该元素，返回结果为false。Set取元素时，没法说取第几个，只能以Iterator接口取得所有的元素，再逐一遍历各个元素。
List表示有先后顺序的集合，注意，不是那种按年龄、按大小、按价格之类的排序。当我们多次调用add(Obj e)方法时，每次加入的对象就像火车站买票有排队顺序一样，按先来后到的顺序排序。有时候，也可以插队，即调用add(int index,Obj e)方法，就可以指定当前对象在集合中的存放位置。一个对象可以被反复存储进List中，每调用一次add方法，这个对象就被插入进集合中一次，其实，并不是把这个对象本身存储进了集合中，而是在集合中用一个索引变量指向这个对象，当这个对象被add多次时，即相当于集合中有多个索引指向了这个对象，如图x所示。List除了可以以Iterator接口取得所有的元素，再逐一遍历各个元素之外，还可以调用get(index i)来明确说明取第几个。
Map与List和Set不同，它是双列的集合，其中有put方法，定义如下：put(obj key,obj value)，每次存储时，要存储一对key/value，不能存储重复的key，这个重复的规则也是按equals比较相等。取则可以根据key获得相应的value，即get(Object key)返回值为key 所对应的value。另外，也可以获得所有的key的结合，还可以获得所有的value的结合，还可以获得key和value组合成的Map.Entry对象的集合。
List 以特定次序来持有元素，可有重复元素。Set 无法拥有重复元素,内部排序。Map 保存key-value值，value可多值。
HashSet按照hashcode值的某种运算方式进行存储，而不是直接按hashCode值的大小进行存储。例如，”abc“---> 78，”def“---> 62，”xyz“---> 65在hashSet中的存储顺序不是62,65,78，这些问题感谢以前一个叫崔健的学员提出，最后通过查看源代码给他解释清楚，看本次培训学员当中有多少能看懂源码。LinkedHashSet按插入的顺序存储，那被存储对象的hashcode方法还有什么作用呢？学员想想!hashset集合比较两个对象是否相等，首先看hashcode方法是否相等，然后看equals方法是否相等。new 两个Student插入到HashSet中，看HashSet的size，实现hashcode和equals方法后再看size。
同一个对象可以在Vector中加入多次。往集合里面加元素，相当于集合里用一根绳子连接到了目标对象。往HashSet中却加不了多次的。
64、说出ArrayList,Vector, LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。
65、去掉一个Vector集合中重复的元素
Vector newVector = new Vector();For(int i=0;i newVector.add(obj);} 还有一种简单的方式，HashSet set = new HashSet(vector);66、Collection 和 Collections的区别。 Collection是集合类的上级接口，继承与他的接口主要有Set 和List.Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。 67、Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别? Set里的元素是不能重复的，元素重复与否是使用equals()方法进行判断的。 equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。 68、你所知道的集合类都有哪些？主要方法？ 最常用的集合类是 List 和 Map。List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。List 适用于按数值索引访问元素的情形。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作”键“和”值“），其中每个键映射到一个值。 ArrayList/VectorList Collection HashSet/TreeSetSet PropetiesHashTable Map Treemap/HashMap 我记的不是方法名，而是思想，我知道它们都有增删改查的方法，但这些方法的具体名称，我记得不是很清楚，对于set，大概的方法是add,remove, contains；对于map，大概的方法就是put,remove，contains等，因为，我只要在eclispe下按点操作符，很自然的这些方法就出来了。我记住的一些思想就是List类会有get(int index)这样的方法，因为它可以按顺序取元素，而set类中没有get(int index)这样的方法。List和set都可以迭代出所有元素，迭代时先要得到一个iterator对象，所以，set和list类都有一个iterator方法，用于返回那个iterator对象。map可以返回三个集合，一个是返回所有的key的集合，另外一个返回的是所有value的集合，再一个返回的key和value组合成的EntrySet对象的集合，map也有get方法，参数是key，返回值是key对应的value。 69、两个对象值相同(x.equals(y)== true)，但却可有不同的hash code，这句话对不对? 对。 如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。 如果不是要保存在HashSet或HashMap，则与hashcode没有什么关系了，这时候hashcode不等是可以的，例如arrayList存储的对象就不用实现hashcode，当然，我们没有理由不实现，通常都会去实现的。 70、TreeSet里面放对象，如果同时放入了父类和子类的实例对象，那比较时使用的是父类的compareTo方法，还是使用的子类的compareTo方法，还是抛异常！ （应该是没有针对问题的确切的答案，当前的add方法放入的是哪个对象，就调用哪个对象的compareTo方法，至于这个compareTo方法怎么做，就看当前这个对象的类中是如何编写这个方法的）实验代码： public class Parent implements Comparable { } public class Child extends Parent { // TODO Auto-generated method stub public Child(){ } public int compareTo(Object o){ super(3);private int age = 0;public Parent(int age){ } public int compareTo(Object o){ } // TODO Auto-generated method stub System.out.println(”method of parent“);Parent o1 =(Parent)o;return age>o1.age?1:age } } System.out.println(”method of child“);Child o1 =(Child)o;return 1;// public class TreeSetTest { /** * @param args */ public static void main(String[] args){ } // TODO Auto-generated method stub TreeSet set = new TreeSet();set.add(new Parent(3));set.add(new Child());set.add(new Parent(4));System.out.println(set.size());} 71、说出一些常用的类，包，接口，请各举5个 要让人家感觉你对java ee开发很熟，所以，不能仅仅只列core java中的那些东西，要多列你在做ssh项目中涉及的那些东西。就写你最近写的那些程序中涉及的那些类。 常用的类：BufferedReader BufferedWriter FileReader FileWirter String Integer java.util.Date，System，Class，List,HashMap 常用的包：java.lang java.io java.util java.sql ,javax.servlet,org.apache.strtuts.action,org.hibernate 常用的接口：Remote List Map Document NodeList ,Servlet,HttpServletRequest,HttpServletResponse,Transaction(Hibernate)、Session(Hibernate),HttpSession 72、java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？ 字节流，字符流。字节流继承于InputStream OutputStream，字符流继承于InputStreamReader OutputStreamWriter。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。 73、字节流与字符流的区别 要把一片二进制数据数据逐一输出到某个设备中，或者从某个设备中逐一读取一片二进制数据，不管输入输出设备是什么，我们要用统一的方式来完成这些操作，用一种抽象的方式进行描述，这个抽象描述方式起名为IO流，对应的抽象类为OutputStream和InputStream，不同的实现类就代表不同的输入和输出设备，它们都是针对字节进行操作的。 在应用中，经常要完全是字符的一段文本输出去或读进来，用字节流可以吗？计算机中的一切最终都是二进制的字节形式存在。对于“中国”这些字符，首先要得到其对应的字节，然后将字节写入到输出流。读取时，首先读到的是字节，可是我们要把它显示为字符，我们需要将字节转换成字符。由于这样的需求很广泛，人家专门提供了字符流的包装类。 底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入。字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备，这为我们向IO设别写入或读取字符串提供了一点点方便。 字符向字节转换时，要注意编码的问题，因为字符串转成字节数组，其实是转成该字符的某种编码的字节形式，读取也是反之的道理。 讲解字节流与字符流关系的代码案例： import java.io.BufferedReader;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.FileReader;import java.io.FileWriter;import java.io.InputStreamReader;import java.io.PrintWriter; public class IOTest { public static void main(String[] args)throws Exception { String str = ”中国人“; /*FileOutputStream fos = new FileOutputStream(”1.txt“); fos.write(str.getBytes(”UTF-8“)); fos.close();*/ /*FileWriter fw = new FileWriter(”1.txt“); fw.write(str); fw.close();*/ PrintWriter pw = new PrintWriter(”1.txt“,”utf-8“); pw.write(str); pw.close(); /*FileReader fr = new FileReader(”1.txt“); } } char[] buf = new char[1024];int len = fr.read(buf);String myStr = new String(buf,0,len);System.out.println(myStr);*/ /*FileInputStream fr = new FileInputStream(”1.txt“);byte[] buf = new byte[1024];int len = fr.read(buf);String myStr = new String(buf,0,len,”UTF-8“);System.out.println(myStr);*/ BufferedReader br = new BufferedReader（new InputStreamReader（new FileInputStream(”1.txt“),”UTF-8“));String myStr = br.readLine();br.close();System.out.println(myStr);74、什么是java序列化，如何实现java序列化？或者请解释Serializable接口的作用。 我们有时候将一个java对象变成字节流的形式传出去或者从一个字节流中恢复成一个java对象，例如，要将java对象存储到硬盘或者传送给网络上的其他计算机，这个过程我们可以自己写代码去把一个java对象变成某个格式的字节流再传输，但是，jre本身就提供了这种支持，我们可以调用OutputStream的writeObject方法来做，如果要让java 帮我们做，要被传输的对象必须实现serializable接口，这样，javac编译时就会进行特殊处理，编译的类才可以被writeObject方法操作，这就是所谓的序列化。需要被序列化的类必须实现Serializable接口，该接口是一个mini接口，其中没有需要实现的方法，implements Serializable只是为了标注该对象是可被序列化的。 例如，在web开发中，如果对象被保存在了Session中，tomcat在重启时要把Session对象序列化到硬盘，这个对象就必须实现Serializable接口。如果对象要经过分布式系统进行网络传输或通过rmi等远程调用，这就需要在网络上传输对象，被传输的对象就必须实现Serializable接口。75、描述一下JVM加载class文件的原理机制? JVM中类的装载是由ClassLoader和它的子类来实现的,Java ClassLoader 是一个重要的Java运行时系统组件。它负责在运行时查找和装入类文件的类。 76、heap和stack有什么区别。 java的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。 堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用new创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使用final修饰后，放在堆中，而不是栈中。 77、GC是什么? 为什么要有GC? GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。 78、垃圾回收的优点和原理。并考虑2种回收机制。 Java语言中一个显著的特点就是引入了垃圾回收机制，使c++程序员最头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再有”作用域“的概念，只有对象的引用才有”作用域“。垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。 79、垃圾回收器的基本原理是什么？垃圾回收器可以马上回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？ 对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中的所有对象。通过这种方式确定哪些对象是”可达的“，哪些对象是”不可达的“。当GC确定一些对象为”不可达“时，GC就有责任回收这些内存空间。可以。程序员可以手动执行System.gc()，通知GC运行，但是Java语言规范并不保证GC一定会执行。 80、什么时候用assert。 assertion(断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，assert将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。 package com.huawei.interview; public class AssertTest { } /** * @param args */ public static void main(String[] args){ } // TODO Auto-generated method stub int i = 0;for(i=0;i<5;i++){ } //假设程序不小心多了一句--i;--i;assert i==5; System.out.println(i); 81、java中会存在内存泄漏吗，请简单描述。 所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。java中有垃圾回收机制，它可以保证一对象不再被引用的时候，即对象编程了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于Java 使用有向图的方式进行垃圾回收管理，可以消除引用循环的问题，例如有两个对象，相互引用，只要它们和根进程不可达的，那么GC也是可以回收它们的，例如下面的代码可以看到这种情况的内存回收： package com.huawei.interview; import java.io.IOException; public class GarbageTest { private static void gcTest()throws IOException { System.in.read();System.in.read();System.in.read();System.in.read();p1.setMate(p2);p2.setMate(p1);System.out.println(”before exit gctest!“);System.in.read();System.in.read();System.gc(); Person p2 = new Person(); Person p1 = new Person();/** * @param args * @throws IOException */ public static void main(String[] args)throws IOException { } // TODO Auto-generated method stub try { } System.out.println(”has exited gcTest!“);System.in.read();System.in.read(); System.out.println(”out begin gc!“);for(int i=0;i<100;i++){ } System.gc();System.in.read();System.in.read();gcTest();// TODO Auto-generated catch block e.printStackTrace();} catch(IOException e){ } } System.out.println(”exit gctest!");private static class Person { } byte[] data = new byte[20000000];Person mate = null;public void setMate(Person other){ } mate = other; java中的内存泄露的情况：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系统，我们加载了一个对象放在缓存中(例如放在一个全局map对象中)，然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。 检查java中的内存泄露，一定要让程序将各种分支情况都完整执行到程序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。 如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。 下面内容来自于网上（主要特点就是清空堆栈中的某个元素，并不是彻底把它从数组中拿掉，而是把存储的总数减少，本人写得可以比这个好，在拿掉某个元素时，顺便也让它从数组中消失，将那个元素所在的位置的值设置为null即可）： 我实在想不到比那个堆栈更经典的例子了,以致于我还要引用别人的例子，下面的例子不是我想到的，是书上看到的，当然如果没有在书上看到，可能过一段时间我自己也想的到，可是那时我说是我自己想到的也没有人相信的。 public class Stack { private Object[] elements=new Object[10];private int size = 0;public void push(Object e){ ensureCapacity();elements[size++] = e;} public Object pop(){ if(size == 0) throw new EmptyStackException(); return elements[--size]; } private void ensureCapacity(){ if(elements.length == size){ Object[] oldElements = elements; elements = new Object[2 * elements.length+1]; System.arraycopy(oldElements,0, elements, 0, size); } } } 上面的原理应该很简单，假如堆栈加了10个元素，然后全部弹出来，虽然堆栈是空的，没有我们要的东西，但是这是个对象是无法回收的，这个才符合了内存泄露的两个条件：无用，无法回收。 但是就是存在这样的东西也不一定会导致什么样的后果，如果这个堆栈用的比较少，也就浪费了几个K内存而已，反正我们的内存都上G了，哪里会有什么影响，再说这个东西很快就会被回收的，有什么关系。下面看两个例子。 例子1 public class Bad{ public static Stack s=Stack(); static{ s.push(new Object()); s.pop();//这里有一个对象发生内存泄露 s.push(new Object());//上面的对象可以被回收了，等于是自愈了 } } 因为是static，就一直存在到程序退出，但是我们也可以看到它有自愈功能，就是说如果你的Stack最多有100个对象，那么最多也就只有100个对象无法被回收其实这个应该很容易理解，Stack内部持有100个引用，最坏的情况就是他们都是无用的，因为我们一旦放新的进取，以前的引用自然消失！ 面试地点：浙江杭州高新人才市场(文三路199号)招聘会：浙江大华技术股份有限公司专场 前记：大年初六就出发了，今年必定将是个（忙碌+压力）的一年 最近一直在为面试做准备，两天前得知大华今天要在高新人才市场开招聘会，于是加紧了准备时间，因为没分配好时间，所以没达到很好的复习效果，一会看看培训期间的PPT，一会做做面试题，一会看看同学的笔记，一会改改简历，一会根据简历来复习，就这样，，最宝贵的两天针对性复习过去了。 2012年2月11日8点晨………………手机铃声响了………，下意识的知道要面对某些事了，迷迷糊糊听见某人的起床声，“哦，我也该起床了…可是我好困，我要再睡会儿“(心里默念道)。 起床了，起床了，，，杜**喊道，我眯了眯眼看着他，哦…… “是该起床了”，不情愿的掀开了被子，然后习惯性的按了下电脑左上角的启动按钮，还像石像似的发呆了一分钟，都过去两分钟了那些困意才像晨雾见到太阳似的渐渐的消失了。因为前天晚上一直到第二天凌晨一点半才睡，再加上失眠了一阵子。失眠是由于这次面试，因为大华的薪资、福利、待遇、休闲娱乐、企业文化都很不错的，所以我挺看重这次招聘会的。对于准备，自我感觉准备的还可以，但还是不够充分，所以在睡觉前，满脑子想的全是什么TCP/IP、UDP啊，SOCKET通信原理啊，汇编指令啊，linux的操作指令啊，mysql的操作语句啊，还有之前面试被提到的问题以及培训期间写的一些小项目啊……等等……等等，满脑子充斥着这些东西……还自己导演了一把面试对话：“假如被问到SOCKET通信原理该如何回答，如果被问TCP/IP协议的三次握手该怎么回答…………“。额，自己给自己当面试官回答的当然挺好的了，不知不觉就睡着了，，，直到凌晨那个刺耳的铃声。 刷牙，洗脸，几分钟搞定；因为最近理了个短寸，这头发是每隔一天不洗就变的更光亮些，因此我还经常指着头对朋友说：“你看我这发型多好，四天不洗，像抹了神马油似的，这么短，梳子的钱都省了。。“(其实几天不洗头，外表很光亮，但是有点痒，而且越挠越痒)下楼，，本来是想坐公交过去的，结果差半分钟没坐上K74，坑爹的K74弟弟一直到9点还没来，这招聘会都快开始了，被逼无奈之下揽了个的哥。打的就是TM的快，15分钟就到了。刚进招聘会大门，眼前近300平方的房间全是人，于是我就去找那个前两天联系我面试的人，结果她给我安排了一位大约30岁的面试官对我进行初步的了解。 开始面试了，首先是自我介绍，这个应该难不住一个会说话的人吧，每个人的回答方式都不一样，我是分三部分来介绍自己的。第一部分，自己的基本信息，如名字，毕业院校，哪里人，工作经验，培训经历，为什么来杭州等等。第二部分是个人喜好，比如说：有点宅，喜欢爬山，不喜欢看电影(高质量的影片除外)，不喜欢连续剧，不喜欢小说，第三部分是性格特点，比如说，喜欢交朋友，心细，比较关心周边的朋友。第四部分….(自由发挥)。也可以说一下自己的缺点，但是不要说的太严重，我记得有一次面试，我为了表现自己的诚恳，当面试官问我有什么缺点的时候，我说：自暴自弃，自控力差………，TMD当时面试官就傻了，我还试图力挽狂澜，解释这只是以前的缺点。可是这已经挽不回很差的印象了，所以对于这些致命的缺点Please Shut Up(因为我毕业前就是自己做一些事情，一直做到培训前，所以我面试经验基本上是0吧，而且每次都是表现的很诚恳，经常出闹剧，直接pass)。 有一些爱好我把产生的原因也加进去了，这样我就可以拖长面试时间，还可以让面试官更透彻的了解我。我在面试的时候是这样说的：之所以喜欢爬山是因为我喜欢超越的感觉，我并不会叫朋友用相机在那里咔咔咔的给我留下许多照片，因为我想把更多的时间放在征服这座山上，我想爬的更高、更远，每超越一个人我就都有一种小小的成就感，，，（略，，100字，，根据个人情况自由发挥）。 （自我介绍完毕就开始提问了，由于是初步的筛选，所以都比较简单）(下面是答题对话的过程，根据回忆，大概就是这样)第一题 考官：!@#$%^&*(我没理解题意)我(闷)：不知道怎么回答@#￥%……&*（）。 考官(换个方式问)：你用字符串给字符数组和字符指针初始化。我：写了char str1[10] = “abcdefg”;和char *str2 = “1234567”;考官：str1和str2有什么区别？ 我：str1是指向一个字符串的指针，str2是常量字符串指针，str1被分配了地址空间而str2没有分配地址空间，它只是指向这个常量字符串。 考官：字符串str1和str2分别是存在哪里？ 我：str1是存在栈上，str2是存在静态存储区。…………..略(100字扩展回答)…………..考官：写出你知道的用字符指针定义的变量； 我(自信的)：1,char *c;char **c;2,char *c[10];….3,char(*)[10];….4,char *(*)(int);5,char *((void*)())(int);等等写了大约10个，因为我对第五个不熟悉，也不知道写的对不对，于是他就在这个点上对我进行狂轰滥炸，幸亏我及时想起来了，那个是函数指针，于是我开始解释，，，此处略去五十字。分析：不要把自己往不熟悉的问题上扯，那样会引火烧身。 (就这样，我通过了初步面试，然后面试官就拿了张试卷给我，题目如下)(下面是题目，大家可以自己做一下，答案在最后面)1，已知文件in.txt,该文件记录某班级某门课的学生考试成绩，每次记录一条信息，格式为姓名+空格+成绩+回车换行，比如 //////////////////////////////////////////////////////////////////////////////////// In.txt中的数据 排完序写入out.txt 张三 86 …… 李四 79 => 王五 93 王五 93 => ……… ……….张三 86 赵六 71 ………… 李四 79 ………….赵六 71 //////////////////////////////////////////////////////////////////////////////////// 请编程实现对考试成绩按照从高到低的顺序排序，把结果输出到文件out.txt,函数声明如下，fin为输入文件，fout为输出文件，成功返回0，失败返回-1； Int fsort(const *fin,const char *fout);//要实现 2,一般的应用网络协议数据由帧头和帧数据体组成，帧头会描述数据的长度。请使用已经实现的数据接收函数recvData和帧数据处理函数processFrame，完成连续接收数据并封装成帧数据进行处理的函数recvAndProcessFrame.//数据帧头定义 Struct DataFrameHeader { } // 数据接收接口，buffer表示用来接收数据的缓冲，length是需要接收的长度 // 返回实际接收到数据的长度，如果接收失败返回-1.// 实际接收到的数据长度不定，但肯定小于或等于需要接收的数据长度length。Int recvData(void *buffer,int length);//处理帧数据接口，header是帧数据头指针，data是帧数据体指针。Void processFrame(DataFrameHeader *header,void *data);//连续接收数据并封装成帧数据进行处理，接收失败退出函数，否则继续接收并处理。void { } 3，链表节点定义如下： //…需要实现 recvAndProcessFrame()Int size;//…其它头数据 Struct Node { Int data;Node *next;}NODE;有两个链表，已经按data从小到大进行了排序，请编写编写链表合并函数，将两个链表合并为一个有序的链表。// NODE* connect(NODE *head1,NODE *head2){ } //////////////////////////////////////////////////////(因为我复习期间大部分时间放在了代码练习上，再加上一些小道消息，所以我基本上是顺水推舟般的完成了所有题目，写完了就立马交卷。)………………….写完试卷就去找对应的考官，我找到了他，不过要等他结束面前的工作，才可//…需要实现 以审阅我的卷子。(考官结束了手头工作，于是轮到我了)………………….我静坐在考官的对面，而他在阅我的试卷，此时的我只能看到试卷的北面，大约过了2分钟，我也静坐了2分钟，总觉得有点不舒服，于是我就站起来走到考官左侧面说：“如果有什么疑问就直接问我，，，,“.(此处省略50字，是关于个别代码的解释)。因为试卷做得还可以，用时又短(心里很得意)，于是在考官快阅完的时候我小小的装了下逼：“我是班级学习委员，我做这些题目很轻松的！@#￥%……&*（）“。其实我只是想表现一下自己有优秀的一面，唉，，事实证明我不应该装逼的，俗话说的好：”装逼遭雷劈“，虽然我没被雷劈，可是在后面我是被羞辱的体无完肤。(总结：低调点，小心驶得万年船，自大是考官讨厌的人之一)试卷这个环节结束了，考官说：“恩，你在这里等一下，我去找部门老大(应该是技术总监吧)面试你”，大约3分钟后我在窗口接到了‘老大’的电话，于是我在原地挥挥手，他在电话里说，“我看到你了“，于是我左右张望找了会终于看到了这位老大-----是位40多岁的中年人，于是开始了新一轮的面试。 第一题： 考官(大概的看了下我简历)：请写出一个互斥锁的例子。我(有点紧张)： (心里独白：我以为是叫我用汉字描述互斥锁的，由于我是在几个月前写过这样的代码，但是时间太久了，只记得理论知识，忘记代码了，于是我就宁愿相信是汉字描述)。这时，他把笔递给我，我才相信是要我写代码，于是我写了个循环语句，变量都没定义，真丢人啊，…….考官(看我不会写)：那你知道在编程中，是如何来保证共享数据操作的完整性？ 我(不自信的): 每个对象都对应于一个可称为“ 互斥锁” 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象(大概就是这个意思)。（分析：考察我对互斥锁的理解和编程能力）第二题 考官(写了个函数):看这个函数有错误吗？ Void GetMemory(char *p,int length)//length是申请内存空间的长度 { P=(char*)malloc(length);If(p!= NULL)Else Printf(“failn”);} 我(15秒内仔细的看了三遍小代码)： 斩钉截铁的回答“没问题“(晕，这个题目我都做过不知多少遍了，也是一个常考Printf(“success”);//内容记不得了所以用**表示 的基础题，竟然答错了，都怪我粗心没看完整个程序的意思，这个失误是让考官pass我的致命伤，牢记)。 (错误原因之一：由于考官的函数是分两次写的，第一次写了函数头Void GetMemory(char *p,int length)把纸递给我并给我解释了一下各变量的意思，然后又继续写下面的部分，写完后就把纸完全递交给我，我不知道怎么回事，完全忘记了函数头，这是个被调用的函数，而我把他当成主函数 里的代码分析了 int main(){ ***代码略*** }，于是我的所有注意力都盯在了代码过程上，仔细看了好几遍还是没发现问题，题目是挺简单的，可总觉得有不详的预感)。第二题分析：主要考察我对指针的掌握程度，TMD，指针是我在C语言那本书的所有章节里学的最好的，这题目也挺简单的，竟然在阴沟里翻船了，很不甘心，草。第二题总结：答题要仔细审题，再简单的问题也不要急于给答案。 第三题 考官(藐视状)：你看过哪些关于编程的书？说一说你最近看的且最喜欢看的那本书。 我：(内心独白：糟了，培训期间使用的课本不可以说吧？那我就没看过什么书了，C指针，C++prime神马的PDF只是2个月前看了看开头几个章节，因为感觉大部分知识都懂了，所以就没坚持往下看，年前、年后时间基本上都花在了面试题，百度文库和百度知道上。怕考官急，思考了很短时间便回答了)答：“我的大部分时间都花在了百度文库上了，我还有自己的百度博客，我那里转了不少好文章，还有自己总结了好多东西”。 考官(疑问状)：那你说出一篇你认为不错的文章。 我：(内心独白：我的时间分明是大部分花在了面试题上,年前在百度文库里看的文章也没什么印象了，基本上是遇到不懂的知识，泛泛的看一下，没深究，印象也不大，因为我怕考官急，于是没加思索的就说了篇还记得标题的文章。)答：《C语言和C++中’0’和NULL的区别》。 (分析：TMD,这次我是把自己往火坑里推了，这篇文章是我面试前一天晚上在百度文库里看到的，因为都凌晨2点了，太晚了，于是我就把文章下载到桌面准备抽时间看，其实只大概的看了前几行，文章的主体内容都是一扫而过)。 考官：那你说出“C语言和C++中’0’和NULL的区别”，至少三点。我(慢吞吞的)： 答：1，他们在内存中的值都是 0；2，都可以作为返回值。 (因为怕答错，实在不忍心再回答了)sorry，这篇文章写的有点深。 (第三题分析：课后多看些编程和嵌入式方面的书籍，丰富自己的知识面。)/////////////////////////// 回答完第三题，面试官对我说：“对不起，你今天的面试就到这里了，我们要选拔更优秀的人才”。 我垂头丧气的在凳子上坐着，大约过了一个半分钟。考官：怎么了？ 我：不甘心，准备了好多东西没被问到。(面试到此结束)下面是我面试时写的答案，根据我当时做的情况整理了下给大家做参考，没编译，可能有错误。1, typedef struct student { char name[10];int score;}STU; int fsort(const char *fin,const char *fout){ STU student_information[4];//用链表更好，我用这个演示用，简单点 FILE *file_in,*file_out;if((file_in = fopen(fin,“r”))== NULL){ printf(“cannot open file %sn.”,fin);return-1;} if((file_out = fopen(fout,“w”))== NULL){ printf(“cannot open file %s”,fout);return-1;} //feof(file_in))feof(file_in)结束是非0 结束是0 int i,j;for(i = 0;i < 4;i++)if(fscanf(file_in,“%s %d”,student_information [i].name,&student_information[i].score)!= 2){ printf(“read erro!n”);fclose(file_in);fclose(file_out);return-1;} //程序还少排序和写入，答案我就略去了，很简单的 //还是写上吧，免得有人嫌麻烦 //对数组中的数据进行排序 STU temp;For(I = 0;I < 3;I++){ For(j = i+1；j < 4;j++){ } } //向fout里写入排好序的数据 For(I = 0；I < 4;I++)If(student_information[i].score < student_information[j].score){ } Temp = student_information[i];student_information[i] = student_information[j];student_information[j] = temp;{ Fprintf(fout,“%s %d%c”, student_information[i].name, student_information[i].score,’n’);} //fscanf(fp,%s%d%lf,a,&b,&c)//返回值：整型，数值等于[argument...]的个数 } ////////////////////////////////////////////////////////////////////// 2, void recvAndProcessFrame(){ int rec_length;struct DataFrameHeader *h;//假设length = 512 char buff[512]; while(1){ 【嵌入式工程师面试宝典】相关文章： 嵌入式c语言面试题04-08 嵌入式软件工程师证04-07 嵌入式工程师待遇如何02-02 嵌入式软件工程师如何学习05-14 嵌入式工程师必知必会02-02 嵌入式软件工程师培养7步骤05-13 嵌入式软件工程师笔试题(含答案)05-05篇6：嵌入式工程师面试宝典