1549人阅读
从享受生活的角度上来说：“程序员并不是一种最好的职业，我认为两种人可以做程序员，第一，你不做程序员，你就没有什么工作可做，或者说是即使有可以做的工作但是你非常不愿意去做；第二，你非常痴迷和爱好程序，并且在这方面有一些天赋和优势。程序员的结局也是有两种：第一，默默退休，第二以程序员为起点或跳板，注意积累，跟对了好的老板或团队，找到和很好的搭档自己创业，成为IT金领和富翁。”
人们在时间面前是平等的，吾生也有涯，所以，你的经验更丰富点，那不算什么，经验是用时间积累的，你一生只有那么多时间，你能积累多少经验呢？最重要的是你的学习能力和学习方法，这个发挥的能量可以有很大差异，要提高学习能力和学习方法首先要学会思考和总结，要学会掌握事物的根本性的东西，而不是一些表面的细节。学习方法和学习能力对于IT工作者来说尤为重要，因为IT行业技术更新太快，并且细节太多，同一个技术的细节变来变去也是常有的事情，所以，IT技术学习者绝不能照着书籍和老师的讲解死记硬背和生搬硬套。搞IT工作很累人，如果学习方法不对、学习能力不强，那就更累了，不过，这怨不得别人，你的学习方法和学习能力只适合做刷盘子的工作，却非要跑到程序员圈子里来混，那谁能有办法拯救你！
在没有人指引的情况下，只能是自己一个知识点、一个知识点地漫无目的学习，等到积累了足够的知识量后，才有能力开始思考和琢磨原理方面的问题，这个学习过程很漫长。如果能在好老师的指引下，老师会启发你先思考原理问题，然后再去学习一个具体的知识点，让你能够举一反三、触类旁通，这样的学习效率就会更高。
多学了几个知识，并不能说明你就很厉害了，只能说是你比别人投入了更多的时间和精力而已，别人想做也能做到！不是你学了多少知识就算厉害了，关键是要用好学到的知识，要让学到的知识发挥出最大的社会价值和经济价值，这才是最厉害的。
另外，一个人的未来和造化，会深受环境的影响，所谓孟母三迁，近朱者赤、近墨者黑的大大道理，这些典故大家不一定能深刻领悟和感受，我们就不多说了。就拿现代比较接近我们生活的事例来说，如果你周围的朋友全是以擦皮鞋为生、每月辛辛苦苦下来就挣1500元，那么估计你的职业也是跟着擦皮鞋了，即使你再聪明和再勤奋，顶多每月比你那帮朋友多挣300元，合下来也就区区1800元/月。前几年只要抓住了大势，没钱全部找银行贷款了在北京买房、到山西开煤矿，是头猪也能每年大把大把地捞钱，如果你周围的朋友全是投机倒把的买房和开煤矿者，你的职业自然也是与他们干同样的事情，即使你再差，每年也能挣到百来万不成问题，这就是环境的重要性。聪明的你因为没有机会置身于炒房团中，比那些有机会接触炒房者的猪挣得就要少、就要累。到传智播客的环境中来，你就很有机会拿到高薪了，你可以不参加传智播客的培训，但只要想办法与传智播客的学员们住在一起，成功的机会就大多了。
自从我们开设3G的课程后，许多学员都找到了月薪在7k或更高的3g开发工作，这是他们的能力还完全不能与之相称的一份好工作，这些学员眼看到嘴的肥肉又舍不得放弃，最后就害苦我们这些老师了，学员纷纷把他们面试和工作中的要解决的问题带回来让我们老师帮助做，有些问题虽然老师能做，但也是要花费很大的时间和精力才能做的，这相当于学员把自己的工作交给我们老师替他去干了，可不是一句话两句话就解决的问题。哀哉！我们老师自己还有很繁重的备课和教学任务，我们的工作请谁来帮助做呢？同学们似乎没有替我们想过这个问题。
一个两个学员偶尔回来这么干还可以，但架不住一批批的学员都来这么干，加上有的学生还不太会说话，让人很无奈：
“很简单的，顶多占用你一个小时就搞定了！”，这么简单，你为何自己不干啊？
“今天晚上你必须做出来，明天就要交上去了”，哎，我再熬夜命都要丢了，老婆就要来砸电脑了，你叫我怎么办啊？
“你没时间干，那你吩咐其他老师干，也可以啊！”，当老师都是我的奴隶，我随时随地叫他们干啥，他们就干啥吗？老师能把教学做好，就很给我面子了。
现在这些公司怎么都越来越狡猾了，他们把日后工作中要解决的问题、并且是他们自己都很难解决的问题拿出来让面试求职者去搞，不管面试求职者的水平怎样，他们都说谁能搞定，谁就来上班，我们学生很高兴，不管自己水平是否适合做这份工作，反正有传智播客的老师可以依靠，拿回来就让我们做，还说“做好了就有高薪工作，这关于我一辈子的幸福，老师你自己看这个忙帮不帮吧？”，软件公司这招够狠！我们这批老师成了这些公司免费使用的超级劳工。如果奥巴马说你能把伊拉克摆平，我就让你当伊拉克总统，这个奥巴马都摆不平的事情，但因为做完了就可以当伊拉克总统，我们学生也可能拿回来让我们帮助做，让我们帮他摆平伊拉克，这对我们来说也是很难很难的事情啊。
1.&学习方向与面试简历的相关问题
如何过简历关？
我先讲解几个软件求职相关的真实故事，以帮助大家了解大多数软件开发企业是如何赛选简历和录用新员工的。
1.传智播客学员A是大四在读的应届毕业生，他自信技术学得很不错，实质上确实也达到用人单位的标准，他不愿意编写两年工作经验的虚假简历，希望凭借自己的真实情况去面对求职，投递了很多份简历，都没有回应；而他周围的很多相似背景的学员因为使用了假简历，都很快找到了薪水4.5k/月左右的工作，最后万不得已，他修改了自己的简历，增加了一些水分，以两年工作经验的身份去投递简历，结果就很快找到了满意的工作。
2.一个穿着和气质给人的印象都很不错的女生咨询时，问：“如果在传智播客学完了，能找到工作吗？”，我问了她一些基本情况后，得知她是郑州航空工业管理学院本科毕业，并且毕业时间已经有两年，谈话中感觉很有工作经验，英语也不错，所以，我斩钉截铁地告诉她：“她学完后绝对能找到一份满意的工作”，并说出了一些原因：（1）她本身的谈吐气质就决定了她找工作没问题，应聘工作除了要求有那些必需的技能外，关键一点还要看这个人的性格和素养，按她的条件，如果她要找软件开发方面的工作，只需要把技术补上就可以了，这一点在传智播客学习是很容易补上的；（2）要想找到好工作，除了掌握必需的技术外，通常都需要编写两年工作经验的简历，她的毕业是证确实两年前的，编造两年软件开发的工作经验更容易，至少不用专门去做假的毕业证了。她听完后，很赞同我的观念，说她现在就在一家软件公司做人力资源，负责挑选应聘者的简历，按领导的吩咐：“凡是工作经验低于两年的简历直接删除到垃圾桶”，可见，如果你的简历首先到达了类似这个女生的人力资源之手，即使你的技术再厉害，如果你的工作经验一栏上写得低于了两年，那简历就永无露脸之日了，何谈后来的笔试和面试呢？
3.与传智播客同一楼的一个软件开发单位，因为项目经理读过传智播客老师们的书籍和看过传智播客的视频，所以他们公司想到了从传智播客学员中招聘开发人员，提出薪水在2800元左后，我们公司老师对他们谁，2800元薪水，我们学员肯定看不上！他们公司说对于没有实际经验的新手开出2800元的薪水已经很不错了，我们老师说，传智播客学员通过简历包装都能找到平均4500元的工资，楼下公司说假简历他们一聊就能聊出来，没工作经验的人是骗不住他们的，我们的老师当时就无语了，…，因为就在前几天，我们就有一个学员成功潜伏进了他们公司，并且工资就是4500元，但我们老师不能当他们的面来说这事，就让他们一直蒙在鼓里还很自信吧！我用一个大饼的故事来说明这个问题吧，假如市场上卖的大饼都是10元一个，我也做了一个这样的大饼，比同类大饼还要好吃一点，我也买10元一个，你肯定愿意买，但是，一旦我告诉你，我这个大饼的原材料才5毛钱，你心里还会平衡吗？只会骂我太黑，5毛钱的成本居然卖出10元的暴利，你不会买我的大饼，因为这超出了你的心理承受，只要我不告诉你这么个实际情况，你则能欣然接受。也就是说，给你讲实话，你心里会难受，给你说假话，你心里则舒坦，相比市场上的同类产品，我这假话也算不上欺骗，毕竟你花10元买人家的大饼，还不如买我这个大饼好吃！
4.前面谈到简历上的工作经验很重要，可是大多数要找工作的同学往往是没有工作经验的，所以，只能在简历上加点水分。但是，只要你将简历上写成了两年以上的工作经验，是不是一定就能得到笔试和面试的机会呢？写两年工作经验只是有效简历的开始，离简历被用人单位相中还有一段差距。一个好的毕业学校、优秀的英语水平、中共党员的政治面貌、某省或直辖市的优秀毕业生、奥林匹克竞赛获几等奖等荣耀都会给用人单位一个很好的印象，如果你有这些荣耀，一定要在简历的基本信息部分写清楚。但是，很多人是没有这些荣耀的，那么只能平平淡淡列出自己的一些基本信息，这也没有很大的关系，顶多就是自己的简历不能脱颖而出，但是，对于软件工程师岗位来说，学历一栏怎么着也不能写为高中，起码也要写个大专或以上，毕业院校编个二线城市的不知名的小学院，如果你不愿意去做假证，等到别人面试你时，再说“闲弃以前上的学校不好，因为对编程太感兴趣，就辍学了！”
为什么说不需要做出完整的项目吗？
1.众所周知，在实际的软件项目中，都是很多人一块共同做一个项目，每个人只是做项目中的一部分内容，甚至是只做了项目中的一个模块，项目越大，越是如此！随便拿出一个中等大小的项目，也需要好多个熟练的开发人员开发好多个月才能勉强做得差不多，培训期间没有这么多时间，并且你还要先学会了很多技术后才能开始做项目。
&2.一个项目中的很多东西都是重复性的工作量的累积，技术方面都大同小异。做一个项目就好比盖一座楼房，只要告诉你整个楼房的整体结构，然后带着你盖上一间两间房子，其他剩下的几百间房子，老师想继续盖给你看，或者让你自己盖剩下的房间，你肯定也不愿意吧。以后有的是练手的机会，拿着人家发给你的工资，你再去做这些重复性的工作也不迟，岂不是更好！
业务重要？还是编码实战更重要？
1.对软件企业来说，两者都很重要，有的项目是业务为重心，有的则是以技术作为核心；以业务为重心的项目大都是企业信息化建设方面的项目，与做鞋差不多，没有多大技术含量和壁垒，只有积累了一定的经验，谁都可以做，利润很薄，例如大多数管理系统，靠的是人海战术和时间纠缠，做这种项目的程序员工作都很辛苦，经常要加班加点。而以技术为核心的项目则很有技术壁垒，不是谁都能做的，利润率很高，例如，360杀毒软件、baidu，qq，迅雷下载，大型bbs项目和淘宝这样的电子商务网站。
& 2.对程序员来说，编码实战更重要，业务则不算什么！程序员和软件公司的工作就是要把用户的需求和业务变成代码，即为人作嫁，一开始，需求和业务都在用户那里，用户最懂业务，你不用了解业务，你的任务就是了解用户的业务后编写代码，在开始做项目前，用户会把业务告诉给你的。一个软件公司从来都不是只做自己熟悉业务的项目，而是来了业务不熟悉的项目机会，肯定也会冲上去做，软件公司通常都是在做自己以前没做过的项目，即做以前不了解业务的项目，只有项目做完了才完全熟悉了业务，这才叫做项目，否则就成了卖产品了，所以，软件工程里说的需求调研和理解业务的过程，也是在从侧面说明，程序员是在接到项目之后才开始了解其业务的，而在此之前，对业务可以是完全不懂的。
是培训内容和信息量大好？还是培训内容少而精的好？
答：虽然这两种方式都能让学有所获和找到工作，并且，前者对于老师和学生要求都很高，老师教得很辛苦，学生学得也很辛苦，学生甚至会产生畏惧心理，即使水平已经很高，可能还是没有信心；后者对于老师和学生的要求都不高，老师教得轻松，学生学得愉快，学生很容易产生自信，成了井底之蛙，还自以为不得了。但是，内容和信息量大培训课程体系，对大多人来说是更收益的，因为，程序员做的工作总是在变化的，没有一成不变的工作，为了适应这种变化，你的知识面必须很广泛。如果你学的知识内容很少，即使你把这些内容练的滚瓜烂熟了，除非你出去找的一份工作正好就是你以前练习的那些东西，这时候会让人感觉你比谁都厉害，但这种千载难逢的好事怎么就被你碰上了呢？软件开发毕竟不同于刷盘子，不是在重复干一件事情。软件开发的工作总是要面临不同的需求和问题，如果培训课程的内容和信息量很大，即使由于时间关系，你暂时没有完全消化和熟练这么多内容，但是，你在工作中不管遇到什么新问题，都有那么一点点印象，知道大概的解决办法和思路，你就可以慢慢地通过查阅资料和最终解决这个问题，软件开发的工作本来就是这么一种现状，如果你学的知识量很少，一旦遇到了新问题，你完全就没有了思路，完全无从下手，这是何等痛苦，只有灰溜溜走人的份了吧。总之，知识面越宽广，了解的信息越多，解决问题的能力就越强，好比以前治疗哮喘没有很好的办法，即使是一个哮喘病专家医生，也需要让病人吃上半年的药，还不能完全治愈，现在，如果有了一种新药，病人只需要吃上一周，就能彻底治愈，所谓好的哮喘病专家医生，他要做的工作就是迅速知道有这么一种新药问世了，否则，他就成名符其实的庸医了。建筑大师可能自己连一个厕所都盖不出来，但是他能指导别人去干，建筑大师一定要阅历广泛，他经历过的项目很多，但每个项目的很多细节不是他亲力亲为。如果砌砖都是他亲力亲为，那他一辈子可能都是干砌砖工作了。
别的培训机构培养的是技术单一的熟练技工，传智播客培养的是具有很强学习和解决问题能力的技术高手和未来技术经理。很多工厂说，清华毕业的学生刚进工厂时的动手操作不如技校毕业的学生熟练，但过一段时间后，清华学生则能解决工厂生成过程出现中的各种新问题和弊端，甚至能提出创新和发明，后劲十足，因为清华培养的就不是一个单一工种的熟练工人，而是知识全面和具有创新能力的高级工程师。别的机构和传智播客培养出来的学生差别好比如此。
行业中也会出现蚁族和民工吗？
先看看IT蚁族和IT民工的悲惨命运吧！
搜素 程序员的悲哀，还有更多辛酸的故事，但是，我并不同情他们，我只是说他们自己无能！程序员这个职业能创造出许多年轻的富翁，不靠父母不靠天，还有那个职业比IT行业更有机会和诱惑呢。不过，程序员毁坏身体是真，可是，不让你做程序员，你去打游戏，聊QQ不也照样坏身体吗？
SSH（struts,spring,hibernate）是当前做管理信息系统最基本和最流行的通用技术，这几个技术都出现7,8年了，应该很普及了，确实没什么新意。现在培训机构教的都是这些玩意，用来混饭吃，还是管点用的。每个做增删改查的人基本都会SSH，所以，SSH没什么了不起的，SSH这套东西对培训公司和个人发展来说，都不能成为核心竞争力，都难以成大气候。一些公司内部所谓的核心技术，就是那些非SSH的知识，传智播客教的不只是大家都会的SSH。有点档次的项目，确实不怎么用SSH，但是大多数OA类的项目都是增删改查，虽然没有技术含量，但是用工需求量大，这也就是能诞生出IT蚁族和IT民工的由来。
但是，java不只是有SSH这套技术，如果你不想成为IT蚁族，如果你不想厌烦软件开发，那就不能只学SSH，这个没有太多技术含量的单一熟练工种。
2.&笔试答题技巧与若干问题
说明，为了节省大家的时间和提高学习效率，一些过时知识点和被笔试概率极低的题目不再被收录和分析。
回答问题的思路：先正面叙述一些基本的核心知识，然后描述一些特殊的东西，最后再来一些锦上添花的东西。要注意有些不是锦上添花，而是画蛇添足的东西，不要随便写上。把答题像写书一样写。我要回答一个新技术的问题大概思路和步骤是：我们想干什么，怎么干，干的过程中遇到了什么问题，现在用什么方式来解决。其实我们讲课也是这样一个思路。
例如，讲ajax时，我们希望不改变原来的整个网页，而只是改变网页中的局部内容，例如，用户名校验，级联下拉列表，下拉树状菜单。用传统方式，就是浏览器自己直接向服务器发请求，服务器返回新页面会盖掉老页面，这样就不流畅了。
对本面试宝典中的题目有信心吗？本来有信心的，结果听你讲完后，就没信心了！我非常理解。因为他觉得我的太深，他想记住我的些东西，可是记不住，所以没信心了。我又问：听懂了吗？他说听懂了。你到现在只要把你的理解尽量清晰地、有条理地表达出来，就很棒了。
这套面试题主要目的是帮助那些还没有java软件开发实际工作经验，而正在努力寻找java软件开发工作的朋友在笔试时更好地赢得笔试和面试。由于这套面试题涉及的范围很泛，很广，很杂，大家不可能一天两天就看完和学完这套面试宝典，即使你已经学过了有关的技术，那么至少也需要一个月的时间才能消化和掌握这套面试宝典，所以，大家应该早作准备，从拿到这套面试宝典之日起，就要坚持在每天闲暇之余学习其中几道题目，日积月累，等到出去面试时，一切都水到渠成，面试时就自然会游刃有余了。
答题时，先答是什么，再答有什么作用和要注意什么（这部分最重要，展现自己的心得）
答案的段落分别，层次分明，条理清晰都非常重要，从这些表面的东西也可以看出一个人的习惯、办事风格、条理等。
要讲你做出答案的思路过程，或者说你记住答案的思想都写下来。把答题想着是辩论赛。答题就是给别人讲道理、摆事实。答题不局限于什么格式和形式，就是要将自己的学识展现出来！
别因为人家题目本来就模棱两可，你就心里胆怯和没底气了，不敢回答了。你要大胆地指出对方题目很模糊和你的观点，不要把面试官想得有多高，其实他和你就是差不多的，你想想，如果他把你招进去了，你们以后就是同事了，可不是差不多的吗？
关于就业薪水，如果你是应届生，那不能要高工资，好比大饼的故事，没有文凭还想拿高工资，就去中关村缺什么补什么吧！少数人基础确实很好，在校期间确实又做过一些项目，那仍然是可以要到相对高的工资的。
公司招聘程序员更看重的要用到的编码技术、而不是那些业务不太相关的所谓项目经历：
1.公司想招什么样的人2.公司面试会问什么,.3.简历怎么写4怎样达到简历上的标准（培训中心教项目的目的）
对于一些公司接到了一些项目，想招聘一些初中级的程序员过来帮助写代码，完成这个项目，你更看重的是他的专业技术功底，还是以前做过几个项目的经历呢？我们先排除掉那些编码技术功底好，又正好做过相似项目的情况，实际上，这种鱼和熊掌兼得的情况并不常见。其实公司很清楚，只要招聘进来的人技术真的很明白，那他什么项目都可以做出来，公司招人不是让你去重复做你以前的项目，而是做一个新项目，业务方面，你只要进了项目团队，自然就能掌握。所以，大多数招聘单位在招聘那些编码级别的程序员时也没指望能招聘到做过类似项目的人，也不会刻意去找做过类似项目的人，用人单位也不是想把你招进，然后把你以前做过的项目重做一遍，所以，用人单位更看重招进来的人对要用到的编码技术的功底到底怎样，技术扎实不扎实，项目则只要跟着开发团队走，自然就没问题。除非是一些非常专业的行业，要招聘特别高级的开发人员和系统分析师，招聘单位才特别注重他的项目经验和行业经验，要去找到行业高手，公司才关心项目和与你聊项目的细节，这样的人通常都不是通过常规招聘渠道去招聘进来的，而是通过各种手段挖过来的，这情况不再我今天要讨论的范围中。
技术学得明白不明白，人家几个问题就把你的深浅问出来了，只要问一些具体的技术点，就很容易看出你是真懂还是假懂，很容看出你的技术深度和实力，所以，技术是来不得半点虚假的，必须扎扎实实。
由于项目的种类繁多，涉及到现实生活中的各行各业，什么五花八门的业务都有，例如，酒店房间预定管理，公司车辆调度管理，学校课程教室管理，超市进销存管理，知识内容管理，等等……成千上万等等，但是，不管是什么项目，采用的无非都是我们学习的那些目前流行和常用的技术。技术好、经验丰富，则项目做出来的效率高些，程序更稳定和更容易维护些；技术差点，碰碰磕磕最后也能把项目做出来，无非是做的周期长点、返工的次数多点，程序代码写得差些，用的技术笨拙点。如果一个人不是完完全全做过某个项目，他是不太关心该项目的业务的，对其中的一些具体细节更是一窍不知，(如果我招你来做图书管理，你项目经历说你做过汽车调度，那我能问你汽车调度具体怎么回事吗？不会，所以，你很容易蒙混过去的)而一个程序员的整个职业生涯中能实实在在和完完整整做出来的项目没几个，更别说在多个不同行业的项目了，有的程序员更是一辈子都只是在做某一个行业的项目，结果他就成了这个行业的专家(专门干一件事的家伙)。所以，技术面试官通常没正好亲身经历过你简历写的那些项目，他不可能去问你写的那些项目的具体细节，而是只能泛泛地问你这个项目是多少人做的，做了多长时间，开发的过程，你在做项目的过程中有什么心得和收获，用的什么技术等面上的问题，所以，简历上的项目经历可以含有很多水分，很容易作假，技术面试官也无法在项目上甄别你的真伪。
简历该怎么写：精通那些技术，有一些什么项目经历
教项目是为了巩固和灵活整合运用技术，增强学习的趣味性，熟悉做项目的流程，或得一些专业课程中无法获得的特有项目经验，增强自己面试的信心。讲的项目应该真实可靠才有价值，否则，表面上是项目，实际上还是知识点的整合，对巩固技术点和增强学习的趣味性，但无法获得实际的项目经验。（项目主要是增加你经验的可信度，获得更多面试机会，真正能不能找到工作，找到好工作，主要看你键盘上的功夫了），好的面试官几下就能面出你是否真有工作经验，他们问技术以外的公司的人和事，并且问开始、过程、结果，看你怎么编。
建议大家尽量开自己的blog，坚持每天写技术blog。在简历上写上自己的blog地址，可以多转载一些技术文章。
3.&笔试题之Java基础部分
基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语法，集合的语法，的语法，虚拟机方面的语法，其他。有些题来自网上搜集整理，有些题来自传智播客学员面试后的反馈，说真的，少数一些网上的面试题，我真怀疑其是否还有存在价值！
、一个源文件中是否可以包括多个类（不是内部类）？有什么限制？
可以有多个类，但只能有一个的类，并且的类名必须与文件名相一致。
中的保留字，现在没有在中使用。
、说说和的区别。
和都可以用作逻辑与的运算符，表示逻辑与（），当运算符两边的表达式的结果都为时，整个运算结果才为，否则，只要有一方为，则结果为。
还具有短路的功能，即如果第一个表达式为，则不再计算第二个表达式，例如，对于表达式，当为时，后面的表达式不会执行，所以不会出现如果将改为，则会抛出异常。会增长，不会增长
还可以用作位运算符，当操作符两边的表达式不是类型时，表示按位与操作，我们通常使用来与一个整数进行运算，来获取该整数的最低个位，例如，的结果为。
备注：这道题先说两者的共同点，再说出和的特殊之处，并列举一些经典的例子来表明自己理解透彻深入、实际经验丰富。
、在中如何跳出当前的多重嵌套循环？
在中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的语句，即可跳出外层循环。例如，
for(int j=0;j&10;j++)
System.out.println(“i=” + i + “,j=” + j);
if(j == 5)
另外，我个人通常并不使用标号这种方式，而是让外层的循环条件表达式的结果可以受到里层循环体代码的控制，例如，要在二维数组中查找到某个数字。
for(int j=0;j&arr[i].j++)
System.out.println(“i=” + i + “,j=” + j);
if(arr[i][j] &== 5)
&&&&&&&& found =
、语句能否作用在上，能否作用在上，能否作用在上
在（）中，只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是基本类型或包装类型，由于，都可以隐含转换为，所以，这些类型以及这些类型的包装类型也是可以的。显然，和类型都不符合的语法规定，并且不能被隐式转换成类型，所以，它们不能作用于语句中。
、有什么错有什么错
对于由于运算时会自动提升表达式的类型，所以结果是型，再赋值给类型时，编译器将报告需要强制转换类型的错误。
对于由于是语言规定的运算符，编译器会对它进行特殊处理，因此可以正确编译。
、型变量中能不能存贮一个中文汉字为什么
型变量是用来存储编码的字符的，编码字符集中包含了汉字，所以，型变量中当然可以存储汉字啦。不过，如果某个特殊的汉字没有被包含在编码字符集中，那么，这个型变量中就不能存储这个特殊汉字。补充说明：编码占用两个字节，所以，类型的变量也是占用两个字节。
备注：后面一部分回答虽然不是在正面回答题目，但是，为了展现自己的学识和表现自己对问题理解的透彻深入，可以回答一些相关的知识，做到知无不言，言无不尽。
、用最有效率的方法算出乘以等於几
因为将一个数左移位，就相当于乘以了的次方，那么，一个数乘以只要将其左移位即可，而位运算直接支持的，效率最高，所以，乘以等於几的最效率的方法是。
、请设计一个一百亿的计算器
首先要明白这道题目的考查点是什么，一是大家首先要对计算机原理的底层细节要清楚、要知道加减法的位运算原理和知道计算机中的算术运算会发生越界的情况，二是要具备一定的面向对象的设计思想。
首先，计算机中用固定数量的几个字节来存储的数值，所以计算机中能够表示的数值是有一定的范围的，为了便于讲解和理解，我们先以类型的整数为例，它用个字节进行存储，表示的最大数值范围为到。在内存中对应的二进制数据为，如果两个相加，不考虑运算时的类型提升，运算后会产生进位，二进制结果为，由于进位后超过了类型的存储空间，所以进位部分被舍弃，即最终的结果为，也就是，这正好利用溢位的方式实现了负数的运算。在内存中对应的二进制数据为，如果两个相加，不考虑运算时的类型提升，运算后会产生进位，二进制结果为，由于进位后超过了类型的存储空间，所以进位部分被舍弃，即最终的结果为，也就是，这样的结果显然不是我们期望的，这说明计算机中的算术运算是会发生越界情况的，两个数值的运算结果不能超过计算机中的该类型的数值范围。由于中涉及表达式运算时的类型自动提升，我们无法用类型来做演示这种问题和现象的实验，大家可以用下面一个使用整数做实验的例子程序体验一下：
int a = Integer.MAX_VALUE;
int b = Integer.MAX_VALUE;
int sum = a +
System.out.println(“a=”+a+”,b=”+b+”,sum=”+sum);
先不考虑类型，由于的正数范围为的次方，表示的最大数值约等于，也就是亿的大小，所以，要实现一个一百亿的计算器，我们得自己设计一个类可以用于表示很大的整数，并且提供了与另外一个整数进行加减乘除的功能，大概功能如下：
（）这个类内部有两个成员变量，一个表示符号，另一个用字节数组表示数值的二进制数
（）有一个构造方法，把一个包含有多位数值的字符串转换到内部的符号和字节数组中
（）提供加减乘除的功能
public Biginteger(String val)
public BigInteger add(BigInteger other)
public BigInteger subtract(BigInteger other)
public BigInteger multiply(BigInteger other)
public BigInteger divide(BigInteger other)
备注：要想写出这个类的完整代码，是非常复杂的，如果有兴趣的话，可以参看中自带的类的源码。面试的人也知道谁都不可能在短时间内写出这个类的完整代码的，他要的是你是否有这方面的概念和意识，他最重要的还是考查你的能力，所以，你不要因为自己无法写出完整的最终结果就放弃答这道题，你要做的就是你比别人写得多，证明你比别人强，你有这方面的思想意识就可以了，毕竟别人可能连题目的意思都看不懂，什么都没写，你要敢于答这道题，即使只答了一部分，那也与那些什么都不懂的人区别出来，拉开了距离，算是矮子中的高个，机会当然就属于你了。另外，答案中的框架代码也很重要，体现了一些面向对象设计的功底，特别是其中的方法命名很专业，用的英文单词很精准，这也是能力、经验、专业性、英语水平等多个方面的体现，会给人留下很好的印象，在编程能力和其他方面条件差不多的情况下，英语好除了可以使你获得更多机会外，薪水可以高出一千元。
、使用关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？
使用关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。例如，对于如下语句：
final&StringBuffer&a=new&StringBuffer(&immutable&);
执行如下语句将报告编译期错误：
但是，执行如下语句则可以通过编译：
有人在定义方法的参数时，可能想采用如下形式来阻止方法内部修改传进来的参数对象：
实际上，这是办不到的，在该方法内部仍然可以增加如下代码来修改参数对象：
param.append(&a&);
、和方法究竟有什么区别？
（单独把一个东西说清楚，然后再说清楚另一个，这样，它们的区别自然就出来了，混在一起说，则很难说清楚）
操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用操作符。
如果一个变量指向的数据是对象类型的，那么，这时候涉及了两块内存，对象本身占用一块内存（堆内存），变量也占用一块内存，例如变量是一个内存，是另一个内存，此时，变量所对应的内存中存储的数值就是对象占用的那块内存的首地址。对于指向对象类型的变量，如果要比较两个变量是否指向同一个对象，即要看这两个变量所对应的内存中的数值是否相等，这时候就需要用操作符进行比较。
方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。例如，对于下面的代码：
两条语句创建了两个对象，然后用这两个变量分别指向了其中一个对象，这是两个不同的对象，它们的首地址是不同的，即和中存储的数值是不相同的，所以，表达式将返回，而这两个对象中的内容是相同的，所以，表达式将返回。
在实际开发中，我们经常要比较传递进行来的字符串内容是否等，例如，，许多人稍不注意就使用进行比较了，这是错误的，随便从网上找几个项目实战的教学视频看看，里面就有大量这样的错误。记住，字符串的比较基本上都是使用方法。
如果一个类没有自己定义方法，那么它将继承类的方法，类的方法的实现代码如下：
这说明，如果一个类没有自己定义方法，它默认的方法（从类继承的）就是使用操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用和使用会得到同样的结果，如果比较的是两个独立的对象则总返回。如果你编写的类希望能够比较该类创建的两个实例对象的内容是否相同，那么你必须覆盖方法，由你自己写代码来决定在什么情况即可认为两个对象的内容是相同的。
、静态变量和实例变量的区别？
在语法定义上的区别：静态变量前要加关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个变量，并且每创建一个实例对象，这个就会加；但是，每创建一个实例对象，就会分配一个，即可能分配多个，并且每个的值都只自加了次。
&&&&&&&& System.out.println(“staticVar=” + staticVar + ”,instanceVar=” + instanceVar);
备注：这个解答除了说清楚两者的区别外，最后还用一个具体的应用例子来说明两者的差异，体现了自己有很好的解说问题和设计案例的能力，思维敏捷，超过一般程序员，有写作能力！
、是否可以从一个方法内部发出对非方法的调用？
不可以。因为非方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而方法调用时不需要创建对象，可以直接调用。也就是说，当一个方法被调用时，可能还没有创建任何实例对象，如果从一个方法中发出对非方法的调用，那个非方法是关联到哪个对象上的呢？这个逻辑无法成立，所以，一个方法内部发出对非方法的调用。
、与的区别
是提供的种原始数据类型之一。为每个原始类型提供了封装类，是为提供的封装类。的默认值为，而的默认值为，即可以区分出未赋值和值为的区别，则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为的区别，则只能使用。在开发中，的默认为，所以用表达式在文本框中显示时，值为空白字符串，而默认的默认值为，所以用表达式在文本框中显示时，结果为，所以，不适合作为层的表单数据的类型。
在中，如果将定义为类型，那么就可以根据其值是否为而判断一个对象是否是临时的，如果将定义为了类型，还需要在映射文件中设置其属性为。
另外，提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，中还定义了表示整数的最大值和最小值的常量。
、等於多少等於多少
类中提供了三个与取整有关的方法：、、，这些方法的作用与它们的英文名称的含义相对应，例如，的英文意义是天花板，该方法就表示向上取整，所以，的结果为的结果是；的英文意义是地板，该方法就表示向下取整，所以，的结果为的结果是；最难掌握的是方法，它表示“四舍五入”，算法为，即将原来的数字加上后再向下取整，所以，的结果为，的结果为。
、下面的代码有什么不妥之处
&&&&2.&&int&&x&= 1;
&&&&return&x==1?true:false;
、请说出作用域，，，以及不写时的区别
这四个作用域的可见范围如下表所示。
说明：如果在修饰的元素上面没有写任何访问修饰符，则表示。
作用域当前类同一子孙类其他
备注：只要记住了有种访问权限，个访问范围，然后将全选和范围在水平和垂直方向上分别按排从小到大或从大到小的顺序排列，就很容易画出上面的图了。
、和的区别。的方法是否可以改变返回值的类型
是重载的意思，是覆盖的意思，也就是重写。
重载表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。
重写表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。子类覆盖父类的方法时，只能比父类抛出更少的异常，或者是抛出父类抛出的异常的子异常，因为子类可以解决父类的一些问题，不能比父类有更多的问题。子类方法的访问权限只能比父类的更大，不能更小。如果父类的方法是类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。
至于的方法是否可以改变返回值的类型这个问题，要看你倒底想问什么呢？这个题目很模糊。如果几个的方法的参数列表不一样，它们的返回者类型当然也可以不一样。但我估计你想问的问题是：如果两个方法的参数列表完全一样，是否可以让它们的返回值不同来实现重载。这是不行的，我们可以用反证法来说明这个问题，因为我们有时候调用一个方法时也可以不定义返回结果变量，即不要关心其返回结果，例如，我们调用方法时，虽然方法有返回值，但是我们通常都不会定义接收返回结果的变量，这时候假设该类中有两个名称和参数列表完全相同的方法，仅仅是返回类型不同，就无法确定编程者倒底是想调用哪个方法了，因为它无法通过返回结果类型来判断。
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）；
2、不能通过访问权限、返回类型、抛出的异常进行重载；
3、方法的异常类型和数目不会对重载造成影响；
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。
、月号班同学贡献的一些题
朱wenchao，女：3500，21岁
搞了多个重载方法，参数分别是int ,char,和double，然后将double x = 2，传递进去，会选择哪个方法？
说说对javaee中的session的理解，你是怎么用session的？
陈yong, 4000
一个房子里有椅子，椅子有腿和背，房子与椅子是什么关系，椅子与腿和背是什么关系？
如果房子有多个椅子，就是聚合关系，否则是一种关联关系，当然，聚合是一种特殊的关联。椅子与腿和背时组合关系。
说说与的区别。
答：表示的是属于得关系。比如兔子属于一种动物（继承关系）。
表示组合，包含关系。比如兔子包含有腿，头等组件；
工厂模式的类图
．月号班同学贡献的一些题？
线程如何同步和通讯。同学回答说方法或代码块！面试官似乎不太满意！
只有多个代码块使用的是同一个监视器对象，这些代码块之间才具有线程互斥的效果，假如代码块用作为监视器对象，假如代码块用作为监视器对象，那么，两个并发的线程可以同时分别进入这两个代码块中。这里还可以分析一下同步的原理。
接着对于静态同步方法的分析，所用的同步监视器对象是该类的对象
接着对如何实现代码块与方法的同步进行分析。
如何加载。
里有多个类加载，每个类加载可以负责加载特定位置的类，例如，类加载负责加载中的类，我们平时用的中的类都位于中。负责加载中的类，负责指定的目录或中的类。除了之外，其他的类加载器本身也都是类，它们的父类是。
的生命周期
抽象类的作用
如何实现插入的数据按自定义的方式有序存放
具体异常的名称，我要查文档。
分层设计的好处；把各个功能按调用流程进行了模块化，模块化带来的好处就是可以随意组合，举例说明：如果要注册一个用户，流程为显示界面并通过界面接收用户的输入，接着进行业务逻辑处理，在处理业务逻辑又访问数据库，如果我们将这些步骤全部按流水帐的方式放在一个方法中编写，这也是可以的，但这其中的坏处就是，当界面要修改时，由于代码全在一个方法内，可能会碰坏业务逻辑和数据库访问的码，同样，当修改业务逻辑或数据库访问的代码时，也会碰坏其他部分的代码。分层就是要把界面部分、业务逻辑部分、数据库访问部分的代码放在各自独立的方法或类中编写，这样就不会出现牵一发而动全身的问题了。这样分层后，还可以方便切换各层，譬如原来的界面是，现在要改成界面，如果最初是按分层设计的，这时候不需要涉及业务和数据访问的代码，只需编写一条界面就可以了。
下面的仅供参考，不建议照搬照套，一定要改成自己的语言，发现内心的感受：
&&分层的好处：
&&&&&&&&1，实现了软件之间的解耦；
&&&&&&&&2.便于进行分工
&&&&&&&&3.便于维护
&&&&&&&&4，提高软件组件的重用
&&&&&&&&5.便于替换某种产品，比如持久层用的是hibernate,需要更换产品用toplink，就不用该其他业务代码，直接把配置一改。
&&&&&&&&6.便于产品功能的扩展。
&&&&&&&&7。便于适用用户需求的不断变化
序列化接口的有什么用？
&&&对象经常要通过IO进行传送，让你写程序传递对象，你会怎么做？把对象的状态数据用某种格式写入到硬盘，Person-&“zxx,male,28,30000”àPerson，既然大家都要这么干，并且没有个统一的干法，于是，sun公司就提出一种统一的解决方案，它会把对象变成某个格式进行输入和输出，这种格式对程序员来说是透明（transparent）的，但是，我们的某个类要想能被sun的这种方案处理，必须实现Serializable接口。
&&&ObjectOutputStream.writeObject(obj);
&&&Object obj = ObjectInputStream.readObject();
&&&假设两年前我保存了某个类的一个对象，这两年来，我修改该类，删除了某个属性和增加了另外一个属性，两年后，我又去读取那个保存的对象，或有什么结果？未知！sun的jdk就会蒙了。为此，一个解决办法就是在类中增加版本后，每一次类的属性修改，都应该把版本号升级一下，这样，在读取时，比较存储对象时的版本号与当前类的版本号，如果不一致，则直接报版本号不同的错!
方法的作用？说
（网友提供的一段，待改进：hashcode这个方法是用来鉴定2个对象是否相等的。
那你会说，不是还有equals这个方法吗？
不错，这2个方法都是用来判断2个对象是否相等的。但是他们是有区别的。
一般来讲，equals这个方法是给用户调用的，如果你想判断2个对象是否相等，你可以重写equals方法，然后在代码中调用，就可以判断他们是否相等了。简单来讲，equals方法主要是用来判断从表面上看或者从内容上看，2个对象是不是相等。举个例子，有个学生类，属性只有姓名和性别，那么我们可以认为只要姓名和性别相等，那么就说这2个对象是相等的。
hashcode方法一般用户不会去调用，比如在hashmap中，由于key是不可以重复的，他在判断key是不是重复的时候就判断了hashcode这个方法，而且也用到了equals方法。这里不可以重复是说equals和hashcode只要有一个不等就可以了！所以简单来讲，hashcode相当于是一个对象的编码，就好像文件中的md5，他和equals不同就在于他返回的是int型的，比较起来不直观。我们一般在覆盖equals的同时也要覆盖hashcode，让他们的逻辑一致。举个例子，还是刚刚的例子，如果姓名和性别相等就算2个对象相等的话，那么hashcode的方法也要返回姓名的hashcode值加上性别的hashcode值，这样从逻辑上，他们就一致了。
要从物理上判断2个对象是否相等，用==就可以了。
设计出计算任意正整数的阶层。
在数据库中需要查询出前条记录的语句怎么写？
什么是，谈谈你的的理解。
如何实现线程间的通讯。
新题目：编程编写一个函数将一个十六进制数的字符串参数转换成整数返回。
其实，也可以用，但面试官很可能是想考我们的编码基本功。
银行贷款的还款方式中最常用的是一种叫“等额本息”，还款法，即借款人在约定还款期限内的每一期（月）归还的金额（产生的利息部分本金）都是相等的，现有一笔总额为元的年期住房贷款，年利率为，要求算出每一期的还款的本金和利息总额，请写出解决思路和任意一种编程语言实现的主要代码。
思路：既然是按月还款，那我就要将年按月来计算，即要还个月，这样就可以求出每月要还的本金。由于每月要还的那部分本金所欠的时间不同，所以，它们所产生的利息是不同的，该部分本金的利息为：部分本金额所欠月数月利率。应该是这么个算法，如果利息还计利息，如果月还款不按年利率来算，老百姓算不明白的。
的是什么（学员注：除了，这些概念，还不太清楚的概念）
任意数字序列“”之类，输出它们所有的排列组合
什么是（学员注：会用，但感觉说不清楚）
我注：由上面这些题，可以看出，思想很重要，只有琢磨思想和原理的人才能很好地回答这些问题！
题的答案：
题的答案：
概念介绍：所谓，即就是面向方面的编程，
解释什么是方面：贯穿到系统的各个模块中的系统一个功能就是一个方面，
比如，记录日志，统一异常处理，事务处理，全限检查，这些功能都是软件系统
的一个面，而不是一点，在各个模块中都要出现。
什么是面向方面编程：把系统的一个方面的功能封装成对象的形式来处理
怎么进行面向方面编程：把功能模块对应的对象作为切面嵌入到原来的各个系统模块中，
采用代理技术，代理会调用目标，同时把切面功能的代码（对象）加入进来，所以，
用配置代理对象时只要要配两个属性，分别表示目标和切面对象（）。
、构造器是否可被
构造器不能被继承，因此不能重写，但可以被重载。
、接口是否可继承接口抽象类是否可实现接口抽象类是否可继承具体类抽象类中是否可以有静态的方法？
接口可以继承接口。抽象类可以实现接口，抽象类是否可继承具体类。抽象类中可以有静态的方法。
备注：只要明白了接口和抽象类的本质和作用，这些问题都很好回答，你想想，如果你是语言的设计者，你是否会提供这样的支持，如果不提供的话，有什么理由吗？如果你没有道理不提供，那答案就是肯定的了。
只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有方法。
、写方法时，通常都有一行代码，是什么？
有缺省行为，因为首先要把父类中的成员复制到位，然后才是复制自己的成员。
、面向对象的特征有哪些方面
计算机软件系统是现实生活中的业务在计算机中的映射，而现实生活中的业务其实就是一个个对象协作的过程。面向对象编程就是按现实业务一样的方式将程序代码按一个个对象进行组织和编写，让计算机系统能够识别和理解用对象方式组织和编写的程序代码，这样就可以把现实生活中的业务对象映射到计算机系统中。
面向对象的编程语言有封装、继承、抽象、多态等个主要的特征。
封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”，防止程序相互依赖性而带来的变动影响。在面向对象的编程语言中，对象是封装的最基本单位，面向对象的封装比传统语言的封装更为清晰、更为有力。面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。通常情况下，只要记住让变量和访问这个变量的方法放在一起，将一个类中的成员变量全部定义成私有的，只有这个类自己的方法才可以访问到这些成员变量，这就基本上实现对象的封装，就很容易找出要分配到这个类上的方法了，就基本上算是会面向对象的编程了。把握一个原则：把对同一事物进行操作的方法和相关的方法放在同一个类中，把方法和它操作的数据放在同一个类中。
例如，人要在黑板上画圆，这一共涉及三个对象：人、黑板、圆，画圆的方法要分配给哪个对象呢？由于画圆需要使用到圆心和半径，圆心和半径显然是圆的属性，如果将它们在类中定义成了私有的成员变量，那么，画圆的方法必须分配给圆，它才能访问到圆心和半径这两个属性，人以后只是调用圆的画圆方法、表示给圆发给消息而已，画圆这个方法不应该分配在人这个对象上，这就是面向对象的封装性，即将对象封装成一个高度自治和相对封闭的个体，对象状态（属性）由这个对象自己的行为（方法）来读取和改变。一个更便于理解的例子就是，司机将火车刹住了，刹车的动作是分配给司机，还是分配给火车，显然，应该分配给火车，因为司机自身是不可能有那么大的力气将一个火车给停下来的，只有火车自己才能完成这一动作，火车需要调用内部的离合器和刹车片等多个器件协作才能完成刹车这个动作，司机刹车的过程只是给火车发了一个消息，通知火车要执行刹车动作而已。
抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。例如，看到一只蚂蚁和大象，你能够想象出它们的相同之处，那就是抽象。抽象包括行为抽象和状态抽象两个方面。例如，定义一个Person类，如下：
class Person
人本来是很复杂的事物，有很多方面，但因为当前系统只需要了解人的姓名和年龄，所以上面定义的类中只包含姓名和年龄这两个属性，这就是一种抽像，使用抽象可以避免考虑一些与目标无关的细节。我对抽象的理解就是不要用显微镜去看一个事物的所有方面，这样涉及的内容就太多了，而是要善于划分问题的边界，当前系统需要什么，就只考虑什么。
在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要，这就是继承。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。
多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性。例如，下面代码中的UserDao是一个接口，它定义引用变量userDao指向的实例对象由在执行的时候返回，有时候指向的是这个实现，有时候指向的是这个实现，这样，不用修改源代码，就可以改变指向的具体类实现，从而导致方法调用的具体代码也随之改变，即有时候调用的是的方法，有时候调用的是的方法：
比喻：人吃饭，你看到的是左手，还是右手？
、中实现多态的机制是什么？
靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
、和有什么区别
含有修饰符的即为抽象类，类不能创建的实例对象。含有方法的类必须定义为，类中的方法不必是抽象的。类中定义抽象方法必须在具体子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为类型。
接口（）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为类型，接口中的成员变量类型默认为。
下面比较一下两者的语法区别：
抽象类可以有构造方法，接口中不能有构造方法。
抽象类中可以有普通成员变量，接口中没有普通成员变量
抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
抽象类中的抽象方法的访问类型可以是，和（默认类型虽然
下不报错，但应该也不行），但接口中的抽象方法只能是类型的，并且默认即为类型。
抽象类中可以包含静态方法，接口中不能包含静态方法
抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是类型，并且默认即为类型。
一个类可以实现多个接口，但只能继承一个抽象类。
下面接着再说说两者在应用上的区别：
接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的都继承这个抽象基类，在抽象基类的方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：
public final void service(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException
记录访问日志
进行权限判断
&&&&&&&& doService(request,response);
catch(Excetpion e)
记录异常信息
protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletE&
注意访问权限定义成，显得既专业，又严谨，因为它是专门给子类用的
本只处理的具体业务逻辑代码
父类方法中间的某段代码不确定，留给子类干，就用模板方法设计模式。
备注：这道题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等个方面逐一去比较回答，接着从第三者继承的角度的回答，特别是最后用了一个典型的例子来展现自己深厚的技术功底。
、的是否可同时是是否可同时是，是否可同时是
的不可以是的，因为抽象的方法是要被子类实现的，而与子类扯不上关系！
方法表示该方法要用另外一种依赖平台的编程语言实现的，不存在着被子类实现的问题，所以，它也不能是抽象的，不能与混用。例如，类要硬件打交道，底层的实现用的是操作系统相关的实现，例如，在用语言实现的，所以，查看的源代码，可以发现的方法的定义如下：
如果我们要用调用别人写的语言函数，我们是无法直接调用的，我们需要按照的要求写一个语言的函数，又我们的这个语言函数去调用别人的语言函数。由于我们的语言函数是按的要求来写的，我们这个语言函数就可以与对接上，那边的对接方式就是定义出与我们这个函数相对应的方法，中对应的方法不需要写具体的代码，但需要在前面声明。
关于与合用的问题，我觉得也不行，因为在我几年的学习和开发中，从来没见到过这种情况，并且我觉得应该是作用在一个具体的方法上才有意义。而且，方法上的同步所使用的同步锁对象是，而抽象方法上无法确定是什么。
、什么是内部类？和的不同。
内部类就是在一个类的内部定义的类，内部类中不能定义静态成员（静态成员不是对象的特性，只是为了找一个容身之处，所以需要放到一个类中而已，这么一点小事，你还要把它放到类内部的一个类中，过分了啊！提供内部类，不是为让你干这种事情，无聊，不让你干。我想可能是既然静态成员类似语言的全局变量，而内部类通常是用于创建内部对象用的，所以，把“全局变量”放在内部类中就是毫无意义的事情，既然是毫无意义的事情，就应该被禁止），内部类可以直接访问外部类中的成员变量，内部类可以定义在外部类的方法外面，也可以定义在外部类的方法体中，如下所示：
int out_x& = 0;
public void method()
&&&&&&&&&&&&&&&&&& {
Inner1 inner1 = new Inner1();
public class Inner2&& //在方法体内部定义的内部类
public method()
out_x = 3;
Inner2 inner2 = new Inner2();
public class Inner1&& //在方法体外面定义的内部类
在方法体外面定义的内部类的访问类型可以是默认的，等种类型，这就好像类中定义的成员变量有种访问类型一样，它们决定这个内部类的定义对其他类是否可见；对于这种情况，我们也可以在外面创建内部类的实例对象，创建内部类的实例对象时，一定要先创建外部类的实例对象，然后用这个外部类的实例对象去创建内部类的实例对象，代码如下：
在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用或修饰符。这种内部类对其他类是不可见的其他类无法引用这种内部类，但是这种内部类创建的实例对象可以传递给其他类访问。这种内部类必须是先定义，后使用，即内部类的定义代码必须出现在使用该类之前，这与方法中的局部变量必须先定义后使用的道理也是一样的。这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加修饰符。
对于这些细节，只要在写代码试试，根据开发工具提示的各类错误信息就可以马上了解到。
在方法体内部还可以采用如下语法来创建一种匿名内部类，即定义某一接口或类的子类的同时，还创建了该子类的实例对象，无需为该子类定义名称：
public void start()
new Thread(
public void run(){};
最后，在方法外部定义的内部类前面可以加上关键字，从而成为，它不再具有内部类的特性，所有，从狭义上讲，它不是内部类。与普通类在运行时的行为和功能上没有什么区别，只是在编程引用时的语法上有一些差别，它可以定义成、、默认的、等多种类型，而普通类只能定义成和默认的这两种类型。在外面引用类的名称为“外部类名内部类名”。在外面不需要创建外部类的实例对象，就可以直接创建，例如，假设是定义在类中的，那么可以使用如下语句创建类：
由于不依赖于外部类的实例对象，所以，能访问外部类的非成员变量。当在外部类中访问时，可以直接使用的名字，而不需要加上外部类的名字了，在中也可以直接引用外部类的的成员变量，不需要加上外部类的名字。
在静态方法中定义的内部类也是，这时候不能在类前面加关键字，静态方法中的与普通方法中的内部类的应用方式很相似，它除了可以直接访问外部类中的的成员变量，还可以访问静态方法中的局部变量，但是，该局部变量前必须加修饰符。
备注：首先根据你的印象说出你对内部类的总体方面的特点：例如，在两个地方可以定义，可以访问外部类的成员变量，不能定义静态成员，这是大的特点。然后再说一些细节方面的知识，例如，几种定义方式的语法区别，静态内部类，以及匿名内部类。
、内部类可以引用它的包含类的成员吗？有没有什么限制？
完全可以。如果不是静态内部类，那没有什么限制！
如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员变量，而只能访问外部类中的静态成员，例如，下面的代码：
void test()
答题时，也要能察言观色，揣摩提问者的心思，显然人家希望你说的是静态内部类不能访问外部类的成员，但你一上来就顶牛，这不好，要先顺着人家，让人家满意，然后再说特殊情况，让人家吃惊。
、匿名内部类是否可以继承其它类，是否可以实现接口
可以继承其他类或实现其他接口。不仅是可以，而是必须
、super.getClass()方法调用
下面程序的输出结果是多少？
import java.util.D
public&&class&Test&extends&Date{
&&&&publicstaticvoid&main(String[]
&&&&&&&new&Test().test();
&&&&publicvoid&test(){
&&&&&&&System.out.println(super.getClass().getName());
很奇怪，结果是Test
这属于脑筋急转弯的题目，在一个qq群有个网友正好问过这个问题，我觉得挺有趣，就研究了一下，没想到今天还被你面到了，哈哈。
在test方法中，直接调用getClass().getName()方法，返回的是Test类名
由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以，在
test方法中调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也应该是Test。
如果想得到父类的名称，应该用如下代码：
getClass().getSuperClass().getName();
中哪些类是不能继承的？
不能继承的是类是那些用关键字修饰的类。一般比较基本的类型或防止扩展类无意间破坏原来方法的实现的类型都应该是的，在中等都是基本类型。
、是最基本的数据类型吗
基本数据类型包括、、、、、、和。
类是类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用类
、这两行代码执行后，原始的对象中的内容到底变了没有？
没有。因为被设计成不可变类，所以它的所有对象都是不可变对象。在这段代码中，原先指向一个对象，内容是，然后我们对进行了操作，那么所指向的那个对象是否发生了改变呢？答案是没有。这时，不指向原来那个对象了，而指向了另一个对象，内容为，原来那个对象还存在于内存之中，只是这个引用变量不再指向它了。
通过上面的说明，我们很容易导出另一个结论，如果经常对字符串进行各种各样的修改，或者说，不可预见的修改，那么使用来代表字符串的话会引起很大的内存开销。因为对象建立之后不能再改变，所以对于每一个不同的字符串，都需要一个对象来表示。这时，应该考虑使用类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。并且，这两种类的对象转换十分容易。
同时，我们还可以知道，如果要使用内容相同的字符串，不必每次都一个。例如我们要在构造器中对一个名叫的引用变量进行初始化，把它设置为初始值，应当这样做：
后者每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为对象不可改变，所以对于内容相同的字符串，只要一个对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的类型属性都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，认为它们代表同一个对象。而用关键字调用构造器，总是会创建一个新的对象，无论内容是否相同。
至于为什么要把类设计成不可变类，是它的用途决定的。其实不只，很多标准类库中的类都是不可变的。在开发一个系统的时候，我们有时候也需要设计不可变类，来传递一组相关的值，这也是面向对象思想的体现。不可变类有一些优点，比如因为它的对象是只读的，所以多线程并发访问也不会有任何问题。当然也有一些缺点，比如每个不同的状态都要一个对象来代表，可能会造成性能上的问题。所以标准类库还提供了一个可变版本，即。
、是否可以继承类
类是类故不可以继承。
、创建了几个二者之间有什么区别？
两个或一个，对应一个对象，这个对象放在字符串常量缓冲区，常量不管出现多少遍，都是缓冲区中的那一个。每写一遍，就创建一个新的对象，它一句那个常量对象的内容来创建出一个新对象。如果以前就用过，这句代表就不会创建自己了，直接从缓冲区拿。
、和的区别
平台提供了两个类：和，它们可以储存和操作字符串，即包含多个字符的字符数据。类表示内容不可改变的字符串。而类表示内容可以被修改的字符串。当你知道字符数据要改变的时候你就可以使用。典型地，你可以使用来动态构造字符数据。另外，实现了方法，的结果为而没有实现方法，所以，的结果为。
接着要举一个具体的例子来说明，我们要把到的所有数字拼起来，组成一个串。
上面的代码效率很高，因为只创建了一个对象，而下面的代码效率很低，因为创建了个对象。
在讲两者区别时，应把循环的次数搞成，然后用来比较两者执行的时间差异，最后还要讲讲与的区别。
覆盖了方法和方法，而没有覆盖方法和方法，所以，将对象存储进集合类中时会出现问题。
和类都表示内容可以被修改的字符串，是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用。如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用，那么最好用。
、如何把一段逗号分割的字符串转换成一个数组
如果不查，我很难写出来！我可以说说我的思路：
用正则表达式，代码大概为：
用代码为：tokener = StringTokenizer(orgStr,”,”);
、数组有没有这个方法有没有这个方法？
数组没有这个方法，有的属性。有有这个方法。
、下面这条语句一共创建了多少个对象：
答：对于如下代码：
第一条语句打印的结果为，第二条语句打印的结果为，这说明编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。
题目中的第一行代码被编译器在编译时优化后，相当于直接定义了一个的字符串，所以，上面的代码应该只创建了一个对象。写如下两行代码，
最终打印的结果应该为。
、里有一个语句，那么紧跟在这个后的里的会不会被执行，什么时候被执行，在前还是后
也许你的答案是在之前，但往更细地说，我的答案是在中间执行，请看下面程序代码的运行结果：
public&&class&Test
&&&&&*@paramargsaddbyzxx,Dec9,2008
&&&&publicstaticvoid&main(String[]
&&&&&&&//&TODO&Auto-generated
method stub
&&&&&&&System.out.println(new&Test().test());;
&&&&static&int&test()
&&&&&&&int&x&= 1;
&&&&&&&try
&&&&&&&&&&&return&x;
&&&&&&&finally
&&&&&&&&&&&++x;
---------执行结果&---------
运行结果是，为什么呢？主函数调用子函数并得到结果的过程，好比主函数准备一个空罐子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说这话之前放进罐子里的。
、下面的程序代码输出的结果是多少？
返回的结果是。
我可以通过下面一个例子程序来帮助我解释这个答案，从下面例子的运行结果中可以发现，中的语句调用的函数先于中调用的函数执行，也就是说语句先执行，语句后执行，所以，返回的结果是。并不是让函数马上返回，而是语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行语句后才真正开始返回。
在讲解答案时可以用下面的程序来帮助分析：
public&&class&Test
&&&&&*@paramargsaddbyzxx,Dec9,2008
&&&&publicstaticvoid&main(String[]
&&&&&&&//&TODO&Auto-generated
method stub
&&&&&&&System.out.println(new&Test().test());;
&&&&int&test()
&&&&&&&try
&&&&&&&&&&&return&func1();
&&&&&&&finally
&&&&&&&&&&&return&func2();
&&&&int&func1()
&&&&&&&System.out.println(&func1&);
&&&&&&&return&1;
&&&&int&func2()
&&&&&&&System.out.println(&func2&);
&&&&&&&return&2;
结论：中的代码比和语句后执行
、的区别。
　　用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
内部类要访问局部变量，局部变量必须定义成类型，例如，一段代码
是异常处理语句结构的一部分，表示总是执行。
是类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。不保证此方法总被调用
、运行时异常与一般异常有何异同？
异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。
、和有什么区别
表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。
、中的异常处理机制的简单原理和应用。
异常是指程序运行时（非编译）所发生的非正常情况或错误，与现实生活中的事件很相似，现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息，可以用一个对象来表示，使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。
对异常进行了分类，不同类型的异常分别用不同的类表示，所有异常的根类为，下面又派生了两个子类：和，表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组脚本越界（），空指针异常（）、类转换异常（）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。
为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须处理或用声明继续抛给上层调用方法处理，所以普通异常也称为异常，而系统异常可以处理也可以不处理，所以，编译器不强制用处理或用声明，所以系统异常也称为异常。
提示答题者：就按照三个级别去思考：虚拟机必须宕机的错误，程序可以死掉也可以不死掉的错误，程序不应该死掉的错误；
、请写出你最常见到的个。
这道题主要考你的代码量到底多大，如果你长期写代码的，应该经常都看到过一些系统方面的异常，你不一定真要回答出个具体的系统异常，但你要能够说出什么是系统异常，以及几个系统异常就可以了，当然，这些异常完全用其英文名称来写是最好的，如果实在写不出，那就用中文吧，有总比没有强！
所谓系统异常，就是，它们都是的子类，在中查类，就可以看到其所有的子类列表，也就是看到了所有的系统异常。我比较有印象的系统异常有：、、。
、语言如何进行异常处理，关键字：分别代表什么意义？在块中可以抛出异常吗？
、中有几种方法可以实现一个线程？用什么关键字修饰同步方法和方法为何不推荐使用？
以前，有如下两种：
这表示调用子类对象的方法，表示一个的匿名子类的实例对象，子类加上方法后的代码如下：
这表示调用对象接受的对象的方法，表示一个的匿名子类的实例对象的子类加上方法后的代码如下：
从开始，还有如下一些线程池创建多线程的方式：
有两种实现方法，分别使用和形式，第一种直接调用的方法，所以，我们往往使用子类，即。第二种调用的方法。
有两种实现方法，分别是继承类与实现接口
用关键字修饰同步方法
反对使用，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。方法容易发生死锁。调用的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被挂起的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用，而应在自己的类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用命其进入等待状态。若标志指出线程应当恢复，则用一个重新启动线程。
、和有什么区别
（网上的答案：是线程类（）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用不会释放对象锁。是类的方法，对此对象调用方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出方法（或）后本线程才进入对象锁定池准备获得对象锁进入运行状态。）
就是正在执行的线程主动让出，去执行其他线程，在指定的时间过后，才会回到这个线程上继续往下执行，如果当前线程进入了同步锁，方法并不会释放锁，即使当前线程使用方法让出了，但其他被同步锁挡住了的线程也无法得到执行。是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了方法（并不释放锁，只是告诉调用过方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放。如果方法后面的代码还有很多，需要这些代码执行完后才会释放锁，可以在方法后增加一个等待和一些代码，看看效果），调用方法的线程就会解除状态和程序可以再次得到锁后继续向下运行。对于的讲解一定要配合例子代码来说明，才显得自己真明白。
package&com.huawei.
publicclass&MultiThread {
&&&&&*@paramargs
&&&&publicstaticvoid&main(String[]
&&&&&&&//&TODO&Auto-generated
method stub
&&&&&&&new&Thread(new&Thread1()).start();
&&&&&&&try&{
&&&&&&&&&&&Thread.sleep(10);
&&&&&&&}&catch&(InterruptedException e) {
&&&&&&&&&&&//&TODO&Auto-generated
catch block
&&&&&&&&&&&e.printStackTrace();
&&&&&&&new&Thread(new&Thread2()).start();&&&&
&&&&privatestaticclass&Thread1&implements&Runnable
&&&&&&&@Override
&&&&&&&publicvoid&run() {
&&&&&&&&&&&//&TODO&Auto-generated
method stub
//由于这里的Thread1和下面的Thread2内部run方法要用同一对象作为监视器，我们这里不能用this，因为在Thread2里面的this和这个Thread1的this不是同一个对象。我们用MultiThread.class这个字节码对象，当前虚拟机里引用这个变量时，指向的都是同一个对象。
&&&&&&&&&&&synchronized&(MultiThread.class)
&&&&&&&&&&&&&&System.out.println(&enter
thread1...&);
&&&&&&&&&&&&&
&&&&&&&&&&&&&&System.out.println(&thread1
is waiting&);
&&&&&&&&&&&&&&try&{
&&&&&&&&&&&//释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了synchronized关键字管辖的代码范围，另一种方式就是在synchronized关键字管辖的代码内部调用监视器对象的wait方法。这里，使用wait方法释放锁。
&&&&&&&&&&&&&&&&&&MultiThread.class.wait();
&&&&&&&&&&&&&&}&catch&(InterruptedException e) {
&&&&&&&&&&&&&&&&&&//&TODO&Auto-generated
catch block
&&&&&&&&&&&&&&&&&&e.printStackTrace();
&&&&&&&&&&&&&&}
&&&&&&&&&&&&&
&&&&&&&&&&&&&&System.out.println(&thread1
is going on...&);
&&&&&&&&&&&&&&System.out.println(&thread1
is being over!&);&&&&&&&
&&&&&&&&&&&}
&&&&privatestaticclass&Thread2&implements&Runnable
&&&&&&&@Override
&&&&&&&publicvoid&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 millisecond...&);
&&&&&&&&&&&&&&try&{
&&&&&&&&&&&&&&&&&&Thread.sleep(10);
&&&&&&&&&&&&&&}&catch&(InterruptedException e) {
&&&&&&&&&&&&&&&&&&//&TODO&Auto-generated
catch block
&&&&&&&&&&&&&&&&&&e.printStackTrace();
&&&&&&&&&&&&&&}
&&&&&&&&&&&&&
&&&&&&&&&&&&&&System.out.println(&thread2
is going on...&);
&&&&&&&&&&&&&&System.out.println(&thread2
is being over!&);
&&&&&&&&&&&&&
&&&&&&&&&&&}
、同步和异步有何异同，在什么情况下分别使用他们？举例说明。
如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。
当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。
下面两个方法同步吗？（自己发明）
&&&&class Test
synchronizedstaticvoid&sayHello3()
&&&&&&& }&&
&&&&&&&&synchronizedvoid&getX(){}
、多线程有几种实现方法同步有几种实现方法
多线程有两种实现方法，分别是继承类与实现接口
同步的实现方面有两种，分别是与
使一个线程处于等待状态，并且释放所持有的对象的。
使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉异常。
唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由确定唤醒哪个线程，而且不是按优先级。
唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
、启动一个线程是用还是
启动一个线程是调用方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，方法是该线程所关联的执行代码。
、当一个线程进入一个对象的一个方法后，其它线程是否可进入此对象的其它方法
分几种情况：
其他方法前是否加了关键字，如果没加，则能。
如果这个方法内部调用了，则可以进入其他方法。
如果其他个方法都加了关键字，并且内部没有调用，则不能。
如果其他方法是，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是。
、线程的基本概念、线程的基本状态以及状态之间的关系
一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行，每个程序至少都有一个线程，即方法执行的那个线程。如果只是一个，它怎么能够同时执行多段程序呢？这是从宏观上来看的，一会执行线索，一会执行线索，切换时间很快，给人的感觉是在同时执行，好比大家在同一个办公室上网，只有一条链接到外部网线，其实，这条网线一会为传数据，一会为传数据，由于切换时间很短暂，所以，大家感觉都在同时上网。
状态：就绪，运行，阻塞，和挂起，结束。必须在内部调用。
调用线程的方法后线程进入就绪状态，线程调度系统将就绪状态的线程转为运行状态，遇到语句时，由运行状态转为阻塞，当获得锁后，由阻塞转为运行，在这种情况可以调用方法转为挂起状态，当线程关联的代码执行完后，线程变为结束状态。
、简述和的异同？
主要相同点：能完成所实现的所有功能
主要不同点：有比更精确的线程语义和更好的性能。会自动释放锁，而一定要求程序员手工释放，并且必须在从句中释放。还有更强大的功能，例如，它的方法可以非阻塞方式去拿锁。
举例说明（对下面的题用进行了改写）：
package&com.huawei.
import&java.util.concurrent.locks.L
import&java.util.concurrent.locks.ReentrantL
publicclass&ThreadTest {
&&&&&*@paramargs
&&&&privateintj;
&&&&private&Lock&lock&=&new&ReentrantLock();
&&&&publicstaticvoid&main(String[]
&&&&&&&//&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();
&&&&privateclass&Subtractor&implements&Runnable
&&&&&&&@Override
&&&&&&&publicvoid&run() {
&&&&&&&&&&&//&TODO&Auto-generated
method stub
&&&&&&&&&&&while(true)
&&&&&&&&&&&{
&&&&&&&&&&&&&&/*synchronized (ThreadTest.this) {&&&&&&&
&&&&&&&&&&&&&&&&&&System.out.println(&j--=& + j--);
&&&&&&&&&&&&&&&&&&//这里抛异常了，锁能释放吗？
&&&&&&&&&&&&&&}*/
&&&&&&&&&&&&&&lock.lock();
&&&&&&&&&&&&&&try
&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&System.out.println(&j--=&&+&j--);
&&&&&&&&&&&&&&}finally
&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&lock.unlock();
&&&&&&&&&&&&&&}
&&&&&&&&&&&}
&&&&privateclass&Adder&implements&Runnable
&&&&&&&@Override
&&&&&&&publicvoid&run() {
&&&&&&&&&&&//&TODO&Auto-generated
method stub
&&&&&&&&&&&while(true)
&&&&&&&&&&&{
&&&&&&&&&&&&&&/*synchronized (ThreadTest.this) {
&&&&&&&&&&&&&&System.out.println(&j++=& + j++);&
&&&&&&&&&&&&&&}*/
&&&&&&&&&&&&&&lock.lock();
&&&&&&&&&&&&&&&try
&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&System.out.println(&j++=&&+&j++);
&&&&&&&&&&&&&&}finally
&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&lock.unlock();
&&&&&&&&&&&&&&}&&&&&&&&&&&&
&&&&&&&&&&&}&&&&&&&&&
、设计个线程，其中两个线程每次对增加，另外两个线程对每次减少。写出程序。
以下程序使用内部类实现线程，对增减的时候没有考虑顺序问题。
随手再写的一个
、子线程循环次，接着主线程循环，接着又回到子线程循环次，接着再回到主线程又循环，如此循环次，请写出程序。
最终的程序代码如下：
publicclass&ThreadTest {
&&&&&*@paramargs
&&&&publicstaticvoid&main(String[]
&&&&&&&//&TODO&Auto-generated
method stub
&&&&&&&new&ThreadTest().init();
&&&&publicvoid&init()
&&&&&&&final&Business business =&new&Business();
&&&&&&&new&Thread(
&&&&&&&&&&&&&&new&Runnable()
&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&publicvoid&run()
&&&&&&&&&&&&&&&&&&&&&for(int&i=0;i&50;i++)
&&&&&&&&&&&&&&&&&&&&&{
&&&&&&&&&&&&&&&&&&&&&&&&&business.SubThread(i);
&&&&&&&&&&&&&&&&&&&&&}&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&}
&&&&&&&).start();
&&&&&&&for(int&i=0;i&50;i++)
&&&&&&&&&&&business.MainThread(i);
&&&&&&&}&&&&&
&&&&privateclass&Business
&&&&&&&booleanbShouldSub&=&true;//这里相当于定义了控制该谁执行的一个信号灯
&&&&&&&publicsynchronizedvoid&MainThread(int&i)
&&&&&&&&&&&if(bShouldSub)
&&&&&&&&&&&&&&try&{
&&&&&&&&&&&&&&&&&&this.wait();
&&&&&&&&&&&&&&}&catch&(InterruptedException e) {
&&&&&&&&&&&&&&&&&&//&TODO&Auto-generated
catch block
&&&&&&&&&&&&&&&&&&e.printStackTrace();
&&&&&&&&&&&&&&}&&&&&
&&&&&&&&&&&&&
&&&&&&&&&&&for(int&j=0;j&5;j++)
&&&&&&&&&&&{
&&&&&&&&&&&&&&System.out.println(Thread.currentThread().getName() +&&:i=&&+
i +&,j=&&+ j);
&&&&&&&&&&&}
&&&&&&&&&&&bShouldSub&=&true;
&&&&&&&&&&&this.notify();
&&&&&&&publicsynchronizedvoid&SubThread(int&i)
&